Un solo LED puede ser útil para probar proyectos Arduino. Pero cuando agrega una matriz LED, puede ser realmente creativo, deletreando letras, números y símbolos. También es una forma práctica de aprender cómo se muestran las pantallas más complejas, como la que estás leyendo en el trabajo. En esta guía, le mostraremos cómo configurar una matriz LED básica de 8×8.
Cómo funcionan las matrices LED
Una matriz LED básica como la que usaremos cuenta con una cuadrícula de LED de 8×8 que se puede usar para dibujar caracteres, imágenes básicas y más. En guías anteriores, hemos mostrado cómo Arduino puede controlar un solo LED. Este componente extiende ese concepto a través de una matriz de 64 LED que se pueden controlar con un solo Arduino.
Matriz LED
En una matriz LED, se ejecuta una corriente a través de filas de LED. Para completar el circuito y activar una luz individual, se conecta una columna a tierra. Donde las líneas de alimentación y tierra se cruzan, se activan los LED. Puedes pensar en ello un poco como el juego de mesa Battleship. Por ejemplo, si la alimentación se ejecuta en las filas A, B y C, pero solo la columna 1 está conectada a tierra, se encenderán las luces A1, B1 y C1. El resto permanecerá oscuro.
Esta es una forma práctica de encender varios LED a la vez, pero crea un problema si solo desea que se enciendan ciertos LED en una columna. Digamos, en cambio, que querías que las luces A1, B2 y C3 se iluminaran creando una línea diagonal. Activar las tres filas y columnas activaría toda la cuadrícula, que no es lo que queremos.
Para resolver este problema, un Arduino puede correr a través de un bucle, activando solo una fila de LED a la vez. De esta manera, puede activar tantas columnas como desee sin afectar a la siguiente fila. Sin una función de retardo prolongado (), las filas se activarán en una sucesión tan rápida que el ojo humano no podrá decirlo. Pero le mostraremos cómo agregar un retardo para que pueda ver cómo funciona de todos modos.
Lo que necesitará
Estamos utilizando un método más complicado para controlar la matriz LED con fines educativos: otros componentes pueden reducir el número de pines necesarios, por lo que se necesitarán bastantes más pines y cables que la mayoría de nuestras otras guías. Por esa razón, usaremos un Arduino Mega 2560, en lugar del habitual Arduino Uno, para controlar esta matriz. También necesitará lo siguiente:
| Arduino Mega 2560 |  |
| 8×8 Matriz LED |  |
| 8 resistencia de x 220ohm
La mayoría de los led se quemarán si los conecta directamente a la salida de 5V de un Arduino. Coloque una resistencia de su kit entre el pasador de salida y el LED. |
 |
| Un par de tablas de cortar el pan | 
|
| IDE Arduino |  |
También necesitará un cable USB y bastantes cables, ¡al menos 32!
Hay varias formas de organizar el cableado para este proyecto, pero como puede volverse complejo, recomendamos usar un par de tablas de cortar el pan unidas, una para manejar la matriz LED y otra para cablear las resistencias. Es posible lograr lo mismo mediante el uso de cables con extremos femeninos que corren a la matriz LED, aunque se sentará a un lado en lugar de estacionario, lo que puede ser un poco más engorroso.
El Código
El código para este proyecto hará uso de bucles y matrices para escribir cada LED individualmente. El resultado será una matriz en la parte superior de su script que puede modificar fácilmente para cambiar la imagen que muestra su matriz LED. Primero, pega el código completo en el IDE de Arduino y súbelo a tu Arduino Mega.
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
|
int toDisplay = {
{1,0,0,0,0,0,0,0},
{1,0,0,0,0,0,0,0},
{1,0,0,0,0,0,1,0},
{1,0,0,0,0,0,0,0},
{1,1,1,1,0,0,1,0},
{1,0,0,1,0,0,1,0},
{1,0,0,1,0,0,1,0},
{1,0,0,1,0,0,1,0}
};
void setup() {
for (int i=2; i<=9; i++) {
pinMode(i, SALIDA);
pinMode(i+44, SALIDA);
digitalWrite(i, LOW);
digitalWrite(i+44, de ALTA);
}
pinMode(A0, ENTRADA);
}
void loop() {
for (int i=0; i<8; i++) {
si (i==0) {
digitalWrite(9, BAJO);
}
else {
digitalWrite(i+1, BAJO);
}
for (int j=0; j<8; j++) {
si (toDisplay == 1) {
digitalWrite(j+46, BAJOS);
}
else {
digitalWrite(j+46, de ALTA);
}
}
digitalWrite(i+2, HIGH);
retraso(1);
}
}
|
a continuación, vamos a caminar a través de cómo cada una de estas secciones de trabajo.
|
1
2
3
4
5
6
7
8
9
10
|
int toDisplay = {
{1,0,0,0,0,0,0,0},
{1,0,0,0,0,0,0,0},
{1,0,0,0,0,0,1,0},
{1,0,0,0,0,0,0,0},
{1,1,1,1,0,0,1,0},
{1,0,0,1,0,0,1,0},
{1,0,0,1,0,0,1,0},
{1,0,0,1,0,0,1,0}
};
|
Antes de cualquiera de los bucles principales del boceto, esta matriz multidimensional definirá qué LED deben iluminarse y cuáles deben permanecer oscuros. Hay ocho filas de ocho valores cada una, que se corresponden con las ocho filas de LED en la matriz. Al colocarlos en una cuadrícula en el boceto, hace que sea más fácil visualizar qué forma formarán los LED.
|
1
2
3
4
5
6
7
8
9
|
void setup() {
for (int i=2; i<=9; i++) {
pinMode(i, SALIDA);
pinMode(i+44, SALIDA);
digitalWrite(i, LOW);
digitalWrite(i+44, de ALTA);
}
pinMode(A0, de ENTRADA);
}
|
En la función setup() sección, vamos a inicializar los pines que necesitamos para la matriz. Dado que hay dieciséis pines diferentes, podemos hacer esto de manera más eficiente que uno a la vez. Los pasadores que van al suelo se conectarán a los pasadores 2 a 9. Los pines que envían energía a la matriz correrán a los pines 46 a 53. Esta sección utilizará un bucle para inicializar ambos conjuntos de pines.
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
|
void loop() {
for (int i=0; i<8; i++) {
si (i==0) {
digitalWrite(9, BAJO);
}
else {
digitalWrite(i+1, BAJO);
}
for (int j=0; j<8; j++) {
si (toDisplay == 1) {
digitalWrite(j+46, BAJOS);
}
else {
digitalWrite(j+46, de ALTA);
}
}
digitalWrite(i+2, HIGH);
retraso(1);
}
}
|
En el bucle principal() en la sección de el croquis, hay una multi-paso del bucle. La primera instrucción if restablecerá la última fila utilizada a BAJA, lo que detendrá el flujo de energía hacia ella.
El siguiente bucle for anidado comprobará los datos de la matriz. Si una celda aparece como 1, ajustará el cable de tierra para esa columna a BAJO, permitiendo que la corriente fluya hacia afuera. De lo contrario, establecerá el pasador en ALTO, lo que evitará que se complete un circuito a lo largo de esa columna. Hará esto para las ocho celdas de una fila dada.
Finalmente, la última instrucción digitalWrite () activará toda la fila. Cualquier columna establecida en BAJA se iluminará. El resto permanecerá oscuro. Cuando el croquis vuelva a repetirse, comenzará inmediatamente apagando esa fila.
El último comando es una instrucción delay () que establece el retardo entre cada fila. Se establece en 1 milisegundo en nuestro ejemplo porque cuando la instrucción no está allí, los led se vuelven un poco demasiado tenues. Sin embargo, puede aumentar el retraso para ver qué está haciendo el boceto más lentamente. Debería ver que cada fila se ilumina de una en una, antes de apagarse a medida que se enciende la siguiente fila.
El cableado
Para este proyecto, el cableado es relativamente sencillo, solo hay mucho. Dado que hay muchos pines, describiremos lo que desea hacer para cada circuito completo, en lugar de enumerar cada cable individual como solemos hacer.
Los pines del 2 al 9 deben ser sus pines de alimentación, y los pines del 46 al 53 deben ser sus pines de tierra. Ejecute un cable desde el pasador de alimentación hasta la matriz de LED (consulte para obtener más detalles sobre los pines a continuación, esto es importante), desde la matriz de LED a una resistencia de 220 ohmios, y luego vuelva a ejecutar un cable a un pasador en el Arduino. El pasador 2 eventualmente debe conducir al pasador 46, el pasador 3 debe conducir al pasador 47, y así sucesivamente.
La principal complicación aquí es con la matriz LED en sí. Contradictorio, los pines en ambos lados de la matriz no están en un orden coherente en todos. Por ejemplo, queremos que el pin 2 alimente lo que llamaremos Fila A. Sin embargo, el pin para este es el cuarto pin de la izquierda en la parte superior de la matriz LED. El otro extremo de este circuito, que debe conducir a la Columna 1, es el primer pasador a la derecha en la parte inferior de la matriz.
Dado que este pedido es bastante complicado, explicaremos a qué pines de la matriz se debe conectar directamente cada pin Arduino.
A lo largo de la parte superior de la matriz (el lado con el número impreso en ella) hay ocho pines. De izquierda a derecha, estos deben estar conectados a los siguientes pines del Arduino:
- Pin 7
- Pin 4
- Pin 49
- Pin 2
- Pin 51
- Pin 52
- Pin 3
- Pin 5
Siguiente, la fila inferior de ocho pines en la matriz (el lado sin números) debe estar conectado a los siguientes pines (de izquierda a derecha, con los números hacia arriba):
- Pin 9
- Pin 50
- Pin 48
- Pin 6
- Pin 53
- Pin 8
- Pin 47
- Pin 46
una Vez conectados todos los cables, que puede girar sobre su proyecto y verá la matriz de LED de luz de seguridad. Intente cambiar la disposición de 1s en la matriz inicial y vuelva a cargar el script para crear diferentes formas. También puede ajustar la longitud del comando delay() para ver que cada fila se ilumina de una en una.