Mostrar imágenes

Para visualizar las imagenes que queramos vamos a crear nuestros propios array booleanos de 5x5 y, mediante una nueva función, transferirlos al array "matrizLed[5][5]", que es el que se muestra en los LEDs al utilizar "multiplexaMatrizLed()". Simplemente hay que ir moviendo los elementos de nuestro array a la misma posición en matrizLed; utilizando dos for el código es el siguiente:

void muestraImagen(boolean tuImagen[5][5]){
  for(byte y=0; y<5; y++){
    for(byte x=0; x<5; x++){
      matrizLed[y][x]=tuImagen[y][x];
    }
  }
}

Esta función la añadimos al archivo funcionesMicrobit.ino que creamos en la entrada anterior. El siguiente programa hace parpadear dos cuadrados a intervalos de medio segundo:

/* 
 *  parpadeoImagenesCuadrados.ino
 *  En la matriz de LEDs irán parpadeando dos 
 *  cuadrados, uno mas grande y otro más pequeño,
 *  a intervalos de medio segundo.
 *  funcionesMicrobit.ino debe estar en otra pestaña
 */

/*
 * Creamos dos array para representar los cuadrados,
 * uno grande y otro pequeño.
 */
boolean imagen1[5][5] = {{1,1,1,1,1}, 
                         {1,0,0,0,1},
                         {1,0,0,0,1},
                         {1,0,0,0,1},
                         {1,1,1,1,1}};

boolean imagen2[5][5] = {{0,0,0,0,0},
                         {0,1,1,1,0},
                         {0,1,0,1,0},
                         {0,1,1,1,0},
                         {0,0,0,0,0}};

void setup() {
  pinMatrizLedSalidas();
}

void loop() {
  muestraImagen(imagen1);
  delay_(500);            
  muestraImagen(imagen2);
  delay_(500);
}

/*
 * La función que se está ejecutando mientras
 * duran los delay_
 */
void loop_(){
  multiplexaMatrizLed();   
}

En lugar de utilizar un array booleano de 5x5, podríamos usar un array de tipo byte con sólo 5 elementos, en el que cada bit de esos números binarios representaría el estado de un LED, de esta forma ahorraríamos memoria. Por ejemplo, los array de los dos cuadrados anteriores quedarían de la siguiente manera:

/*
 * Creamos dos array para representar los cuadrados,
 * uno grande y otro pequeño. Cada bit representa un LED.
 * Se utilizan números binarios (byte) de 8 bit; en 
 * nuestro caso es suficiente con 5 bit, los tres bit
 * mas a la izquierda serían ceros.
 */
byte imagen1[5] = {B11111, 
                   B10001,
                   B10001,
                   B10001,
                   B11111};

byte imagen2[5] = {B00000, 
                   B01110,
                   B01010,
                   B01110,
                   B00000};
 

Lógicamente, tenemos que hacer una nueva función, un poco más complicada, para visualizar las imagenes; ya que hay que ir realizando una operación lógica and (&) entre los distintos bytes del array con el número B10000, desplazando el 1 hacia la derecha (>>) tantas veces como indique el número de la columna en la que nos encontremos:

void muestraImagenBmp(byte tuImagenBmp [5]){
  for(byte y=0; y<5; y++){
    for(byte x=0; x<5; x++){
      matrizLed[y][x]=tuImagenBmp[y] & (B10000 >> x);
    }
  }
}

También incluiremos una función para poner a cero todos los elementos del array "matrizled" y así apagar todos los LEDs:

void borraImagen(){
  for(byte y=0; y<5; y++){
    for(byte x=0; x<5; x++){
      matrizLed[y][x]=0;
    }
  }

En este ejemplo los LEDs se van encendiendo progresivamente en diagonal:

/* 
 *  imagenesBmpBarridoLed.ino
 *  La matriz de LEDs se irá encendiendo progresivamente
 *  en diagonal.
*/

/*
 * Todos los array con las imágenes a visualizar
 */
byte imagen1[5]={B10000,
                 B00000,
                 B00000,
                 B00000,
                 B00000};
byte imagen2[5]={B11000,
                 B10000,
                 B00000,
                 B00000,
                 B00000};
byte imagen3[5]={B11100,
                 B11000,
                 B10000,
                 B00000,
                 B00000};
byte imagen4[5]={B11110,
                 B11100,
                 B11000,
                 B10000,
                 B00000};
byte imagen5[5]={B11111,
                 B11110,
                 B11100,
                 B11000,
                 B10000};
byte imagen6[5]={B11111,
                 B11111,
                 B11110,
                 B11100,
                 B11000};
byte imagen7[5]={B11111,
                 B11111,
                 B11111,
                 B11110,
                 B11100};
byte imagen8[5]={B11111,
                 B11111,
                 B11111,
                 B11111,
                 B11110};
byte imagen9[5]={B11111,
                 B11111,
                 B11111,
                 B11111,
                 B11111};

void setup() {
 pinMatrizLedSalidas();
}

void loop() {
  muestraImagenBmp(imagen1);
  delay_(100);
  muestraImagenBmp(imagen2);
  delay_(100);
  muestraImagenBmp(imagen3);
  delay_(100);
  muestraImagenBmp(imagen4);
  delay_(100);
  muestraImagenBmp(imagen5);
  delay_(100);
  muestraImagenBmp(imagen6);
  delay_(100);
  muestraImagenBmp(imagen7);
  delay_(100);
  muestraImagenBmp(imagen8);
  delay_(100);
  muestraImagenBmp(imagen9);
  delay_(1000);
  borraImagen();
  delay_(1000);
}

/*
 * La función que se está ejecutando mientras
 * duran los delay_
 */
void loop_(){
  multiplexaMatrizLed();
}

También podemos visualizar letras y números. En el siguiente programa se muestran las letras A, B y el número 2:

/* 
 *  imagenesBmpAB2.ino
 *  En la matriz de LEDs irán apareciendo las letras
 *  A y B y el número 2, a intervalos de un segundo.
*/

/*
 * Los array con las imágenes de A, B y 2.
 */
byte imagenA[5]={B01100,
                 B10010,
                 B11110,
                 B10010,
                 B10010};
byte imagenB[5]={B11100,
                 B10010,
                 B11100,
                 B10010,
                 B11100};
byte imagen2[5]={B11100,
                 B00010,
                 B01100,
                 B10000,
                 B11110};

void setup() {
 pinMatrizLedSalidas();
}

void loop() {
  muestraImagenBmp(imagenA);
  delay_(1000);
  muestraImagenBmp(imagenB);
  delay_(1000);
  muestraImagenBmp(imagen2);
  delay_(1000);
}

/*
 * La función que se está ejecutando mientras
 * duran los delay_
 */
void loop_(){
  multiplexaMatrizLed();
}