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);