Archivos para abril, 2017

Arduino es una plataforma prácticamente infinita para todo tipo de aplicaciones como lo hemos visto en este humilde blog de entre millones que existen en la web. En este espacio comenzamos con aplicaciones de Hacking, luego incursionamos en la fascinante disciplina de la Robótica y últimamente avanzamos sobre increíble universo de los Videojuegos.

Anteriormente publicamos juegos (basados en la librería VGAx desarrollada por Sandro Maffiodo) como, por ejemplo:

Y juegos más sencillos basados simplemente en LEDs y pulsadores como

En esta ocasión continuaremos con la construcción de juegos sencillos, pero algo más elaborados utilizando matrices de LEDs controladas por el circuito integrado MAX7219.
Pong (o Tele-Pong) fue un videojuego de la primera generación de videoconsolas publicado por Atari, creado por Nolan Bushnell y lanzado el 29 de noviembre de 1972. Pong está basado en el deporte de tenis de mesa (o ping pong). La palabra Pong es una marca registrada por Atari Interactive, mientras que la palabra genérica «pong» es usada para describir el género de videojuegos «bate y bola». La popularidad de Pong dio lugar a una demanda de infracción de patentes y ganada por parte de los fabricantes de Magnavox Odyssey, que poseía un juego similar.
Pong es un juego de deportes en dos dimensiones que simula un tenis de mesa. El jugador controla en el juego una paleta moviéndola verticalmente en la parte izquierda de la pantalla, y puede competir tanto contra un oponente controlado por computadora, como con otro jugador humano que controla una segunda paleta en la parte opuesta. Los jugadores pueden usar las paletas para pegarle a la pelota hacia un lado u otro. El objetivo consiste en que uno de los jugadores consiga más puntos que el oponente al finalizar el juego. Estos puntos se obtienen cuando el jugador adversario falla al devolver la pelota.

Este videojuego es un verdadero clásico y es sumamente adictivo para jugar durante breves intervalos de tiempo. Ya sea esperando un micro o taxi, alguna hora o minutos libres en la Universidad o Colegio, o simplemente de noche hasta que logramos conciliar el sueño.
Esta variante contiene tres niveles de dificultad aumentado la velocidad de desplazamiento de la pelota a medida que avanzamos de nivel. En el último nivel la pelota se desplaza muy rápidamente, no apto para cardíacos, y si logramos superar este nivel ocurre una secuencia que podrán observar en el gameplay que se encuentra al final de la publicación y solo apto para verdaderos fanáticos.

La Matriz de LEDs

Una matriz LEDs es un display formado por múltiples LEDs en distribución rectangular. Existen distintos tamaños, siendo el más habitual los cuadrados de 8×8 LEDs.
Podemos combinar varios módulos para formar un display mucho mayor. En estos display podemos mostrar textos, dibujos o animaciones, como desplazar un texto (scroll).
Por lo demás, son diodos LEDs totalmente normales, organizados en forma de matriz, que tendremos que multiplexar para poder iluminar uno u otro punto.
Si los diodos se unen por el positivo, se dice que son matrices de Ánodo común, y si se une por el negativo decimos que son de Cátodo común. Dependiendo del fabricante podemos encontrar de ambos tipos.

Encender una matriz de LEDs directamente con Arduino requiere emplear una gran cantidad de pines, lo cual supondría un gran desperdicio de recursos. Por este motivo, lo normal es siempre utilizar un controlador específicamente diseñado para esta función. Un controlador habitualmente empleado por ser barato y sencillo es el circuito integrado MAX7219.

Circuito Integrado MAX7219

Encender una matriz de 8×8 LED requeriría 16 señales digitales y un trabajo constante del procesador para refrescar la imagen. Eso es una cantidad enorme de recursos para cualquier autómata, que estaríamos desperdiciando para simplemente encender un display.
Por este motivo, utilizamos el circuito integrado MAX7219 que está especialmente diseñado para encender displays de 7 segmentos y matrices de LEDs, liberando al procesador para hacer tareas mucho más valiosas y productivas.
La comunicación con el circuito integrado MAX7219 se realiza mediante el bus SPI por lo que sólo se requieren 3 pines de Arduino (SS, MOSI y SCK). Además, ni siquiera “ocupamos” en su totalidad estos pines, ya que con el mismo bus podemos controlar múltiples dispositivos.
Por último, las placas MAX7219 generalmente incorporan un puerto de entrada y salida, de forma que podemos combinar múltiples controladores sin ninguna dificultad.
MAX7219 Datasheet

El diagrama esquemático de esta variante de Arduino Pong se observa en la siguiente imagen:

(click para ampliar)

Lista de Componentes
1 Resistencia 10KΩ 0.25W
1 Potenciómetro Lineal 10KΩ
1 Transistor NPN 2SC1815
2 Módulos con Matrices de LEDs 8×8 con Circuito Integrado MAX7219 c/u. Cátodo Común [Color Rojo en caso de aplicar Red Mod]
1 Buzzer Pasivo 5V
1 Placa Arduino Nanino
Librería LedControl desarrollada por wayoda

#include <LedControl.h>

#define DATA_PIN    12
#define CLOCK_PIN   11
#define CS_PIN      10
#define NUM_DEVICES 2
#define KNOB_PIN    A0
#define RANDOM_PIN  A1
#define SPEAKER_PIN 7

#define N_a   440
#define N_f   349
#define N_cH  523
#define N_eH  659
#define N_fH  698
#define N_gS  415

int step_col, step_row, subidas, OLD_X, sensor, row, col, sc, sr, dly;
int row_bar = 0;
int X = 4;
int cnt = 0;
int desarma = 0;

boolean showBars_enabled = false;

LedControl LC = LedControl(DATA_PIN, CLOCK_PIN, CS_PIN, NUM_DEVICES);

byte MSG[8 * 20];
byte SPACE[8] = {
    B00000000,
    B00000000,
    B00000000,
    B00000000,
    B00000000,
    B00000000,
    B00000000,
    B00000000
};
byte W[8] = {
    B00000000,
    B01000010,
    B01000010,
    B01000010,
    B01000010,
    B01011010,
    B01100110,
    B00000000
};
byte I[8] = {
    B00000000,
    B00111100,
    B00011000,
    B00011000,
    B00011000,
    B00011000,
    B00111100,
    B00000000
};
byte N[8] = {
    B00000000,
    B01000010,
    B01100010,
    B01010010,
    B01001010,
    B01000110,
    B01000010,
    B00000000
};
byte E[8] = {
    B00000000,
    B01111110,
    B01000000,
    B01111100,
    B01000000,
    B01000000,
    B01111110,
    B00000000
};
byte R[8] = {
    B00000000,
    B01111100,
    B01000010,
    B01111100,
    B01001000,
    B01000100,
    B01000010,
    B00000000
};

void loose()
{
    delay(80);

    for(row = 0; (row < 16); row++) {
        setROW(row, 0xFF);
        tone(SPEAKER_PIN, (row * 500), 10);
        delay(20);
    }

    delay(130);

    for(row = 15; (row >= 0); row--) {
        setROW(row, 0x00);
        tone(SPEAKER_PIN, (row * 500), 10);
        delay(20);
    }
}

void showBars(boolean show)
{
    showBars_enabled = show;

    if(show) {
        row_bar = (2 + random(5));
    }

    setROW(row_bar, (show == true ? 0xFF : 0x00));
}

void setLED(int l, int c, boolean state)
{
    int disp = 0;

    if(l > 7) {
        l = (l - 8);
        disp = 1;
    }

    LC.setLed(disp, l, c, state);
}

void setROW(int r, char ch)
{
    int disp = 0;

    if(r > 7) {
        r = (r - 8);
        disp = 1;
    }

    LC.setRow(disp, r, ch);
}

void copyLetter(byte *ch,int pos)
{
    int i;

    for(i = 0; (i < 8); i++) {
        *(MSG + i + (pos * 8)) = *( ch + i);
    }
}

void showMSG(int qtde, int tempo)
{
    int idx;

    LC.clearDisplay(0);
    LC.clearDisplay(1);

    for(idx = 0; (idx < (8 * qtde)); idx++) {
        for(row = 0; (row < 16); row++) {
            setROW(row, *(MSG + row + idx));
        }
		
        delay(tempo);
    }

    LC.clearDisplay(0);
    LC.clearDisplay(1);
}

void beep(int frequencyInHertz, long timeInMilliseconds)
{
    int x;
    long delayAmount = (long)(1000000 / frequencyInHertz);
    long loopTime = (long)((timeInMilliseconds * 1000) / (delayAmount * 2));

    for(row = 0; (row < 16); row++) {
        setROW(row,0xFF);
    }

    for (x = 0; (x < loopTime); x++) {
        digitalWrite(SPEAKER_PIN, HIGH);
        delayMicroseconds(delayAmount);
        digitalWrite(SPEAKER_PIN, LOW);
        delayMicroseconds(delayAmount);
    }

    LC.clearDisplay(0);
    LC.clearDisplay(1);

    delay(20);
}

void march()
{
    beep(N_a, 500);
    beep(N_a, 500);
    beep(N_a, 500);
    beep(N_f, 350);
    beep(N_cH, 150);

    beep(N_a, 500);
    beep(N_f, 350);
    beep(N_cH, 150);
    beep(N_a, 1000);

    beep(N_eH, 500);
    beep(N_eH, 500);
    beep(N_eH, 500);
    beep(N_fH, 350);
    beep(N_cH, 150);

    beep(N_gS, 500);
    beep(N_f, 350);
    beep(N_cH, 150);
    beep(N_a, 1000);
}

void winner()
{
    copyLetter(SPACE, 0);
    copyLetter(SPACE, 1);

    copyLetter(W, 2);
    copyLetter(I, 3);
    copyLetter(N, 4);
    copyLetter(N, 5);
    copyLetter(E, 6);
    copyLetter(R, 7);

    copyLetter(SPACE, 8);
    copyLetter(SPACE, 9);

    showMSG(9, 80);

    march();

    setup();
}

void setup() {
    pinMode(KNOB_PIN, INPUT);      // Potentiometer 10K Linear (GND, KNOB_PIN, +5v)
	pinMode(RANDOM_PIN, INPUT);    // Random Seed
    pinMode(SPEAKER_PIN, OUTPUT);  // Passive Buzzer

    LC.shutdown(0, false);
    LC.setIntensity(0, 8);
    LC.clearDisplay(0);

    LC.shutdown(1, false);
    LC.setIntensity(1, 8);
    LC.clearDisplay(1);

    randomSeed(analogRead(RANDOM_PIN) * millis());

    loose();

    dly = 500;

    setLED(15, X, true);
    setLED(15, (X + 1), true);
    setLED(15, (X + 2) ,true);
    OLD_X = (-1);
    subidas = 0;

    step_col = 1;
    step_row = 1;

    sc = step_col;
    sr = step_row;

    row = ((-1) + random(3));
    col = random(8);

    showBars(false);
}

void loop()
{
    sensor = analogRead(KNOB_PIN);

    X = map(sensor, 0, 980, 1, 6);

    if(X != OLD_X) {
        OLD_X = X;
        setROW(15, 0x00);
        setLED(15, (X - 1),true);
        setLED(15, X, true);
        setLED(15, (X + 1), true);
    }

    if(cnt == 0) {
        setLED(row, col, false);

        if((subidas == 1 || random(2) == 1) && showBars_enabled == false && row == 0) {
            showBars(true);
            subidas = 0;
            desarma = (2 + random(5));
        }

        if((subidas == desarma) && (showBars_enabled == true)) {
            showBars(false);
            subidas = 0;
        }

        if(col == 7) {
            sc = -step_col;
            tone(SPEAKER_PIN, 1000, 20);
        }

        if(col == 0) {
            sc = step_col;
            tone(SPEAKER_PIN, 1000, 20);
        }

        if(row == 0) {
            sr = step_row;
            subidas++;
            dly -= 5;
            tone(SPEAKER_PIN, 1000, 20);
        }

        if(dly <= 190) {
            winner();
        }

        if(showBars_enabled == true && sr > 0 && row < row_bar) {
            if(row == (row_bar - 1)) {
                sr = -step_row;
                tone(SPEAKER_PIN, 1000, 20);
            }
        }

        if(row == 14)
        {
            if(col >= (X - 1) && col <= (X + 1)) {
                sr = -step_row;
				tone(SPEAKER_PIN, 1500, 20);
			}
            else if(col == (X - 2) && (sc > 0)) {
                sr = -step_row;
                sc = -step_col;
                tone(SPEAKER_PIN, 1500, 20);
            }
            else if(col == (X + 2) && (sc < 0)) {
                sr = -step_row;
                sc = step_col;
                tone(SPEAKER_PIN, 1500, 20);
            }
        }

        row += sr;
        col += sc;

        if(col == 8) {
            col = 7;
        }

        if(col == (-1)) {
            col = 0;
        }

        setLED(row, col, true);

        if(row == 15) {
            setup();
        }
    }

    cnt++;

    if(cnt == dly) {
        cnt = 0;
    }
}

(click para ampliar)

(click para ampliar)

(click para ampliar)

(click para ampliar)

(click para ampliar)

(click para ampliar)

(click para ampliar)

(click para ampliar)

(click para ampliar)

(click para ampliar)

(click para ampliar)

Red Mod
La cinta Kapton es resistente al calor y eléctricamente aislante que se usa mucho en electrónica e impresión 3D. Si has estado en esta afición por un tiempo hay una buena probabilidad de que tengas un rollo a mano.

Una o dos capas de cinta Kapton aplicada a las matrices las hacen menos propensas a lavarse bajo luz brillante. El color de la cinta es lo suficientemente similar a los LEDs rojos que brillan a través con poca dificultad, mientras que la mayoría de la luz ambiente está bloqueada.

La película de enmascarar “Rubylith” (empleada en diseño gráfico) probablemente funcionaría igual de bien, o quizás mejor. Este film puede conseguirse en tiendas de arte decentes de la vieja escuela.

Anuncios