Select Page

Una matriz de led o LED MATRIX es la única (pueden haber otras como leds programables PL9823 o WS2812) forma que tenemos de ahorrarnos pines a la hora de manejar muchos leds como en una matriz de led 8×8. El mismo método se utiliza con los teclados de membrana, cubos de led y hasta display de 7 segmentos. Todos estos dispositivos tienen algún en común: MUCHOS PINES, lo cual supondría un gran desperdicio de recursos de un microcontrolador y por este motivo, lo normal es que siempre empleemos un controlador o driver específicamente diseñado para esta función. Para manejar muchos pines, tenemos integrados que nos ayudan y en este caso es el: MAX7219.

QUÉ ES UNA MATRIZ LED

Una matriz LED es un tipo de display, formado por más de un LED en distribución normalmente rectangular y estan conectados eléctricamente de una manera particular: cada fila de leds tiene unidos entre una de sus dos patas. Según sea Anodo o Catodo comun, una u otra pata estarán unidas entre sí.

Repetimos este patrón con la segunda fila de leds, pero esta vez además de cortocircuitar esa para entre todos, conectamos cada led de su columna con el compañero en la misma columna.

Esta interconexión es denominada MATRIZ.

MAX7219 con Arduino y Una Matriz de LED 2

Existen muchos tamaños, siendo el más habitual los cuadrados de 8×8 LED. Veremos más adelante que también podemos conectar más de una matriz con su driver generando una matriz mucho más grande pudiendo lograr un cartel de LED.

CÓMO FUNCIONA UNA MATRIZ DE LED 8×8

Si aplicamos valores HIGH y LOW a varias filas y columnas de forma simultánea se encenderán todos los LED de las intersecciones. De esta forma, resulta casi imposible generar gráficos complejos. Lo que debemos hacer es imaginarnos una imagen una forma de algo, y la matriz la ira dibujando fila por fila. Esto se llama barrido.

Para poder hacer gráficos el procedimiento consiste en hacer un barrido por filas (o columnas). Encendemos todos los LED de una única fila (o columna), y a continuación cambiamos a la siguiente. Sólo una fila (o columna) está encendida cada instante pero, al hacerlo rápidamente, el efecto en nuestra visión es ver toda la imagen formada de forma simultánea, como en la TV o cine.

Este efecto se denomina Persistencia de visión” (POV)..

Encender una matriz de 8×8 LED requeriría 16 señales digitales y un trabajo constante del procesador para refrescar la imagen en caso de movimiento o un video. Eso es una cantidad enorme de recursos para cualquier micro y estaríamos desaprovechando toda su potencia para solo simplemente encender un display y nada mas.

Por este motivo, empleamos un controlador o driver como el MAX7219 que está especialmente diseñado para encender displays de 7 segmentos y matrices de led, dejando poder de procesamiento para hacer otras cosas con el micro.

La comunicación con el MAX7219 se realiza a través del puerto SPI por lo que sólo se requieren 3 pines de Arduino (SS, MOSI y SCK) dado que este módulo solo escucha y no devuelve info. Además ni siquiera “ocupamos” del todo estos pines, ya que con el mismo bus podemos controlar múltiples dispositivos. Podríamos utilizar otro dispositivo SPI o varios módulos de matrices de led en conjunto y al mismo tiempo.

Por último, las propias placas MAX7219 generalmente incorporan un puerto de entrada y salida, de forma que podemos combinar múltiples controladores sin ningún problema.

MAX7219 con Arduino y Una Matriz de LED 3

En resumen: Las matrices de LEDs están conformadas por una serie de filas y columnas en donde hay un LED en cada una de las intersecciones. Para que un LED encienda se deberá recibir un «0» en la fila y un «1» en la columna simultáneamente, según cómo se unan entre sí, cátodo o ánodo común.

PinOut de la matriz de led 8×8

MAX7219 con Arduino y Una Matriz de LED 4

Característica del MAX7219

El MAX7219 es un controlador de displays que puede manejar 8 segmentos en hasta 8 dígitos o bien 64 leds individuales, esto lo hace ideal para manejar una matriz de led 8×8. En este módulo el MAX7219 viene conectado a una matriz de cátodo común, por lo que  podemos controlar los 64 leds con solamente 3 lineas de un microcontrolador. Este tipo de módulos son de gran utilidad para experimentar con matrices de led, pues simplifican en gran medida las conexiones que hay que realizar para poder controlar el arreglo de leds.

El módulo MAX7219 con matriz de led se entrega listo para funcionar, puede usarse simplemente conectándolo a un arduino, raspberry pi o cualquier otro dispositivo que pueda comunicarse a través de una interfaz SPI o pueda emular su funcionamiento. En la plataforma arduino ya existen librerías para realizar la interfaz con el MAX7219 de forma muy sencilla y mostrar cualquier patrón en la matriz de leds. Incluso pueden conectarse varios módulos para formar un anuncio de leds.

  • MAX7219 controlador de displays con 8 segmentos y 8 dígitos
  • Controlan hasta 64 leds individuales
  • Intensidad de iluminación de leds se puede controlar mediante software a través de la interfaz serial
  • Interfaz serial similar a SPI de 10 Mhz
  • Se controla solamente con 3 señales: DIN, CS, SCK

¿QUÉ ES EL MULTIPLEXADO?

Es una técnica que permite usar pocos pines de entrada y salida del microcontrolador. Esto para controlar los circuitos integrados que encenderán los LED´s. Existen diversos tipos para hacerlo.

LATCH

Es una memoria que mantiene un valor es sus salidas hasta que se le indique. De esta forma se encienden los LED´s rápidamente y por turnos para formar una palabra.

REGISTRO DE DESPLAZAMIENTO:

Funciona de la misma manera que una fila. Por un extremo ingresan los datos (0,1) y del otro extremo van saliendo. Se necesitan solamente 3 pines;

DATA: Envía los datos al registro ya sea un «0» o un «1».

CLOCK: Avisa al registro que el dato ya está listo para ingresarse.

RESET: Es el que vacía la fila al escribir un «0» en todas las salidas.

Cableando la matriz de led 8×8 al Arduino

Podemos conectar uno o más de un módulo al arduino, esto es indistinto gracias a que se maneje por puerto SPI. Existen unos módulos de 4 matrices de 8×8 que ya vienen pre armados.

El modelo más utilizado, es el que tiene un par de borneras de pines una de cada lado, para utilizar los módulos como en la imagen. Pero en caso de que no tenga una doble tira de pines, simplemente tenes que conectar las borneras en paralelo, SALVO EL CS [chip select] que debe ir a un pin independiente al Arduino.

MAX7219 con Arduino y Una Matriz de LED 5

Como se puede ver, la conexión es muy sencilla debido al MAX7219. El cual incorpora un decoder o decodificador BCD code-B, tiene una memoria interna de 8×8 para  almacenar el valor de cada dígito y hacer el multiplexado. Se maneja solo con 3 pines, DIN, CS y CLK, y solo necesita una resistencia externa para funcionar. Además, es compatible con SPI, QSPI y MICROWIRE.

MAX7219 con Arduino y Una Matriz de LED 6

Librería para Matriz de led 8×8 MAX7219

Dependiendo lo que queremos hacer, tenemos una librería o herramientas para simplificarse la vida.

Mostrando texto en scroll

Para empezar vamos a mostrar un texto en scroll lateral. Para comunicarnos con el módulo usaremos la librería MaxMatrix.h, la descargamos usando el enlace que hay a continuación y la descomprimimos en la carpeta Libraries de nuestra instalación del IDE de Arduino.

Libreria MaxMatrix.H

Lo primero que hacemos es declarar todos los caracteres posibles (A-Z y 0-9) como valores binarios y, en vez de declararlos como variables y colapsar la SRAM, lo que haremos es poner esos datos en la memoria flash (memoria de programa) usando el modificador de variable PROGMEM ya que son datos fijos que no van a variar. A continuación tenéis el sketch que está comentado para que sea muy fácil de entender.

// INCLUIMOS LA LIBRERÍA MAXMATRIX.H Y PGMSPACE.H NECESARIO
// PARA PODER USAR EL MODIFICADOR DE VARIABLE PROGMEM
#include <MaxMatrix.h>
#include <avr/pgmspace.h>


// DEFINIMOS TODOS LOS CARACTERES POSIBLES EN UN ARRAY 
// Y LO CARGAMOS EN LA MEMORIA DE PROGRAMA CON PROGMEM
PROGMEM const unsigned char CH[] = {
3, 8, B00000000, B00000000, B00000000, B00000000, B00000000, // espacio
1, 8, B01011111, B00000000, B00000000, B00000000, B00000000, // !
3, 8, B00000011, B00000000, B00000011, B00000000, B00000000, // "
5, 8, B00010100, B00111110, B00010100, B00111110, B00010100, // #
4, 8, B00100100, B01101010, B00101011, B00010010, B00000000, // $
5, 8, B01100011, B00010011, B00001000, B01100100, B01100011, // %
5, 8, B00110110, B01001001, B01010110, B00100000, B01010000, // &
1, 8, B00000011, B00000000, B00000000, B00000000, B00000000, // '
3, 8, B00011100, B00100010, B01000001, B00000000, B00000000, // (
3, 8, B01000001, B00100010, B00011100, B00000000, B00000000, // )
5, 8, B00101000, B00011000, B00001110, B00011000, B00101000, // *
5, 8, B00001000, B00001000, B00111110, B00001000, B00001000, // +
2, 8, B10110000, B01110000, B00000000, B00000000, B00000000, // ,
4, 8, B00001000, B00001000, B00001000, B00001000, B00000000, // -
2, 8, B01100000, B01100000, B00000000, B00000000, B00000000, // .
4, 8, B01100000, B00011000, B00000110, B00000001, B00000000, // /
4, 8, B00111110, B01000001, B01000001, B00111110, B00000000, // 0
3, 8, B01000010, B01111111, B01000000, B00000000, B00000000, // 1
4, 8, B01100010, B01010001, B01001001, B01000110, B00000000, // 2
4, 8, B00100010, B01000001, B01001001, B00110110, B00000000, // 3
4, 8, B00011000, B00010100, B00010010, B01111111, B00000000, // 4
4, 8, B00100111, B01000101, B01000101, B00111001, B00000000, // 5
4, 8, B00111110, B01001001, B01001001, B00110000, B00000000, // 6
4, 8, B01100001, B00010001, B00001001, B00000111, B00000000, // 7
4, 8, B00110110, B01001001, B01001001, B00110110, B00000000, // 8
4, 8, B00000110, B01001001, B01001001, B00111110, B00000000, // 9
2, 8, B01010000, B00000000, B00000000, B00000000, B00000000, // :
2, 8, B10000000, B01010000, B00000000, B00000000, B00000000, // ;
3, 8, B00010000, B00101000, B01000100, B00000000, B00000000, // <
3, 8, B00010100, B00010100, B00010100, B00000000, B00000000, // =
3, 8, B01000100, B00101000, B00010000, B00000000, B00000000, // >
4, 8, B00000010, B01011001, B00001001, B00000110, B00000000, // ?
5, 8, B00111110, B01001001, B01010101, B01011101, B00001110, // @
4, 8, B01111110, B00010001, B00010001, B01111110, B00000000, // A
4, 8, B01111111, B01001001, B01001001, B00110110, B00000000, // B
4, 8, B00111110, B01000001, B01000001, B00100010, B00000000, // C
4, 8, B01111111, B01000001, B01000001, B00111110, B00000000, // D
4, 8, B01111111, B01001001, B01001001, B01000001, B00000000, // E
4, 8, B01111111, B00001001, B00001001, B00000001, B00000000, // F
4, 8, B00111110, B01000001, B01001001, B01111010, B00000000, // G
4, 8, B01111111, B00001000, B00001000, B01111111, B00000000, // H
3, 8, B01000001, B01111111, B01000001, B00000000, B00000000, // I
4, 8, B00110000, B01000000, B01000001, B00111111, B00000000, // J
4, 8, B01111111, B00001000, B00010100, B01100011, B00000000, // K
4, 8, B01111111, B01000000, B01000000, B01000000, B00000000, // L
5, 8, B01111111, B00000010, B00001100, B00000010, B01111111, // M
5, 8, B01111111, B00000100, B00001000, B00010000, B01111111, // N
4, 8, B00111110, B01000001, B01000001, B00111110, B00000000, // O
4, 8, B01111111, B00001001, B00001001, B00000110, B00000000, // P
4, 8, B00111110, B01000001, B01000001, B10111110, B00000000, // Q
4, 8, B01111111, B00001001, B00001001, B01110110, B00000000, // R
4, 8, B01000110, B01001001, B01001001, B00110010, B00000000, // S
5, 8, B00000001, B00000001, B01111111, B00000001, B00000001, // T
4, 8, B00111111, B01000000, B01000000, B00111111, B00000000, // U
5, 8, B00001111, B00110000, B01000000, B00110000, B00001111, // V
5, 8, B00111111, B01000000, B00111000, B01000000, B00111111, // W
5, 8, B01100011, B00010100, B00001000, B00010100, B01100011, // X
5, 8, B00000111, B00001000, B01110000, B00001000, B00000111, // Y
4, 8, B01100001, B01010001, B01001001, B01000111, B00000000, // Z
2, 8, B01111111, B01000001, B00000000, B00000000, B00000000, // [
4, 8, B00000001, B00000110, B00011000, B01100000, B00000000, // \ 
2, 8, B01000001, B01111111, B00000000, B00000000, B00000000, // ]
3, 8, B00000010, B00000001, B00000010, B00000000, B00000000, // sombrero
4, 8, B01000000, B01000000, B01000000, B01000000, B00000000, // _
2, 8, B00000001, B00000010, B00000000, B00000000, B00000000, // `
4, 8, B00100000, B01010100, B01010100, B01111000, B00000000, // a
4, 8, B01111111, B01000100, B01000100, B00111000, B00000000, // b
4, 8, B00111000, B01000100, B01000100, B00101000, B00000000, // c
4, 8, B00111000, B01000100, B01000100, B01111111, B00000000, // d
4, 8, B00111000, B01010100, B01010100, B00011000, B00000000, // e
3, 8, B00000100, B01111110, B00000101, B00000000, B00000000, // f
4, 8, B10011000, B10100100, B10100100, B01111000, B00000000, // g
4, 8, B01111111, B00000100, B00000100, B01111000, B00000000, // h
3, 8, B01000100, B01111101, B01000000, B00000000, B00000000, // i
4, 8, B01000000, B10000000, B10000100, B01111101, B00000000, // j
4, 8, B01111111, B00010000, B00101000, B01000100, B00000000, // k
3, 8, B01000001, B01111111, B01000000, B00000000, B00000000, // l
5, 8, B01111100, B00000100, B01111100, B00000100, B01111000, // m
4, 8, B01111100, B00000100, B00000100, B01111000, B00000000, // n
4, 8, B00111000, B01000100, B01000100, B00111000, B00000000, // o
4, 8, B11111100, B00100100, B00100100, B00011000, B00000000, // p
4, 8, B00011000, B00100100, B00100100, B11111100, B00000000, // q
4, 8, B01111100, B00001000, B00000100, B00000100, B00000000, // r
4, 8, B01001000, B01010100, B01010100, B00100100, B00000000, // s
3, 8, B00000100, B00111111, B01000100, B00000000, B00000000, // t
4, 8, B00111100, B01000000, B01000000, B01111100, B00000000, // u
5, 8, B00011100, B00100000, B01000000, B00100000, B00011100, // v
5, 8, B00111100, B01000000, B00111100, B01000000, B00111100, // w
5, 8, B01000100, B00101000, B00010000, B00101000, B01000100, // x
4, 8, B10011100, B10100000, B10100000, B01111100, B00000000, // y
3, 8, B01100100, B01010100, B01001100, B00000000, B00000000, // z
3, 8, B00001000, B00110110, B01000001, B00000000, B00000000, // {
1, 8, B01111111, B00000000, B00000000, B00000000, B00000000, // |
3, 8, B01000001, B00110110, B00001000, B00000000, B00000000, // }
4, 8, B00001000, B00000100, B00001000, B00000100, B00000000, // ~
};


// DEFINIMOS LOS PINES DEL ARDUINO
int data = 8;    // Pin DIN del módulo MAX7219
int load = 9;    // Pin CS del módulo MAX7219
int clock = 10;  // Pin CLK del módulo MAX7219

// CUANTOS MÓDULOS TENEMOS CONECTADOS EN SERIE?
int maxInUse = 2;

// DEFINIMOS LA FUNCIÓN DE CADA PIN 
MaxMatrix m(data, load, clock, maxInUse); 
byte buffer[10];

// ESTA ES LA VARIABLE QUE CONTIENE EL TEXTO QUE APARECERÁ EN LOS DISPLAYS 
char string1[] = "Esto es una prueba de texto en scroll           "; 
 
void setup(){
  m.init();          // INICIAMOS EL MODULO
  m.setIntensity(5); // DEFINIMOS LA INTENSIDAD DE LOS LED (0-15)
}
 
void loop(){
  byte c;
  delay(100);  // PAUSA ENTRE MOVIMIENTOS
  m.shiftLeft(false, true);
  printStringWithShift(string1, 100);  // ENVIAMOS EL TEXTO A LOS MODULOS
}
 
// FUNCIONES PARA MOSTRAR LOS CARACTERES EN EL DISPLAY DE LOS MODULOS
void printCharWithShift(char c, int shift_speed){
  if (c < 32) return;
  c -= 32;
  memcpy_P(buffer, CH + 7*c, 7);
  m.writeSprite(maxInUse*8, 0, buffer);
  m.setColumn(maxInUse*8 + buffer[0], 0);
  
  for (int i=0; i<buffer[0]+1; i++) 
  {
    delay(shift_speed);
    m.shiftLeft(false, false);
  }
}
 
void printStringWithShift(char* s, int shift_speed){
  while (*s != 0){
    printCharWithShift(*s, shift_speed);
    s++;
  }
}

Mostrar dibujos o patrones

Usar matrices de leds en nuestro proyecto es una buena forma de incorporar señales de aviso, alertas de estado o simplemente animaciones graciosas como reemplazo de un LCD 16×02. En este caso vamos a ver cómo alternar imágenes para crear una animación sencilla de 2 frames usando la librería LEDControl.h.

Al igual que con la otra librería, la descargamos y descomprimimos en la carpeta Libraries de nuestra instalación del IDE de Arduino. El código está comentado para que sea fácil de entender. Aquí está el enlace para descargarla:

Librería LedControl

//Incluimos la libreria LedControl.h
#include "LedControl.h" 

//Declaramos los pines: DIN, CLK, CS y el nº de displays conectados en serie
LedControl lc=LedControl(8,10,9,2);

//Pausa entre frames  
unsigned long delayTime=900;  
 
//Codigo de los 2 frames que vamos a mostrar:
//Corazón pequeño
byte Heart1[] = {
B00000000,
B01100110,
B11111111,
B11111111,
B01111110,
B00111100,
B00011000,
B00000000};

//Corazón grande
byte Heart2[] = {
B01100110,
B11111111,
B11111111,
B11111111,
B11111111,
B01111110,
B00111100,
B00011000};

//Sub para transformar array #1 en un patron para la matriz
void Heart1GO()
{
  for (int i = 0; i < 8; i++)  
  {
    lc.setRow(0,i,Heart1[i]);
    lc.setRow(1,i,Heart2[i]);
  }
}

//Sub para transformar array #2 en un patron para la matriz
void Heart2GO()
{
  for (int i = 0; i < 8; i++)  
  {
    lc.setRow(0,i,Heart2[i]);
    lc.setRow(1,i,Heart1[i]);
  }
}

//Esta sub se ejecutará 1 sola vez al arrancar el Arduino
void setup() {
lc.shutdown(0,false);    //Iniciamos la matriz led #1
lc.shutdown(1,false);  //Iniciamos la matriz led #2
lc.setIntensity(0,5);    //Intensidad de los led en la matriz #1
lc.setIntensity(1,5);  //Intensidad de los led en la matriz #2
lc.clearDisplay(0);      //Apagamos todos los led de la matriz #1
lc.clearDisplay(1);    //Apagamos todos los led de la matriz #2
}

//Esta sub se ejecutara en bucle una y otra vez mientras el Arduino este alimentado.
void loop() {
Heart1GO();         //Mostramos el patrón #1
delay(delayTime);   //Pequeña pausa
Heart2GO();         //Mostramos el patrón #2
delay(delayTime);   //Pequeña pausa
}

Creando patrones en binario

Como hemos visto en los ejemplos anteriores cada dígito o carácter esta compuesto de un código en binario que define el estado de cada led de la matriz. Para generar estos códigos de forma fácil y rápida hemos diseñado una pequeña aplicación para Windows basada en una herramienta online que descubrimos hace algún tiempo.

Herramienta online para crear patrones en matrices led

MAX7219 con Arduino y Una Matriz de LED 7

Como se puede ver en la imagen esta formado por una matriz de 8×8 checkboxes, cada checkbox define el estado de 1 led de la matriz. Para generar un patrón marcamos los checkbox deseados hasta conformar una imagen al estilo pixel art. En la siguiente imagen se ve un corazón generado por el programa.

MAX7219 con Arduino y Una Matriz de LED 8

Podemos generar nuestros propios patrones para integrarlos en cualquier sketch de forma fácil, y recuerda, si el checkbox esta marcado el led estará activado en la matriz.

A %d blogueros les gusta esto: