¿Qué es una matriz?

Las matrices son un conjunto bidimensional de números o símbolos

distribuidos de forma rectangular, en líneas verticales y horizontales. Es
decir sus elementos se organizan en filas y columnas. 

¿Qué es una matriz LED?

Una matriz LED no es otra cosa que un conjunto de LED  agrupados
por filas y columnas.
Las matrices LED  pueden ser de dos tipos Ánodo común o cátodo común.
 ¿Cómo manejar una matriz LED?
En una matriz no es posible controlar todos los LED como si fueran
independientes. Esto pasa porque solo se dispone de los pines
correspondientes a filas y columnas.

Si se aplican valores de alto (HIGH) y bajo (LOW) a varias columnas y

filas, respectivamente, se encenderán todos los LED de las
intersecciones.

Es difícil generar gráficos complejos.

Para poder mostrar gráficos correctamente es necesario realizar un

barrido por filas o columnas. Se iluminará sólo una fila a la vez.
 Para cada carácter se requiere 8 pasos, uno por cada fila.

Las actualizaciones se realizan rápido y con ayuda del efecto de persistencia

visual el ojo humano no es capaz de notar el instante donde los LED  se
apagan.

Por defecto, la frecuencia de trabajo de Arduino UNO es

de 16 MHz.
MHz es la abreviatura de megahercios y significa un millón de ciclos por segundo
El Arduino puede prender y apagar un led 16 millones de veces un segundo

Circuito integrado MAX7219 y MAX7221

(Periférico)
Controlar una matriz de 8×8 implica utilizar 16 señales digitales y refrescar la
imagen de una forma constante. Es por eso que en lugar de utilizar un Arduino
directamente, emplearemos el circuito integrado MAX7219 o MAX7221 para
esta tarea.

 Interfaz de control serie: con tan solo 3 pines podemos controlar toda
una matriz de LEDs.
 Circuito externo simple: requiere pocos componentes externos.
 Conexión en cascada: se pueden conectar varios MAX7219 en cascada.
De esta forma se puede controlar varias matrices LEDs utilizando solo 3
pines de la placa Arduino.
 Modo de bajo consumo: puede consumir solo 120 uA.
existen módulos de matrices LEDs para Arduino con el circuito montado.
Existen de una única matriz o de varias.
 MAX7219

Los pines DIN, SCK y CS conforman

la interfaz de comunicación, es decir,
que mediante estos pines la placa
Arduino le envía comandos al chip

Proyecto de prueba para iniciar a trabajar con una matriz de led

1° Instalar librería MAX7219 con Arduino

Para esto tienes que abrir el Gestor
de Librerías que se encuentra
en Herramientas/Administrar
Bibliotecas…

Digitamos ledcontrol y

Esperamos un momento

Despues que cargue los archivos

debemos instalar la librería

Y cerramos el gestor de librerias

2° Incluir librería led control

En programas / incluir librerias seleccionamos

ledcontrol

3° el IDE de Arduino

Incluida la libbreria. En el ide de arduino creamos un objeto llamado led control y le podemos
dar un nombre, en este caso se le nombrara lc y se le asignan los pines de conexiones los
cuales pueden ser 11, 13, 10, 1 que son los cuatro parámetros requeridos por arduino para
interactuar con la matriz
Cada pin corresponde a:

Led control requiere de una serie de parámetros que deben ser configurados en el void setup

Inicio apagado ( N° dispositivo, estado)

Intensidad de brillo ( N° dispositivo, intensidad)

Borrar matriz (N° dispositivo)

Se dispone de un máximo de 8 dispositivos conectados, estos se enumeran desde el cero hasta

el 7 , el primer modulo o matriz debe llevar el numero 0,

El cero equivale a la primera matriz, la

condición shutdown indica que inicia apagado,
por lo tanto, al colocar false o falso en el estado, indicaremos que inicie prendida.

La intensidad se da en una escala del 0 al

15, 4 de intensidad es aconsejable para
trabajar en interiores
Este parámetro es opcional, pero de no
limpiar la matriz se puede generar
ocasionalmente algún error si queda un led prendido de un diagrama previo

En el void loop utilizaremos dos bucles “for” (Un ciclo “for” generalmente contiene una
variable que cambia a lo largo del ciclo,)

El primer bucle for

Inicia con una variable de nombre fila y un valor que inicia en cero, este bucle se mantiene
siempre que fila sea menor que 8 y en cada interaccion, fila se incrementa en uno dada la
condicion ++, con esto se hace un “barrido” por todos los led de la fila,

El segundo bucle hace lo mismo, pero con cada columna.

con la funcion set led

determinamos el numero del dispositivo( matriz), variable fila, variable columna y el estado
que deseamaos para esta ubicación, en este caso es true, ( verdadero o prendido) ,

con esto cuando el bucle for nos hace un barrido por cada led de la matriz, se inicia
prendiendo el primer led de la matriz,

damos una espera de 100 milisegundos y luego con

apagamos el led, nuevamente,

da una nueva espera de apagado y continuar con el siguiente led hasta completar toda la
matriz.

Sketch
Lista de 'instrucciones' para la placa Arduino.
 Montaje a realizar
& después?
 //Programa que enciende y apaga cada elemento de la matriz de 8x8

#include "LedControl.h" // incluye libreria LedControl

LedControl lc=LedControl(11,13,10,1); // crea objeto
void setup() {
lc.shutdown(0,false); // enciende la matriz
lc.setIntensity(0,4); // establece brillo
lc.clearDisplay(0); // blanquea matriz
}
void loop(){
for(int fila = 0; fila < 8; fila++) { // itera por las filas
for(int columna = 0; columna < 8; columna++) { // itera por las columnas
lc.setLed(0,fila,columna,true); // enciende LED
delay(100); // demora de 100 mseg
lc.setLed(0,fila,columna,false); // apaga LED
delay(100); // demora de 100 mseg.
}
}
}

//Programa que enciende cada elemento de la matriz de 8x8

#include "LedControl.h" // incluye libreria LedControl

LedControl lc=LedControl(11,13,10,1); // crea objeto

void setup() {
lc.shutdown(0,false); // enciende la matriz
lc.setIntensity(0,4); // establece brillo
lc.clearDisplay(0); // blanquea matriz
}
void loop(){
for(int fila = 0; fila < 8; fila++) { // itera por las filas
for(int columna = 0; columna < 8; columna++) { // itera por las columnas
lc.setLed(0,fila,columna,true); // enciende LED
delay(200); // demora de 200 mseg.
}
}
lc.clearDisplay(0); // blanquea matriz
}

Programa
que
muestra
los
digitos
numericos
0 a 9 a
intervalos
de un
segundo.

Autor: bitwiseAr

*/

#include "LedControl.h" // incluye libreria LedControl

LedControl lc=LedControl(11,13,10,1); // crea objeto

#define demora 1000 // constante demora con valor de

1000

byte cero[8]= { // array que contiene

todos los elementos de las

B00111000, // filas necesarias por mostrar el

digito cero

B01000100,

B01000100,

B01000100,

B01000100,

B01000100,

B01000100,

B00111000

};
byte uno[8]= { // array que contiene todos los
elementos de las

B00010000, // filas necesarias por mostrar el

digito uno

B00110000,

B00010000,

B00010000,

B00010000,

B00010000,

B00010000,

B00111000

};

byte dos[8]= { // array que contiene todos los

elementos de las

B00111000, // filas necesarias por mostrar el

digito dos

B01000100,

B00000100,

B00000100,

B00001000,

B00010000,

B00100000,

B01111100
};

byte tres[8]= { // array que contiene

todos los elementos de las

B00111000, // filas necesarias por mostrar el

digito tres

B01000100,

B00000100,

B00011000,

B00000100,

B00000100,

B01000100,

B00111000

};

byte cuatro[8]= { // array que contiene todos los

elementos de las

B00001000, // filas necesarias por mostrar el

digito cuatro

B00011000,

B00101000,

B01001000,

B01001000,

B01111100,

B00001000,
 B00001000

};

byte cinco[8]= { // array que contiene todos los

elementos de las

B01111100, // filas necesarias por mostrar el

digito cinco

B01000000,

B01000000,

B01111000,

B00000100,

B00000100,

B01000100,

B00111000

};

byte seis[8]= { // array que contiene

todos los elementos de las

B00111000, // filas necesarias por mostrar el

digito seis

B01000100,

B01000000,

B01111000,

B01000100,

B01000100,
 B01000100,

B00111000

};

byte siete[8]= { // array que contiene todos los

elementos de las

B01111100, // filas necesarias por mostrar el

digito siete

B00000100,

B00000100,

B00001000,

B00010000,

B00100000,

B00100000,

B00100000

};

byte ocho[8]= { // array que contiene

todos los elementos de las

B00111000, // filas necesarias por mostrar el

digito ocho

B01000100,

B01000100,

B00111000,

B01000100,
 B01000100,

B01000100,

B00111000

};

byte nueve[8]= { // array que contiene todos los

elementos de las

B00111000, // filas necesarias por mostrar el

digito nueve

B01000100,

B01000100,

B01000100,

B00111100,

B00000100,

B01000100,

B00111000

};

void setup() {

lc.shutdown(0,false); // enciende la matriz

lc.setIntensity(0,4); // establece brillo

lc.clearDisplay(0); // blanquea matriz

}
void loop(){

mostrar_0(); // llama funcion mostrar_0

delay(demora); // demora

mostrar_1(); // llama funcion mostrar_1

delay(demora); // demora

mostrar_2(); // llama funcion mostrar_2

delay(demora); // demora

mostrar_3(); // llama funcion mostrar_3

delay(demora); // demora

mostrar_4(); // llama funcion mostrar_4

delay(demora); // demora

mostrar_5(); // llama funcion mostrar_5

delay(demora); // demora

mostrar_6(); // llama funcion mostrar_6

delay(demora); // demora

mostrar_7(); // llama funcion mostrar_7

delay(demora); // demora

mostrar_8(); // llama funcion mostrar_8

delay(demora); // demora

mostrar_9(); // llama funcion mostrar_9

delay(demora); // demora

}
void mostrar_0(){ // funcion mostrar_0

for (int i = 0; i < 8; i++) // bucle itera 8 veces por

el array

lc.setRow(0,i,cero[i]); // establece fila con valor de

array cero en misma posicion

void mostrar_1(){ // funcion mostrar_1

for (int i = 0; i < 8; i++) // bucle itera 8 veces por

el array

lc.setRow(0,i,uno[i]); // establece fila con valor de

array uno en misma posicion

void mostrar_2(){ // funcion mostrar_2

for (int i = 0; i < 8; i++) // bucle itera 8 veces por

el array

lc.setRow(0,i,dos[i]); // establece fila con valor de

array dos en misma posicion

}
void mostrar_3(){ // funcion mostrar_3

for (int i = 0; i < 8; i++) // bucle itera 8 veces por

el array

lc.setRow(0,i,tres[i]); // establece fila con valor de

array tres en misma posicion

void mostrar_4(){ // funcion mostrar_4

for (int i = 0; i < 8; i++) // bucle itera 8 veces por

el array

lc.setRow(0,i,cuatro[i]); // establece fila con

valor de array cuatro en misma posicion

void mostrar_5(){ // funcion mostrar_5

for (int i = 0; i < 8; i++) // bucle itera 8 veces por

el array

lc.setRow(0,i,cinco[i]); // establece fila con valor de

array cinco en misma posicion

}
}

void mostrar_6(){ // funcion mostrar_6

for (int i = 0; i < 8; i++) // bucle itera 8 veces por

el array

lc.setRow(0,i,seis[i]); // establece fila con valor de

array seis en misma posicion

void mostrar_7(){ // funcion mostrar_7

for (int i = 0; i < 8; i++) // bucle itera 8 veces por

el array

lc.setRow(0,i,siete[i]); // establece fila con valor de

array siete en misma posicion

void mostrar_8(){ // funcion mostrar_8

for (int i = 0; i < 8; i++) // bucle itera 8 veces por

el array

lc.setRow(0,i,ocho[i]); // establece fila con valor de

array ocho en misma posicion
 }

void mostrar_9(){ // funcion mostrar_9

for (int i = 0; i < 8; i++) // bucle itera 8 veces por

el array

lc.setRow(0,i,nueve[i]); // establece fila con valor de

array nueve en misma posicion