Tutorial: Usando la matriz de leds del Arduino UNO R4. Parte 1

Una de las novedades del nuevo Arduino UNO es su matriz de leds, que podemos aprovechar a modo de pantalla con muchisimos usos. En este tutorial te explico como usarla para mostrar patrones fijos, animaciones e incluso mensajes de texto.

Introducción

El Arduino UNO R4, entre otras novedades, incorpora una matriz de leds rojos con un tamaño de 8 filas y 12 columnas. Esta matriz puede emplearse a modo de “pantalla” para mostrar símbolos, íconos, valores numericos o hasta texto, en forma estática e incluso en movimiento.

Esta característica no solo amplía las posibilidades de visualización, sino que también facilita la creación de proyectos interactivos y visuales, incluyendo algunos juegos sencillos.

En este artículo te voy a mostrar distintos métodos para que aproveches al máximo la matriz led del Arduino UNO R4.

Para este tutorial usé una placa UNO R4 Wifi clon y Arduino IDE 2.3.2 sobre Windows 11. Si necesitas instrucciones para comenzar con esta placa puedes consultar este artículo anterior.

Librerías

Afortunadamente, para aprovechar las ventajas de la matriz de leds no tenemos que codificar una librería desde cero sino que podemos emplear una escrita por la gente de Arduino que incluye todo lo necesario para su uso, llamada “Arduino_LED_Matrix.h“.

Si vas a usar la matriz de leds, lo primero que debes hacer en tu programa es incluir esta librería con la directiva include:

#include "Arduino_LED_Matrix.h"

Entre otras cosas, esta librería contiene la clase ArduinoLEDMatrix. Lo siguiente que debe contener tu código es la creación o instanciación de un objeto de esta clase, que quedará asociado a la matriz. En el ejemplo de abajo he llamado a este objeto Pantalla.

ArduinoLEDMatrix Pantalla;  //Instancia objeto

El último paso para dejar lista para usar la matriz es inicializar este objeto invocando al método begin:

void setup() {

  Pantalla.begin();
}

Un sketch completo y funcional que prepara la matriz quedaría como el siguiente:

#include "Arduino_LED_Matrix.h"

ArduinoLEDMatrix Pantalla;  //Instancia objeto

void setup() {
  Pantalla.begin();  //Inicializar 
}

void loop() {
 
}

Lo que falta es aprender a usar los distintos métodos existentes para mostrar contenido sobre la matriz, que es lo que te explicaré a continuación.

Bitmaps

La forma mas sencilla de mostrar un patrón en la matriz de leds es empleando un bitmap. Un bitmap no es otra cosa que un arreglo bidimensional, con un tamaño de 8 x 12 en el que cada elemento puede tener un valor de 0 (led apagado) o 1 (led prendido).

Una vez definido el bitmap, se puede mostrar en la matriz empleando el método renderBitmap de la librería Arduino_LED_Matrix.

El siguiente código muestra como es el procedimiento.

#include "Arduino_LED_Matrix.h"

ArduinoLEDMatrix Pantalla;  //Instancia objeto

byte corazon [8][12] = {
    {0,0,0,0,0,0,0,0,0,0,0,0},
    {0,0,0,1,1,0,1,1,0,0,0,0},
    {0,0,1,0,0,0,0,0,1,0,0,0},
    {0,0,1,0,0,0,0,0,1,0,0,0},
    {0,0,0,1,0,0,0,1,0,0,0,0},
    {0,0,0,0,1,0,1,0,0,0,0,0},
    {0,0,0,0,0,1,0,0,0,0,0,0},
    {0,0,0,0,0,0,0,0,0,0,0,0},
};

void setup() {

  Pantalla.begin();  //Inicializa

  Pantalla.renderBitmap (corazon, 8,12);  //Muestra bitmap

}

void loop() {

}

Como puedes ver en la linea 5 se define el bitmap con 1s y 0s para encender y apagar los leds y en la línea 20 se muestra el bitmap en la matriz usando renderBitmap pasandole como parámetros la cantidad de leds (8 x 12).

Este método es muy sencillo, como te dije al principio pero tiene una desventaja: el bitmap se define como una matriz de bytes, donde cada byte se usa para almacenar sólo un 0 o un 1, así que se hace un uso muy ineficiente de la memoria.

¿Habrá alguna alternativa mas eficiente?

Enteros de 32 bits

Claro que hay otro método mas eficiente y por suerte no nos hace falta superinteligencia sino prestar atención a como se almacenan los datos en la memoria.

Este método es una alternativa al de los bitmaps y busca almacenar la información de una forma mas eficiente, variables de tipo unsigned long, que son capaces de almacenar valores numericos de 32 bits de ancho.

La matriz tiene 8 x 12 = 96 leds. Usando el método anterior del bitmap, eso significa 96 bytes.

Pero 96 es divisible por 32 (96 / 32 = 3) así que si cada bit de una variable unsigned long se usa para representar el estado de un led, nos alcanza con sólo 3 variables de este tipo.

Como cada unsigned long tiene un ancho de 4 bytes, con esta forma de almacenar los datos de los leds reducimos el consumo de memoria a 3 x 4 = 12 bytes (8 veces menos que con los bitmaps).

La unica contra de este este método es que es menos intuitivo, la conversión del contenido de la matriz a 3 enteros hace que se pierda la información visual que teniamos al emplear bitmaps.

Esta conversión se puede hacer manualmente, pero puedes hacerlo mas fácil con esta herramienta.

Usando el editor anterior puedes dibujar el patrón que quieras y al pulsar Convert to array obtendrás tanto la definición del bitmap como los enteros de 32 bits.

Como puedes ver, los valores ahora se acomodan en un arreglo de solo 3 elementos, cada uno de ellos un entero de 32 bits o unsigned long.

Para mostrar estos datos en la matriz de leds debes usar el método loadFrame especificando el nombre del arreglo con los datos. Usando la información provista por el editor, el programa que muestra la imagen del corazón empleando enteros de 32 bits quedaría de la siguiente forma:

#include "Arduino_LED_Matrix.h"

ArduinoLEDMatrix Pantalla;

unsigned long corazon[] = {
    0x1B020,
    0x82081100,
    0xA0040000,
};

void setup() {
  
  Pantalla.begin ();  //Inicializa

  Pantalla.loadFrame (corazon);  //Muestra en matriz

}

void loop() {
  // put your main code here, to run repeatedly:

}

Frames predefinidos

Para que te ahorres trabajo, la librería Arduino_LED_Matrix incluye la definición de muchos patrones que se usan habitualmente, como te muestro a continuación:

/*
 Pruebas de la matriz led de la UNO R4 Wifi usando enteros de 32 bits
 En este ejemplo se muestran los frames que ya están predefinidos
*/

#include "Arduino_LED_Matrix.h"

ArduinoLEDMatrix Pantalla;  //Instancia un objeto de la clase Arduino_LED_Matrix


void setup() {
  // put your setup code here, to run once:

  Pantalla.begin ();

}

void loop() {
  // put your main code here, to run repeatedly:

  Pantalla.loadFrame (LEDMATRIX_BLUETOOTH);
  delay (1500);
  Pantalla.loadFrame (LEDMATRIX_BOOTLOADER_ON);
  delay (1500);
  Pantalla.loadFrame (LEDMATRIX_CHIP);
  delay (1500);
  Pantalla.loadFrame (LEDMATRIX_CLOUD_WIFI);
  delay (1500);
  Pantalla.loadFrame (LEDMATRIX_DANGER);
  delay (1500);
  Pantalla.loadFrame (LEDMATRIX_EMOJI_BASIC);
  delay (1500);
  Pantalla.loadFrame (LEDMATRIX_EMOJI_HAPPY);
  delay (1500);
  Pantalla.loadFrame (LEDMATRIX_EMOJI_SAD);
  delay (1500);
  Pantalla.loadFrame (LEDMATRIX_HEART_BIG);
  delay (1500);
  Pantalla.loadFrame (LEDMATRIX_HEART_SMALL);
  delay (1500);
  Pantalla.loadFrame (LEDMATRIX_LIKE);
  delay (1500);
  Pantalla.loadFrame (LEDMATRIX_MUSIC_NOTE);
  delay (1500);    
  Pantalla.loadFrame (LEDMATRIX_RESISTOR);
  delay (1500);    
  Pantalla.loadFrame (LEDMATRIX_UNO);
  delay (1500);

}

Para aprender más

Using the Arduino UNO R4 Wifi LED matrix

Conclusiones

En este artículo hice una introducción al uso de la librería Arduino_LED_Matrix y los métodos necesarios para mostrar patrones en la matriz led del Arduino UNO R4.

Te expliqué como usar bitmaps, enteros de 32 bits y te mostré los patrones predefinidos ya incluidos en la misma librería.

En la proxima entrega nos toca ver como hacer animaciones sencillas y como usar la matriz para mostrar valores numéricos y textos.

Espero que la información te haya sido de utilidad para comenzar tus propios proyectos con el UNO R4. Como siempre, cualquier sugerencia o duda puedes dejarla mas abajo en la sección de comentarios.