Descripción
Tenemos un integrado del fabricante Maxim, el MAX7219/MAX7221 que facilita el trabajo con las matrices LEDs y hasta con los displays de 7 segmentos. Sus características son:
• Entrada y salida en serie, para necesitar menos pines.
Tenemos un integrado del fabricante Maxim, el MAX7219/MAX7221 que facilita el trabajo con las matrices LEDs y hasta con los displays de 7 segmentos. Sus características son:
• Controla displays de 7 segmentos de hasta 8 dígitos.
• Bar graph displays o Barras de LEDs.
• Matrices de 8×8 o hasta 64 LEDs individuales.
• Solo requiere una resistencia externa para los 64 LEDs.
• Incluye decodificador BCD (No hay necesidad de dibujar matrices de caracteres, las lleva incluidas. Mayúsculas, minúsculas y hasta números y signos).
• Se encarga del multiplexado de los caracteres y dígitos.
• Incluye memoria de los caracteres.
• Es compatible con SPI y QSPI.
• Es barato y se consiguen por pocos euros.
Así que la única razón para manejar cualquier tipo de displays LED a mano y cableando, es la de comprender un circuito y aprender, pero en el mundo real usaremos un chip de este estilo, porque nos ahorrará muchas horas de improperios.
En el futuro incluiremos alguna sesión mostrando como manejar displays con el chip directamente, pero de momento vamos a empezar por una placa que incluye una matriz de 8×8 con uno de estos chips.
Por menos de lo que valen los componentes, ya nos venden unas plaquitas con una matriz gobernada por un MAX7219 y con pines para olvidarnos de las complicaciones. Son fáciles de montar en una protoboard y con la ventaja añadida de que se pueden cascadear, es decir, montar hasta 8 en serie. La conexión con nuestros Duino es a través de un puerto serie asíncrono SPI
Esquema
Conexión sin el BUS SPI
Conexión con BUS SPI
De nuevo, cuando se usa un controlador externo, la conexión es trivial.
Esquema de dos o más en cascada
Montaje
Montaje sin el BUS SPI
Montaje de 2 o más en cascada
Código
Este primer código nos permite chequear uno por uno los led de la matriz. Se puede modificar la velocidad de chequeo cambiando el valor de los delays, el primero es el tiempo que permanece encendido y el segundo es el tiempo que permanece apagado
#include "LedControl.h"
LedControl lc = LedControl(11,13,10,1);
void setup() {
lc.shutdown(0,false);
lc.setIntensity(0,4);
lc.clearDisplay(0);
}
void loop() {
for(int fila = 0; fila < 8; fila++){
for (int columna = 0; columna< 8; columna++){
lc.setLed(0,fila, columna, true);
delay(25);
lc.setLed(0,fila,columna,false);
delay(25);
}
}
}
Con este segundo código se puede también comprobar que se encienden todos a la vez, es igual que el anterior pero los leds se van quedando encendidos hasta que se enciende toda la matriz, la diferencia con el anterior es que hemos comentado las líneas que apagaban los led y hemos añadido al final una linea que apaga todos los leds a la vez.
#include "LedControl.h"
LedControl lc = LedControl(11,13,10,1);
void setup() {
lc.shutdown(0,false);
lc.setIntensity(0,4);
lc.clearDisplay(0);
}
void loop() {
for(int fila = 0; fila < 8; fila++){
for (int columna = 0; columna< 8; columna++){
lc.setLed(0,fila, columna, true);
delay(200);
//lc.setLed(0,fila,columna,false);
//delay(0);
}
}
lc.clearDisplay(0);
}
En este tercér código hemos definido los caracteres númericos y hemos procedido a presentarlos en la matriz led, de forma que el resultado es una cuenta del 0 al 9 infinitas veces.
#include "LedControl.h"
LedControl lc = LedControl(11,13,10,1);
#define demora 1000
byte cero[8]={
B00111000,
B01000100,
B01000100,
B01000100,
B01000100,
B01000100,
B01000100,
B00111000
};
byte uno[8]={
B00010000,
B00110000,
B01010000,
B00010000,
B00010000,
B00010000,
B00010000,
B00111000
};
byte dos[8]={
B00111000,
B01000100,
B00001000,
B00010000,
B00100000,
B01000000,
B11111100,
B00000000
};
byte tres[8]={
B00111000,
B01000100,
B00000100,
B00111000,
B00000100,
B01000100,
B00111000,
B00000000
};
byte cuatro[8]={
B00001000,
B00011000,
B00101000,
B01001000,
B11111100,
B00001000,
B00001000,
B00000000
};
byte cinco[8]={
B11111100,
B10000000,
B10000000,
B11111000,
B00000100,
B10000100,
B01111000,
B00000000
};
byte seis[8]={
B00111000,
B01000100,
B10000000,
B10111000,
B11000100,
B10000100,
B01111000,
B00000000
};
byte siete[8]={
B11111100,
B10000100,
B00001000,
B00010000,
B00100000,
B00100000,
B00100000,
B00000000
};
byte ocho[8]={
B01111000,
B10000100,
B10000100,
B01111000,
B10000100,
B10000100,
B01111000,
B00000000
};
byte nueve[8]={
B00111000,
B01000100,
B01000100,
B01111100,
B00000100,
B00000100,
B01111000,
B00000000
};
void setup() {
lc.shutdown(0,false);
lc.setIntensity(0,4);
lc.clearDisplay(0);
}
void loop() {
mostrar_0();
delay(demora);
mostrar_1();
delay(demora);
mostrar_2();
delay(demora);
mostrar_3();
delay(demora);
mostrar_4();
delay(demora);
mostrar_5();
delay(demora);
mostrar_6();
delay(demora);
mostrar_7();
delay(demora);
mostrar_8();
delay(demora);
mostrar_9();
delay(demora);
}
void mostrar_0(){
for(int i = 0; i<8; i++){
lc.setRow(0,i,cero[i]);
}
}
void mostrar_1(){
for(int i = 0; i<8; i++){
lc.setRow(0,i,uno[i]);
}
}
void mostrar_2(){
for(int i = 0; i<8; i++){
lc.setRow(0,i,dos[i]);
}
}
void mostrar_3(){
for(int i = 0; i<8; i++){
lc.setRow(0,i,tres[i]);
}
}
void mostrar_4(){
for(int i = 0; i<8; i++){
lc.setRow(0,i,cuatro[i]);
}
}
void mostrar_5(){
for(int i = 0; i<8; i++){
lc.setRow(0,i,cinco[i]);
}
}
void mostrar_6(){
for(int i = 0; i<8; i++){
lc.setRow(0,i,seis[i]);
}
}
void mostrar_7(){
for(int i = 0; i<8; i++){
lc.setRow(0,i,siete[i]);
}
}
void mostrar_8(){
for(int i = 0; i<8; i++){
lc.setRow(0,i,ocho[i]);
}
}
void mostrar_9(){
for(int i = 0; i<8; i++){
lc.setRow(0,i,nueve[i]);
}
}
Finalmente hemos añadidos dos librerías nuevas MD_Parola y MD_MAX7219 que tiene una serie de métodos que nos permite fácilmente scrollear un texto en la matriz, sin la necesidad de definir todos los caracteres
#include <MD_Parola.h>
Como podeis ver.No tenemos que definir arrays de caracteres, ni preocuparnos de multiplexar los pines. Siempre hay que trabajar lo mínimo para conseguir nuestros objetivos (En la jerga informática se llama optimizar recursos)
#include <MD_MAX72xx.h>
#include <SPI.h>
#define HARDWARE_TYPE MD_MAX72XX::FC16_HW
#define MAX_DEVICES 1
#define CS_PIN 10
MD_Parola matriz = MD_Parola(HARDWARE_TYPE, CS_PIN, MAX_DEVICES);
void setup()
{
matriz.begin();
matriz.setIntensity(8);
matriz.displayText(
" Mago Miguelon ",
PA_LEFT,
100,
0,
PA_SCROLL_LEFT,
PA_SCROLL_LEFT
);
}
void loop(){
if (matriz.displayAnimate()){
matriz.displayReset();
}
}
No hay comentarios:
Publicar un comentario