Matrix LED MAX7219

En este post conoceremos el módulo matriz led de 8×8 controlado por el circuito integrado MAX7219, que nos permitirá mostrar números, caracteres o simples dibujos y animaciones.

¿Qué es una matriz LED? Es un display compuesto por múltiples LEDs en distribución rectangular. El más habitual es el de 8×8 y se suele combinar para formar matrices mayores, aunque existen matrices de diferentes tamaños. Se podría controlar la matriz LED a través de sus 16 terminales, pero normalmente, va acompañado de un controlador integrado, el MAX7219, que facilita la conexión con Arduino y el control de la matriz LED.

Las matrices LEDs están fomadas por una serie de filas y columnas donde en cada intersección se encuentra un LED. Para encender o apagar un LED se requiere aplicar los valores HIGH y LOW a su correspondiente fila y columna.

Como se puede observar en la figura, todos los cátodos de los LEDs que forman una fila de la matriz se encuentran conectados entre sí, a igual que lo están los ánodos de una columna. ¿Cómo activamos un led determinado? Por ejemplo, el primero de la esquina superior a la izquierda, debe recibir una señal LOW (0) sobre la fila 1 y un HIGH (1) en la columna 1, si fuera el el LED 5º de la primera fila, mantendríamos la señal LOW sobre la fila 1 pero un HIGH en la columna 5.

Para facilitar el control de la matriz se utiliza el circuito integrado MAX7219, diseñado para el manejo de matrices de LEDS y para displays de 7 segmentos. La comunicación con el MAX7219 se realiza a través de SPI por lo que solo se necesitan 3 pines de Arduino.

Conexión con Arduino

Esquema

Conectaremos el pin VCC a los 5V de Arduino, el pin GND al GND de Arduino, el pin denominado DIN al pin digital 11 de Arduino, CLK al pin digital número 13 y el pin CS al pin digital 10 de Arduino.

Ejemplo 1

Con este primer ejemplo iremos encendiendo y apagando cada LED de la matriz sucesivamente.

#include "LedControl.h"
LedControl matrizLed=LedControl(11,13,10,1);

Primero incluimos la librería LedControl.h que se encargará del manejo de la matriz y creamos un objeto del tipo LedControl llamado matrizLed en el que estableceremos los siguientes parámetros:

LedControl( DIN, CLK, CS, nº de matrices)

En la función setup():

void setup() {
  matrizLed.shutdown(0,false);
  matrizLed.setIntensity(0,4);
  matrizLed.clearDisplay(0);
}

Utilizamos la función shutdown(), con la cual indicamos que habilitamos la matriz. Tiene dos parámetros: el número de dispositivos y el estado en que se encuentra. El número de dispositivos se indica de 0 a 7. (Una sola matriz sería indicada con el 0, 4 dispositivos lo indicaríamos con un 3). El estado en que se encuentra puede ser true o false; nosotros lo configuraremos en false, encendido.

shutdown( nº dispositivo, estado)

Con la función setIntensity() indicamos el nivel de intensidad del LED. Requiere dos parámetros, el número de dispositivos y la intensidad con un valor comprendido entre 0 y 15.

setIntensity( nº dispositivo, intensidad)

La función clearDisplay() apaga todos los LEDs de la matriz. Solamente indicaremos el número de dispositivo.

clearDisplay( nº dispositivo)

En la función loop() tenemos dos bucles for anidados para ir recorriendo las filas y columnas:

void loop(){
  for(int fila = 0; fila < 8; fila++) {
    for(int columna = 0; columna < 8; columna++) {
      matrizLed.setLed(0,fila,columna,true);
      delay(100);
      matrizLed.setLed(0,fila,columna,false);
      delay(100);
    }
  }
}

La función setLed() es la que va a indicar si el led de la fila y columna correspondiente estará encendido o apagado. Esta función tiene 4 parámetros: el número del dispositivo, la fila, la columna y si estará encendido (true) o apagado (false).

setLed( nº dispositivo, fila, columna, valor)

Código completo:

#include "LedControl.h"
LedControl matrizLed=LedControl(11,13,10,1);

void setup() {
  Serial.begin(9600);
  matrizLed.shutdown(0,false);
  matrizLed.setIntensity(0,4);
  matrizLed.clearDisplay(0);
}

void loop(){
  for(int fila = 0; fila < 8; fila++) {
    Serial.print(fila);
    Serial.println("------");
    for(int columna = 0; columna < 8; columna++) {
      Serial.println(columna);
      matrizLed.setLed(0,fila,columna,true);
      delay(100);
      matrizLed.setLed(0,fila,columna,false);
      delay(100);
    }
  }
}

Ejemplo 2.

En este segundo ejemplo visualizaremos los números del 0 al 9 en la matriz. Primero realizamos un boceto para diseñar cómo queremos que muestre los números.

En la imagen superior, están representados el 0 y el 1 en una matriz de 8×8. Si nos fijamos a la derecha de la representación del 0, comprobaremos que estamos ante un array de 8 elementos formado por ceros y unos, donde el cero es el cuadro vacío y el uno es el cuadro lleno. Y como existe la posibilidad de indicar al compilador de Arduino que el número está en binario colocando una B delante, esto nos facilita mucho el trabajo, ya que vemos visualmente la matriz de LEDs tal como la queremos. Por ejemplo, el array para indicar que queremos mostrar el cero sería:

byte cero[8]= {
  B00111000,
  B01000100,
  B01000100,
  B01000100,
  B01000100,
  B01000100,
  B01000100,
  B00111000
}

Código para mostrar del 0 al 9:

#include "LedControl.h"

LedControl lc=LedControl(11,13,10,1);

#define espera 1000

byte cero[8]= {B00111000,B01000100,B01000100,B01000100,B01000100,B01000100,B01000100,B00111000};
byte uno[8]= {B00010000,B00110000,B00010000,B00010000,B00010000,B00010000,B00010000,B00111000};
byte dos[8]= {B00111000,B01000100,B00000100,B00000100,B00001000,B00010000,B00100000,B01111100};
byte tres[8]= {B00111000,B01000100,B00000100,B00011000,B00000100,B00000100,B01000100,B00111000};
byte cuatro[8]= {B00001000,B00011000,B00101000,B01001000,B01001000,B01111100,B00001000,B00001000};
byte cinco[8]= {B01111100,B01000000,B01000000,B01111000,B00000100,B00000100,B01000100,B00111000};
byte seis[8]= {B00111000,B01000100,B01000000,B01111000,B01000100,B01000100,B01000100,B00111000};
byte siete[8]= {B01111100,B00000100,B00000100,B00001000,B00010000,B00100000,B00100000,B00100000};
byte ocho[8]= {B00111000,B01000100,B01000100,B00111000,B01000100,B01000100,B01000100,B00111000};
byte nueve[8]= {B00111000,B01000100,B01000100,B01000100,B00111100,B00000100,B01000100,B00111000};

void setup() {
  lc.shutdown(0,false);
  lc.setIntensity(0,4);
  lc.clearDisplay(0);
}

void loop(){
  mostrar(cero);
  delay(espera);
  mostrar(uno);
  delay(espera);
  mostrar(dos);
  delay(espera);
  mostrar(tres);
  delay(espera);
  mostrar(cuatro);
  delay(espera);
  mostrar(cinco);
  delay(espera);
  mostrar(seis);
  delay(espera);
  mostrar(siete);
  delay(espera);
  mostrar(ocho);
  delay(espera);
  mostrar(nueve);
  delay(espera);
}

void mostrar(byte numero[]){
  for (int i = 0; i < 8; i++){
    lc.setRow(0,i,numero[i]);
  }
}

La función nueva que vamos a utilizar es setRow(), con ella vamos a mostrar los caracteres. Se encuentra dentro del blucle de la función mostrar(). Requiere de 3 parámetros: el número del dispositivo, la fila y un valor de 8 bits, que corresponde con la secuencia de unos y ceros de cada fila para formar el número que queremos.

setRow( nº dispositivo, fila, valor)