CAPITULO V
“MÓDULO DE ENTRENAMIENTO DE UN DISPLAY MATRICIAL DE
LEDS 8x32”
5.1.-OBJETIVO:
Se elaboró el presente proyecto con el fin de desarrollar prácticas y
ensayos de programación y escritura en una pantalla o display de corrimiento
conformado por una matriz de LEDs de 8x32, controlado por una tarjeta Arduino
Mega y pueda servir como módulo didáctico para los docentes de la especialidad.
5.2.-DESCRIPCIÓN GENERAL
El módulo en su totalidad ha sido construido con dispositivos electrónicos
muy económicos y de fácil adquisición.
Este módulo está basado en la tarjeta Arduino Mega, que es la más básica
y accesible de comprar, utilizada en la mayoría de proyectos de Automatización y
Programación. Arduino es una marca de microcontroladores mundialmente
conocida por los amantes de la electrónica, la programación y la robótica. Es un
proyecto Open Source que pone a disposición de sus usuarios una amplia gama
de dispositivos basados en el microcontrolador AtMega..
La pantalla o display matricial de LEDs está compuesta por una Matriz LED
8x8 MAX7219 para Arduino (4 matrices) y consta de 4 matrices de 8x8 leds de
3mm multiplexados mediante el chip MAX7219.
Partes del módulo
https://www.picmicrolab.com/4-digit-led-dot-matrix-clock-arduino/
El principio de funcionamiento es el multiplexado. Es decir, utilizar unos pocos
pines de E/S del microcontrolador para manejar una serie de circuitos integrados
que se encarguen de excitar los LEDs que lo explicaremos más adelante con
mayor detalle.
5.3.-DESCRIPCIÓN DE LAS PARTES:
5.3.1.- Forma de Alimentación
La siguiente imagen resume los mecanismos que podemos utilizar para alimentar
el Arduino
Puertos de alimentación de la tarjeta arduino
https://www.geekfactory.mx/tutoriales/tutoriales-arduino/
Alimentar el arduino mediante USB
Como ya mencionamos, es la forma más sencilla de alimentar la tarjeta
arduino. A través de esta entrada se admiten ÚNICAMENTE 5 volts.
Alimentación del arduino mediante USB
https://www.geekfactory.mx/tutoriales/tutoriales-arduino/
Podemos obtener los 5 volts del puerto USB de nuestra PC y/o de cualquier
otro dispositivo compatible con USB (como un televisor con puerto USB, por
ejemplo), de un adaptador de teléfono móvil con salida a USB o a través de
uno de los “cargadores de emergencia” disponibles también para teléfonos
móviles.
El puerto USB cuenta con un fusible PPTC que limita la corriente que el
arduino (y sus accesorios) pueden demandar del puerto USB. La corriente
máxima entonces queda limitada a unos 500 mA. Usualmente no podemos
cometer errores de polaridad ni de voltaje cuando usamos USB para alimentar.
Alimentación del arduino mediante cable USB
https://www.geekfactory.mx/tutoriales/tutoriales-arduino/
El jack de alimentación externa del arduino
La tarjeta arduino viene diseñada para aceptar alimentación mediante el
jack estándar que se encuentra en muchos equipos electrónicos. Normalmente
se utiliza un adaptador de corriente (AC/DC).
Alimentación del arduino mediante una fuente externa
https://www.geekfactory.mx/tutoriales/tutoriales-arduino/
Al tratarse de una entrada de corriente directa, la conexión del eliminador
tiene una polaridad que debe ser respetada: el polo positivo debe ir al centro
del conector. El voltaje adecuado a usar en esta entrada es de 7 a 12 volts DC.
Voltajes menores (5 a 7 volts) en esta entrada pueden causar que el
regulador interno del arduino no pueda trabajar correctamente. Voltajes
mayores a 12 pueden causar el rápido sobrecalentamiento del regulador,
aunque la cantidad de accesorios conectados (la demanda de corriente) no sea
grande.
Esta entrada tiene un diodo de protección para inversión de polaridad, por
lo que si no se respeta la polaridad, no ocurrirán daños, pero la tarjeta arduino
NO funcionará.
5.3.2.- Etapa de control
La etapa de control está conformada por la tarjeta Arduino Mega 2560 que
es una marca de microcontroladores mundialmente conocida por los amantes de
la electrónica, la programación y la robótica.
El Arduino Mega 2560 es una placa de desarrollo basada en el
microcontrolador ATmega2560. Tiene 54 entradas/salidas digitales (de las cuales
15 pueden ser usadas como salidas PWM), 16 entradas analógicas, 4 UARTs, un
cristal de 16Mhz, conexión USB, jack para alimentación DC, conector ICSP, y un
botón de reseteo. La placa Mega 2560 es compatible con la mayoría de shields
compatibles para Arduino UNO.
El Arduino Mega 2560 es una actualización que remplaza al Arduino Mega
Placa Arduino Mega 2560
http://panamahitek.com/arduino-mega-caracteristicas
Posee 54 pines digitales que funcionan como entrada/salida; 16 entradas
análogas, un cristal oscilador de 16 MHz, una conexión USB, un boton de reset y
una entrada para la alimentación de la placa.
La comunicación entre la computadora y Arduino se produce a través del
Puerto Serie. Posee un convertidor usb-serie, por lo que sólo se necesita conectar
el dispositivo a la computadora utilizando un cable USB como el que utilizan las
impresoras.
USB_CABLE para conectar la tarjeta Arduino
http://panamahitek.com/arduino-mega-caracteristicas
Arduino Mega posee las siguientes especificaciones:
Microcontrolador: ATmega2560
Voltaje Operativo: 5V
Voltaje de Entrada: 7-12V
Voltaje de Entrada(límites): 6-20V
Pines digitales de Entrada/Salida: 54 (de los cuales 15 proveen salida
PWM)
Pines análogos de entrada: 16
Corriente DC por cada Pin Entrada/Salida: 40 mA
Corriente DC entregada en el Pin 3.3V: 50 mA
Memoria Flash: 256 KB (8KB usados por el bootloader)
SRAM: 8KB
EEPROM: 4KB
Clock Speed: 16 MHz
5.3.3.- Matriz de 8x8
Una matriz LED es un display formado por múltiples LED en distribución
rectangular. Existen distintos tamaños, siendo el más habitual los cuadrados de
8×8 LED.
Matriz de 8x8 LEDs
https://www.luisllamas.es/matriz-led-arduino-max7219/
Podemos combinar varios módulos para formar un display mucho mayor. En estos
display podemos mostrar textos, dibujos o animaciones, como desplazar un texto
(scroll).
Matriz de 8x32 LEDs
https://www.luisllamas.es/matriz-led-arduino-max7219/
Encender una matriz de LED directamente con Arduino requiere emplear
una gran cantidad de pines, lo cual supondría un gran desperdicio de recursos.
Por este motivo, lo normal es que siempre empleemos un controlador
específicamente diseñado para esta función.
Matriz de LEDs 8x8 y su controlador MAX7219
https://www.luisllamas.es/matriz-led-arduino-max7219/
Un controlador habitualmente empleado por ser barato y sencillo es el
integrado MAX7219.
La etapa de control está conformada por la tarjeta Arduino Mega 2560 que
es una marca de microcontroladores mundialmente conocida por los amantes de
la electrónica, la programación y la robótica.
El principio de operación es el multiplexado. Es decir, utilizar unos pocos
pines de E/S del microcontrolador para manejar una serie de circuitos integrados
que se encarguen de excitar los LEDs. Existen diversas maneras y muchos
modelos diferentes de circuitos y algoritmos para realizar esta tarea.
Una matriz de LED está formada por diferentes LED, cableados de forma
conjunta por filas y columnas. Podemos encender un LED determinado de la
matriz aplicando correctamente los valores HIGH y LOW a su respectiva fila y
columna.
Configuración ánodo común y cátodo común de matriz de LEDs 8x8
https://www.luisllamas.es/matriz-led-arduino-max7219/
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.
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.
Este efecto se denomina “Persistencia de visión” (POV), y es consecuencia
de la forma en la que los humanos percibimos el movimiento. Es muy empleado
en electrónica e informática.
Encender una matriz de 8×8 LED requeriría 16 señales digitales y un
trabajo constante del procesador para refrescar la imagen. Eso es una cantidad
enorme de recursos para cualquier autómata, que estaríamos mal aprovechando
para simplemente encender un display.
Por este motivo, empleamos un controlador como el MAX7219 que está
especialmente diseñado para encender displays de 7 segmentos y matrices de
led, y libera a nuestro procesador para hacer tareas mucho más valiosas.
La comunicación con el MAX7219 se realiza a través del bus SPI (Serial
Peripheral Interface) por lo que sólo se requieren 3 pines de Arduino (CS, DIN y
CLK). Además ni siquiera “ocupamos” del todo estos pines, ya que con el mismo
bus podemos controlar múltiples dispositivos.
Circuito MAX7219 conectado a una matriz de LEDs de 8x8
https://howtomechatronics.com/tutorials/arduino/8x8-led-matrix-max7219-
tutorial-scrolling-text-android-control-via-bluetooth/
Por último, las propias placas MAX7219 generalmente incorporan un puerto
de entrada y salida, de forma que podemos combinar múltiples controladores sin
ninguna dificultad.
El esquema eléctrico es sencillo. Alimentamos el módulo a través de Vcc y
Gnd, y conectamos los pines correspondientes para la comunicación SPI.
En caso de usar más de un módulo, conectaríamos las salidas de cada
módulo con las entradas del siguiente, y conectaríamos el primero a Arduino.
MAX7219 conectado al Arduino
https://www.luisllamas.es/matriz-led-arduino-max7219/
Los números de Pin dependen del modelo concreto de Arduino. En Arduino
Mega corresponden con los pines 51, 52, y 53.
DIAGRAMA DE FLUJO EMPLEADO DEL PROGRAMA A DESARROLLAR
INICIO
CONFIGURACIÓN
PA → OUT
PB → OUT
CARGAR LETRA 1
MOSTRAR
CORRER
CARGAR LETRA
MOSTRAR
CORRER
SUBRUTINA CARGA
B0 → F0
B1 → F1
B2 → F2
B4 → F4
B3 → F3
B5 → F5
SUBRUTINA MOSTRAR
F39,0 → RA0
SUB RUTINA CLK
F38,0 → RA0
SUB RUTINA CLK
F0,0 → RA0
SUB RUTINA CLK
Activar la fila 0
SUB RUTINA de retardo
Desactiva la fila 0
5.3.4.- Programa de letra que se desplaza (scroll)
#include "LedControl.h" //Incluimos
#include "Adafruit_GFX.h" //Incluimos
LedControl lc=LedControl(51,52,53,4);
#define demora 1000
byte dos[8]{
B00000000,
B01000011,
B10000101,
B10001001,
B10010001,
B01100001,
B00000000,
B00000000,
};
byte M0[8]{
B00000000,
B00000000,
B00000000,
B00000000,
B00000000,
B00000000,
B00000000,
B00000000,
};
byte M1[8]{
B00000000,
B00000000,
B00000000,
B00000000,
B00000000,
B00000000,
B00000000,
B00000000,
};
byte M2[8]{
B00000000,
B00000000,
B00000000,
B00000000,
B00000000,
B00000000,
B00000000,
B00000000,
};
byte M3[8]{
B00000000,
B00000000,
B00000000,
B00000000,
B00000000,
B00000000,
B00000000,
B00000000,
};
void setup() {
lc.shutdown(0,false);
lc.setIntensity(0,8);
lc.clearDisplay(0);
lc.shutdown(1,false);
lc.setIntensity(1,8);
lc.clearDisplay(1);
lc.shutdown(2,false);
lc.setIntensity(2,8);
lc.clearDisplay(2);
lc.shutdown(3,false);
lc.setIntensity(3,8);
lc.clearDisplay(3);
carga_inicial();
// La función LOOP se ejecutará continuamente después de haberse ejecutado la
función SETUP
void loop() {
corrimiento();
void carga_inicial() {
for(int fila = 0; fila < 8; fila++) {
M0[fila] = dos[fila];
void corrimiento() {
// M0[7] = M3[0];//Retorna el último dato del display
//lc.setColumn(0,7,M0[7]);
M3[0] = M3[1];
lc.setColumn(3,0,M3[0]);
M3[1] = M3[2];
lc.setColumn(3,1,M3[1]);
M3[2] = M3[3];
lc.setColumn(3,2,M3[2]);
M3[3] = M3[4];
lc.setColumn(3,3,M3[3]);
M3[4] = M3[5];
lc.setColumn(3,4,M3[4]);
M3[5] = M3[6];
lc.setColumn(3,5,M3[5]);
M3[6] = M3[7];
lc.setColumn(3,6,M3[6]);
M3[7] = M2[0];
lc.setColumn(3,7,M3[7]);
//delay(demora);
M2[0] = M2[1];
lc.setColumn(2,0,M2[0]);
M2[1] = M2[2];
lc.setColumn(2,1,M2[1]);
M2[2] = M2[3];
lc.setColumn(2,2,M2[2]);
M2[3] = M2[4];
lc.setColumn(2,3,M2[3]);
M2[4] = M2[5];
lc.setColumn(2,4,M2[4]);
M2[5] = M2[6];
lc.setColumn(2,5,M2[5]);
M2[6] = M2[7];
lc.setColumn(2,6,M2[6]);
M2[7] = M1[0];
lc.setColumn(2,7,M2[7]);
M1[0] = M1[1];
lc.setColumn(1,0,M1[0]);
M1[1] = M1[2];
lc.setColumn(1,1,M1[1]);
M1[2] = M1[3];
lc.setColumn(1,2,M1[2]);
M1[3] = M1[4];
lc.setColumn(1,3,M1[3]);
M1[4] = M1[5];
lc.setColumn(1,4,M1[4]);
M1[5] = M1[6];
lc.setColumn(1,5,M1[5]);
M1[6] = M1[7];
lc.setColumn(1,6,M1[6]);
M1[7] = M0[0];
lc.setColumn(1,7,M1[7]);
//delay(demora);
M0[0] = M0[1];
lc.setColumn(0,0,M0[0]);
M0[1] = M0[2];
lc.setColumn(0,1,M0[1]);
M0[2] = M0[3];
lc.setColumn(0,2,M0[2]);
M0[3] = M0[4];
lc.setColumn(0,3,M0[3]);
M0[4] = M0[5];
lc.setColumn(0,4,M0[4]);
M0[5] = M0[6];
lc.setColumn(0,5,M0[5]);
M0[6] = M0[7];
lc.setColumn(0,6,M0[6]);
5.3.5.- Programa frases que se desplaza (scroll)
#include <SPI.h>
#include <Adafruit_GFX.h>
#include <Max72xxPanel.h>
const int pinCS = 53;
const int numberOfHorizontalDisplays = 8;
const int numberOfVerticalDisplays = 1;
Max72xxPanel matrix = Max72xxPanel(pinCS, numberOfHorizontalDisplays,
numberOfVerticalDisplays);
const int wait = 100; // En milisegundos
const int spacer = 1;
const int width = 5 + spacer; // Ancho de la fuente a 5 pixeles
String cadena[]= {"Libreria - Miguel..."}; //textos
void setup() {
// put your setup code here, to run once:
matrix.setIntensity(7); // Ajustar el brillo entre 0 y 15
// Ajustar segun las necesidades
matrix.setPosition(0, 0, 0); // El primer display esta en <0, 0>
matrix.setPosition(1, 1, 0); // El segundo display esta en <1, 0>
matrix.setPosition(2, 2, 0); // El tercer display esta en <2, 0>
matrix.setPosition(3, 3, 0); // El cuarto display esta en <3, 0>
matrix.setPosition(4, 4, 0); // El quinto display esta en <4, 0>
matrix.setRotation(0, 1); // Posición del display
matrix.setRotation(1, 1); // Posición del display
matrix.setRotation(2, 1); // Posición del display
matrix.setRotation(3, 1); // Posición del display
matrix.setRotation(4, 1); // Posición del display
void loop() {
// put your main code here, to run repeatedly:
//int n = random(0,10);
int n = 0;
for (int i = 0; i < width * cadena[n].length() + matrix.width() - 1 - spacer; i++) {
matrix.fillScreen(LOW);
int letter = i / width;
int x = (matrix.width() - 1) - i % width;
int y = (matrix.height() - 8) / 2; // Centrar el texto
while (x + width - spacer >= 0 && letter >= 0) {
if (letter < cadena[n].length()) {
matrix.drawChar(x, y, cadena[n][letter], HIGH, LOW, 1);
letter--;
x -= width;
matrix.write(); // Muestra los caracteres
delay(wait);
