Publicado el

Control Hexadecimal de Matriz RGB.

La Matriz de Leds es un módulo integrado con cierto número de filas y columnas de Leds ya interconectados. Haciendo la combinación adecuada de activación en sus pines se pueden visualizar sus estados digitales 0 y 1 (encendido o apagado). La Matriz RGB que se utilizará para este tutorial es 8×8 denominada CILE 2088RGB-5, la cual consta de 32 pines con sus ánodos y cátodos distribuidos e interconectados.

Para este tutorial el reto es teclear y enviar el color así como el mensaje al Arduino Mega 2560 desde el monitor serial para que el Arduino muestre la información en la Matriz RGB.

MATRIZ-RGB SEEEDSTUDIO_TUTORIAL

Este es un Video del funcionamiento de una Matriz 8X8 con Leds normales en color rojo.

[nextpage title=”Materiales.”]
materiales
Para armar el circuito que se utilizará en el tutorial, se necesitará el sigueinte material:

[nextpage title=”Esquemático de la matriz.”]
esquemático RGB
Como se puede ver en el diagrama, esta es la distribución de las conexiones internas de la Matriz RGB, donde se muestran los pines que corresponden a los ánodos y cátodos. Para poder identificar el punto de partida de los pines, el pin #1 se muestra en la parte posterior de la Matriz RGB junto al pin de la esquina inferior derecha.
MATRIZ-RGB SEEEDSTUDIO_TUTORIAL_3
La distribución de pines se muestra en la siguiente lista:

  • Cátodos azules pines: 1, 2, 3, 4, 5, 6, 7, 8.
  • Cátodos verdes pines: 28, 27, 26, 25, 24, 23, 22, 21.
  • Cátodos rojos pines: 9, 10, 11, 12, 13, 14, 15, 16.
  • Ánodos negros pines: 17, 18, 19, 20, 29, 30, 31, 32.

De preferencia los jumpers para la implementación del circuito deben seguir los colores de los pines correspondientes para evitar confusiones. Con esta distribución será más simple controlar y programar la Matriz RGB.
Esta es la estructura de pines en el Arduino Mega 2560, pines en la Matriz RGB, color de cables Jumpers y cómo se van a conectar los pines entre el Arduino y la Matriz RGB:

Pines para encender Leds Azules.
Arduino 42 43 44 45 46 47 48 49 Jumpers
Azules
Matriz RGB 1 2 3 4 5 6 7 8
Pines para encender Leds Verdes.
Arduino 32 33 34 35 36 37 38 39 Jumpers
Verde
Matriz RGB 28 27 26 25 24 23 22 21
Pines para encender Leds Rojos.
Arduino 22 23 24 25 26 27 28 29 Jumpers
Rojo
Matriz RGB 9 10 11 12 13 14 15 16
Pines a los ánodos de matriz.
Arduino 2 3 4 5 6 7 8 9 Jumpers
Negros
Matriz RGB 17 18 19 20 29 30 31 32

[nextpage title=”Diagrama en Fritzing y prueba de conexión.”]
matriz de leds RGB
Diagrama en Fritzing para conectar la Matriz RGB y Arduino.
circuito
Así es como quedaría el circuito implementado en el protoboard, usando los cables Jumpers de colores adecuados para que la distribución del circuito sea más sencilla.
A continuación se muestra el código de pruebas para verificar las conexiones de la Matriz RGB y un vídeo de ejemplo.
Código:
[code language=”java”]
int tiempo=10; //Variable de tipo entero (int) donde se asigna el valor del tiempo para controlar la velocidad de transición
void setup() //Sección void setup
{
for (int j=2; j<38; j++) //Ciclo for para declarar las salidas
pinMode(j, OUTPUT); //Asignación de número de pin a la variable de tipo entero (int) denominada “j”
}
void loop() //Sección void loop
{
for (int negro=2; negro<10; negro++) //Ciclo for de las filas para hacer el barrido de la matriz
{
digitalWrite(negro, HIGH); //Se asigna un “HIGH” a los pines correspondientes de las filas
for (int verde = 14; verde < 22; verde++) //Ciclo for para las columnas de color verde
{
digitalWrite(verde, LOW); //Asignación “LOW” a los pines correspondientes para los leds verdes y se enciendan
delay(tiempo); //Asignación al “delay” la variable tiempo, la cual dependiendo de su valor, se controlará la velocidad del barrido
digitalWrite(verde, HIGH); //Asignación “HIGH” a los pines correspondientes para los leds verdes y se apaguen
}
for (int rojo= 22; rojo < 30; rojo++) //Ciclo for para las columnas de color rojo
{
digitalWrite(rojo, LOW); //Asignación “LOW” a los pines correspondientes para los leds rojos y se enciendan
delay(tiempo); //Asignación al “delay” la variable tiempo, la cual dependiendo de su valor, se controlará la velocidad del barrido
digitalWrite(rojo, HIGH); //Asignación “LOW” a los pines correspondientes para los leds rojos y se enciendan
}
for (int azul= 30; azul < 38; azul++) //Ciclo for para las columnas de color azul
{
digitalWrite(azul, LOW); //Asignación “LOW” a los pines correspondientes para los leds azules y se enciendan
delay(tiempo); //Asignación al “delay” la variable tiempo, la cual dependiendo de su valor, se controlará la velocidad del barrido
digitalWrite(azul, HIGH); //Asignación “LOW” a los pines correspondientes para los leds azules y se enciendan
}
digitalWrite(negro, LOW); //Se asigna un “LOW” a los pines correspondientes de las filas
} //Fin del ciclo for de las filas las filas
} //Fin se la sección void loop
[/code]

[nextpage title=”Introducción al algoritmo de la matriz.”]
Para poder mostrar cualquier figura en la Matriz RGB, es necesario primero dibujarla en un diagrama y sacar los valores de cada bit para poder mandar los estados digitales a la Matriz RGB. Como se muestra en la foto y diagrama siguientes, para poder diseñar una figura, se debe dibujar en una hoja, de preferencia cuadriculada, para rellenar los espacios de la figura que se quiere mostrar, al hacer esto recordando que es un espacio de 8×8, en la primera fila se toman los primeros 4 lugares de derecha a izquierda, cada espacio en blanco representa un 0 lógico y cada espacio rellenado representa un 1 lógico. Una vez identificando los valores lógicos, se identifican los valores correspondientes en la tabla de valores binarios y hexadecimales.
cuaderno
En este caso la figura que se va a mostrar en la Matriz RGB es la letra “A”.

Estructura

Hexadecimal Binario
0 0 (1) (1) (1) (1) 0 0 0x3C 00111100
0 (1) 0 0 0 0 (1) 0 0x42 01000010
0 (1) 0 0 0 0 (1) 0 0x42 01000010
0 (1) (1) (1) (1) (1) (1) 0 0x7E 01111110
0 (1) 0 0 0 0 (1) 0 0x42 01000010
0 (1) 0 0 0 0 (1) 0 0x42 01000010
0 (1) 0 0 0 0 (1) 0 0x42 01000010
0 (1) 0 0 0 0 (1) 0 0x42

01000010

Cada formato es importante, pues simplifica el código final para mostrar el mensaje en la Matriz RGB, a continuación se explicará su función y conversión, junto con un programa para poder visualizar las estructuras de cada figura.

La notación hexadecimal consiste en la numeración en base 16. Los valores para representar esta numeración son: 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E, F.
La notación binaria consiste en la numeración en base 2. Los valores para representar esta numeración son 0 y 1.
Para poder convertir binario a Hexadecimal se debe considerar la siguiente tabla, donde se muestra que se necesitan 4 bits para representar 16 valores (o a 15).

Valores binarios y hexadecimales

BIN 0000 0001 0010 0011 0100 0101 0110 0111 1000 1001 1010 1011 1100 1101 1110 1111
HEX 0 1 2 3 4 5 6 7 8 9 A B C D E

F

Como se ha mostrado en el la tabla con la estructura de la figura, para poder sacar los valores, se deben utilizar los grupos de 4 bits, siendo estos evaluados para sacar los valores hexadecimales en la Matriz RGB, se tendrán 2 números hexadecimales los cuales conforman el valor en cada fila de la estructura de la figura.
Ejemplo:
Binario (00111100) ->(0011)(1100)->(0011 = 3)(1100 = C)->Hexadecimal (3C).
Cada lista en el código siguiente de tipo “Byte” representa una figura y contiene elementos hexadecimales para cada fila de esta mostrada en la matriz como se ha mostrado anteriormente en el diagrama de la letra “A”. Cada lista contiene 8 elementos.
Ejemplo de lista:

byte A[] = { 0x3C, 0x42, 0x42, 0x7E, 0x42, 0x42, 0x42, 0x42 };

Para poder visualizar la estructura de cada letra, se deja el siguiente código para cargarlo al Arduino y visualizar la estructura de la figura junto con sus valores respectivos en el monitor serial, en este programa se encuentran todas las listas de las letras, números, y símbolos. Para poder dibujar más figuras, solo se deben editar las listas considerando la relación de los valores binarios y hexadecimales.
Código:
[code language=”java”]
//Listas
//abecedario
byte A[] = { 0x3C, 0x42, 0x42, 0x7E, 0x42, 0x42, 0x42, 0x42 }; //A
byte B[] = { 0x7C, 0x42, 0x42, 0x7C, 0x42, 0x42, 0x42, 0x7C }; //B
byte C[] = { 0x3E, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x3E }; //C
byte D[] = { 0x7C, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x7C }; //D
byte E[] = { 0x3E, 0x40, 0x40, 0x7C, 0x7C, 0x40, 0x40, 0x3E }; //E
byte F[] = { 0x7E, 0x40, 0x40, 0x7C, 0x40, 0x40, 0x40, 0x40 }; //F
byte G[] = { 0x3E, 0x40, 0x40, 0x40, 0x4E, 0x42, 0x42, 0x7A }; //G
byte H[] = { 0x42, 0x42, 0x42, 0x7E, 0x7E, 0x42, 0x42, 0x42 }; //H
byte I[] = { 0x7E, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x7E }; //I
byte J[] = { 0x7E, 0x18, 0x18, 0x18, 0x18, 0x58, 0x58, 0x78 }; //J
byte K[] = { 0x44, 0x48, 0x50, 0x60, 0x50, 0x48, 0x44, 0x42 }; //K
byte L[] = { 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x7E }; //L
byte M[] = { 0x66, 0x5A, 0x5A, 0x42, 0x42, 0x42, 0x42, 0x42 }; //M
byte N[] = { 0x42, 0x62, 0x52, 0x4A, 0x46, 0x42, 0x42, 0x42 }; //N
byte O[] = { 0x7E, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x7E }; //O
byte P[] = { 0x78, 0x44, 0x44, 0x44, 0x78, 0x40, 0x40, 0x40 }; //P
byte Q[] = { 0x3C, 0x42, 0x42, 0x42, 0x4A, 0x44, 0x42, 0x3C }; //Q
byte R[] = { 0x7C, 0x42, 0x42, 0x42, 0x7C, 0x60, 0x50, 0x48 }; //R
byte S[] = { 0x3E, 0x40, 0x40, 0x3C, 0x02, 0x02, 0x02, 0x7C }; //S
byte T[] = { 0x7E, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18 }; //T
byte U[] = { 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x24, 0x18 }; //U
byte V[] = { 0x42, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x18 }; //V
byte W[] = { 0x42, 0x42, 0x42, 0x42, 0x42, 0x5A, 0x66, 0x42 }; //W
byte X[] = { 0x42, 0x42, 0x24, 0x18, 0x18, 0x24, 0x42, 0x42 }; //X
byte Y[] = { 0x42, 0x42, 0x24, 0x18, 0x10, 0x20, 0x40, 0x40 }; //Y
byte Z[] = { 0x7E, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x7E }; //Z
//simbolos
byte num[] = { 0x24, 0x24, 0x7E, 0x24, 0x24, 0x7E, 0x24, 0x24 }; //#
byte ast[] = { 0x5A, 0x5A, 0x3C, 0x7E, 0x7E, 0x3C, 0x5A, 0x5A }; //*
byte pre[] = { 0x3C, 0x02, 0x02, 0x1C, 0x18, 0x00, 0x18, 0x18 }; //?
byte exc[] = { 0x18, 0x18, 0x18, 0x18, 0x18, 0x00, 0x18, 0x18 }; //!
byte dot[] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x60, 0x60 }; //.
byte spa[] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }; //ESPACIO ” ”
//numeros
byte cero [] = { 0x3C, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x3C }; //CERO
byte uno [] = { 0x38, 0x78, 0x18, 0x18, 0x18, 0x18, 0x18, 0x7E }; //UNO
byte dos [] = { 0x78, 0x04, 0x04, 0x04, 0x3C, 0x40, 0x40, 0x3E }; //DOS
byte tres [] = { 0x7C, 0x02, 0x02, 0x1C, 0x1C, 0x02, 0x02, 0x7C }; //TRES
byte cuatro[] = { 0x0C, 0x14, 0x24, 0x44, 0x3E, 0x04, 0x04, 0x04 }; //CUATRO
byte cinco [] = { 0x7E, 0x40, 0x40, 0x7C, 0x02, 0x02, 0x02, 0x7C }; //CINCO
byte seis [] = { 0x3E, 0x40, 0x40, 0x7C, 0x42, 0x42, 0x42, 0x3C }; //SEIS
byte siete [] = { 0x7E, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x40 }; //SIETE
byte ocho [] = { 0x3C, 0x42, 0x42, 0x3C, 0x3C, 0x42, 0x42, 0x3C }; //OCHO
byte nueve [] = { 0x3C, 0x42, 0x42, 0x42, 0x3E, 0x02, 0x02, 0x3C }; //NUEVE
byte lista( char c, byte fil)
{
//Letras
if (( c == ‘A’)||( c == ‘a’)) return( A[fil]) ;
if (( c == ‘B’)||( c == ‘b’)) return( B[fil]) ;
if (( c == ‘C’)||( c == ‘c’)) return( C[fil]) ;
if (( c == ‘D’)||( c == ‘d’)) return( D[fil]) ;
if (( c == ‘E’)||( c == ‘e’)) return( E[fil]) ;
if (( c == ‘F’)||( c == ‘f’)) return( F[fil]) ;
if (( c == ‘G’)||( c == ‘g’)) return( G[fil]) ;
if (( c == ‘H’)||( c == ‘h’)) return( H[fil]) ;
if (( c == ‘I’)||( c == ‘i’)) return( I[fil]) ;
if (( c == ‘J’)||( c == ‘j’)) return( J[fil]) ;
if (( c == ‘K’)||( c == ‘k’)) return( K[fil]) ;
if (( c == ‘L’)||( c == ‘l’)) return( L[fil]) ;
if (( c == ‘M’)||( c == ‘m’)) return( M[fil]) ;
if (( c == ‘N’)||( c == ‘n’)) return( N[fil]) ;
if (( c == ‘O’)||( c == ‘o’)) return( O[fil]) ;
if (( c == ‘P’)||( c == ‘p’)) return( P[fil]) ;
if (( c == ‘Q’)||( c == ‘q’)) return( Q[fil]) ;
if (( c == ‘R’)||( c == ‘r’)) return( R[fil]) ;
if (( c == ‘S’)||( c == ‘s’)) return( S[fil]) ;
if (( c == ‘T’)||( c == ‘t’)) return( T[fil]) ;
if (( c == ‘U’)||( c == ‘u’)) return( U[fil]) ;
if (( c == ‘V’)||( c == ‘v’)) return( V[fil]) ;
if (( c == ‘W’)||( c == ‘w’)) return( W[fil]) ;
if (( c == ‘X’)||( c == ‘x’)) return( X[fil]) ;
if (( c == ‘Y’)||( c == ‘y’)) return( Y[fil]) ;
if (( c == ‘Z’)||( c == ‘z’)) return( Z[fil]) ;
//numeros
if ( c == ‘0’) return( cero [fil]) ;
if ( c == ‘1’) return( uno [fil]) ;
if ( c == ‘2’) return( dos [fil]) ;
if ( c == ‘3’) return( tres [fil]) ;
if ( c == ‘4’) return( cuatro[fil]) ;
if ( c == ‘5’) return( cinco [fil]) ;
if ( c == ‘6’) return( seis [fil]) ;
if ( c == ‘7’) return( siete [fil]) ;
if ( c == ‘8’) return( ocho [fil]) ;
if ( c == ‘9’) return( nueve [fil]) ;
//simbolos
if (c == ‘#’) return( num[fil]);
if (c == ‘*’) return( ast[fil]);
if (c == ‘?’) return( pre[fil]);
if (c == ‘!’) return( exc[fil]);
if (c == ‘.’) return( dot[fil]);
if (c == ‘ ‘) return( spa[fil]);
}
void setup()
{
Serial.begin(9600);
Serial.println(“Formato de letras, numeros y simbolos para la Matriz de bits:”);
Serial.println(” “);
}
void loop()
{
if (Serial.available())
{
char letra = Serial.read();
Serial.println(“________________________________________________”);
Serial.println(” “);
Serial.println(“Letra”);
Serial.println(” “);
Serial.println(letra);
Serial.println(“Decimales Binarios Hexadecimales Octagonales Estructura en la matriz”);
Serial.println(” “);
for(int s=0; s<=7; s++) { byte F = lista (letra, s); Serial.print(F,DEC); Serial.print(” “); Serial.print(F, BIN); Serial.print(” “); Serial.print(F, HEX); Serial.print(” “); Serial.print(F, OCT); Serial.print(” “); for (int c = 7; c >= 0 ; c–)
{
bool b = (F >> c) & 1;
Serial.print(b);
Serial.print(“,”);
}
Serial.println();
}
Serial.println(“________________________________________________”);
}
}
[/code]
[nextpage title=”Código de la matriz.”]
A continuación se muestra el código para representar cualquier mensaje que se quiera visualizar en la Matriz RGB y abajo su respectiva explicación.
Código:
[code language=”java”]
//Sección de listas y variables
//Listas
//Matriz principal vacia
int matriz[8][8] = {};
//abecedario
byte A[] = { 0x3C, 0x42, 0x42, 0x7E, 0x42, 0x42, 0x42, 0x42 }; //A
byte B[] = { 0x7C, 0x42, 0x42, 0x7C, 0x42, 0x42, 0x42, 0x7C }; //B
byte C[] = { 0x3E, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x3E }; //C
byte D[] = { 0x7C, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x7C }; //D
byte E[] = { 0x3E, 0x40, 0x40, 0x7C, 0x7C, 0x40, 0x40, 0x3E }; //E
byte F[] = { 0x7E, 0x40, 0x40, 0x7C, 0x40, 0x40, 0x40, 0x40 }; //F
byte G[] = { 0x3E, 0x40, 0x40, 0x40, 0x4E, 0x42, 0x42, 0x7A }; //G
byte H[] = { 0x42, 0x42, 0x42, 0x7E, 0x7E, 0x42, 0x42, 0x42 }; //H
byte I[] = { 0x7E, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x7E }; //I
byte J[] = { 0x7E, 0x18, 0x18, 0x18, 0x18, 0x58, 0x58, 0x78 }; //J
byte K[] = { 0x44, 0x48, 0x50, 0x60, 0x50, 0x48, 0x44, 0x42 }; //K
byte L[] = { 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x7E }; //L
byte M[] = { 0x66, 0x5A, 0x5A, 0x42, 0x42, 0x42, 0x42, 0x42 }; //M
byte N[] = { 0x42, 0x62, 0x52, 0x4A, 0x46, 0x42, 0x42, 0x42 }; //N
byte O[] = { 0x7E, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x7E }; //O
byte P[] = { 0x78, 0x44, 0x44, 0x44, 0x78, 0x40, 0x40, 0x40 }; //P
byte Q[] = { 0x3C, 0x42, 0x42, 0x42, 0x4A, 0x44, 0x42, 0x3C }; //Q
byte R[] = { 0x7C, 0x42, 0x42, 0x42, 0x7C, 0x60, 0x50, 0x48 }; //R
byte S[] = { 0x3E, 0x40, 0x40, 0x3C, 0x02, 0x02, 0x02, 0x7C }; //S
byte T[] = { 0x7E, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18 }; //T
byte U[] = { 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x24, 0x18 }; //U
byte V[] = { 0x42, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x18 }; //V
byte W[] = { 0x42, 0x42, 0x42, 0x42, 0x42, 0x5A, 0x66, 0x42 }; //W
byte X[] = { 0x42, 0x42, 0x24, 0x18, 0x18, 0x24, 0x42, 0x42 }; //X
byte Y[] = { 0x42, 0x42, 0x24, 0x18, 0x10, 0x20, 0x40, 0x40 }; //Y
byte Z[] = { 0x7E, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x7E }; //Z
//simbolos
byte num[] = { 0x24, 0x24, 0x7E, 0x24, 0x24, 0x7E, 0x24, 0x24 }; //#
byte ast[] = { 0x5A, 0x5A, 0x3C, 0x7E, 0x7E, 0x3C, 0x5A, 0x5A }; //*
byte pre[] = { 0x3C, 0x02, 0x02, 0x1C, 0x18, 0x00, 0x18, 0x18 }; //?
byte exc[] = { 0x18, 0x18, 0x18, 0x18, 0x18, 0x00, 0x18, 0x18 }; //!
byte dot[] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x60, 0x60 }; //.
byte spa[] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }; //ESPACIO ” ”
//numeros
byte cero [] = { 0x3C, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x3C }; //CERO
byte uno [] = { 0x38, 0x78, 0x18, 0x18, 0x18, 0x18, 0x18, 0x7E }; //UNO
byte dos [] = { 0x78, 0x04, 0x04, 0x04, 0x3C, 0x40, 0x40, 0x3E }; //DOS
byte tres [] = { 0x7C, 0x02, 0x02, 0x1C, 0x1C, 0x02, 0x02, 0x7C }; //TRES
byte cuatro[] = { 0x0C, 0x14, 0x24, 0x44, 0x3E, 0x04, 0x04, 0x04 }; //CUATRO
byte cinco [] = { 0x7E, 0x40, 0x40, 0x7C, 0x02, 0x02, 0x02, 0x7C }; //CINCO
byte seis [] = { 0x3E, 0x40, 0x40, 0x7C, 0x42, 0x42, 0x42, 0x3C }; //SEIS
byte siete [] = { 0x7E, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x40 }; //SIETE
byte ocho [] = { 0x3C, 0x42, 0x42, 0x3C, 0x3C, 0x42, 0x42, 0x3C }; //OCHO
byte nueve [] = { 0x3C, 0x42, 0x42, 0x42, 0x3E, 0x02, 0x02, 0x3C }; //NUEVE
//variables de asignación
String color = ” “;
String s =” “;
int opcion1;
int opcion2;
//Sección de la función de listas
byte lista( char c, byte fil) //Función que tiene como parámetros la letra, número o símbolo (c) y el byte en la lista (fil)
{
//Letras
if (( c == ‘A’)||( c == ‘a’)) return( A[fil]) ;
if (( c == ‘B’)||( c == ‘b’)) return( B[fil]) ;
if (( c == ‘C’)||( c == ‘c’)) return( C[fil]) ;
if (( c == ‘D’)||( c == ‘d’)) return( D[fil]) ;
if (( c == ‘E’)||( c == ‘e’)) return( E[fil]) ;
if (( c == ‘F’)||( c == ‘f’)) return( F[fil]) ;
if (( c == ‘G’)||( c == ‘g’)) return( G[fil]) ;
if (( c == ‘H’)||( c == ‘h’)) return( H[fil]) ;
if (( c == ‘I’)||( c == ‘i’)) return( I[fil]) ;
if (( c == ‘J’)||( c == ‘j’)) return( J[fil]) ;
if (( c == ‘K’)||( c == ‘k’)) return( K[fil]) ;
if (( c == ‘L’)||( c == ‘l’)) return( L[fil]) ;
if (( c == ‘M’)||( c == ‘m’)) return( M[fil]) ;
if (( c == ‘N’)||( c == ‘n’)) return( N[fil]) ;
if (( c == ‘O’)||( c == ‘o’)) return( O[fil]) ;
if (( c == ‘P’)||( c == ‘p’)) return( P[fil]) ;
if (( c == ‘Q’)||( c == ‘q’)) return( Q[fil]) ;
if (( c == ‘R’)||( c == ‘r’)) return( R[fil]) ;
if (( c == ‘S’)||( c == ‘s’)) return( S[fil]) ;
if (( c == ‘T’)||( c == ‘t’)) return( T[fil]) ;
if (( c == ‘U’)||( c == ‘u’)) return( U[fil]) ;
if (( c == ‘V’)||( c == ‘v’)) return( V[fil]) ;
if (( c == ‘W’)||( c == ‘w’)) return( W[fil]) ;
if (( c == ‘X’)||( c == ‘x’)) return( X[fil]) ;
if (( c == ‘Y’)||( c == ‘y’)) return( Y[fil]) ;
if (( c == ‘Z’)||( c == ‘z’)) return( Z[fil]) ;
//numeros
if ( c == ‘0’) return( cero [fil]) ;
if ( c == ‘1’) return( uno [fil]) ;
if ( c == ‘2’) return( dos [fil]) ;
if ( c == ‘3’) return( tres [fil]) ;
if ( c == ‘4’) return( cuatro[fil]) ;
if ( c == ‘5’) return( cinco [fil]) ;
if ( c == ‘6’) return( seis [fil]) ;
if ( c == ‘7’) return( siete [fil]) ;
if ( c == ‘8’) return( ocho [fil]) ;
if ( c == ‘9’) return( nueve [fil]) ;
//simbolos
if (c == ‘#’) return( num[fil]);
if (c == ‘*’) return( ast[fil]);
if (c == ‘?’) return( pre[fil]);
if (c == ‘!’) return( exc[fil]);
if (c == ‘.’) return( dot[fil]);
if (c == ‘ ‘) return( spa[fil]);
}
//Sección de declaración de salidas y mensajes impresos en el monitor serial solo una vez
void setup() //Sección void setup
{
for (int j=2; j<10; j++) //Ciclo for para declarar las salidas
{pinMode(j, OUTPUT);} //Pines de salidas
Serial.begin(9600); //Iniciación del monitor serial (9600 baudios)
Serial.println(“Monitor serial en linea con el Arduino”); //Mensaje que aparecerá solo una vez en el monitor serial cada que se reinicie el arduino o se cierre la ventana
Serial.println(); //Espacio de impresión
Serial.println(“Escriba el color de la matriz o se ejecutara en color de matriz anterior”);
Serial.println(“+ Azul +”); //Opción de color azul
Serial.println(“+ Verde +”); //Opción de color azul
Serial.println(“+ Rojo +”); //Opción de color azul
Serial.println(“+ Morado +”); //Opción de color azul
Serial.println(“+ Amarillo +”); //Opción de color azul
Serial.println(“Escriba ”Exit” para acabar con la ejecucion del programa”);
} //Fin de la sección void setup
//Sección de bucle para ser ejecutado en el prgorama principal o terminarlo
void loop() //Sección void loop
{
if (Serial.available()) //Condición que evalúa si el monitor serial esta disponible para enviar y recibir datos del arduino
{
color = Serial.readString(); //Variable de tipo cadena (String) lacual se le asigna el color en que se imprima el mensaje en la matriz
Serial.println(); //Se imprime un salto de línea para que se vea claro la estructura del caracter de la cadena
Serial.print(“Se selecciono: “); //Mensaje en el monitor serial el cúal mostrará el color que se ha elejido
Serial.println(color); //Color elejido
Serial.println(); //Se imprime un salto de línea para que se vea claro la estructura del caracter de la cadena
if((color==”Exit”)||(color==”exit”)||(color==”EXIT”))     //Condicion que evalúa si el susuario quiere acabar el programa
{
for(int on=2; on<10; on++) //Ciclo for de filas para apagarlas
{
digitalWrite(on, LOW); //Se apagan las filas
for (int off= 22; off < 50; off++) // Ciclo for de columnas para apagarlas
{
digitalWrite(off, HIGH); //Se apagan las columnas
}
}
Serial.println(“ADIOS!!! :D”); //Al acabar el programa, se imprimirá un pequeño mensaje de ADIOS
Serial.end(); //Fin del programa
}
Serial.println(“Escriba el mensaje, tiene 5 segundos”); //Instrucción impresa en el monitor serial para escribir el mensaje al arduino y se imprima en la matriz
Serial.println(); //Se imprime un salto de línea para que se vea claro la estructura del caracter de la cadena
delay(5000); //Tiempo para escribir y mandar el mensaje
s = Serial.readString(); //Variable de tipo cadena (String) para asignar la cadena que se enviará del monitor serial al arduino
Serial.println(“Se esta procesando su mensaje…”); //Instrucción impresa en el monitor serial de tiempo
Serial.println(); //Se imprime un salto de línea para que se vea claro la estructura del caracter de la cadena
delay(3000); //Tiempo para escribir y mandar el mensaje
Serial.println(s); //Se imprime el mensaje mandado desde el monitor serial ya escrito
Serial.println(“———————-“); //Se imprime un separador para la impresión de cada caracter de la cadena
int len=s.length(); //Se evalúa la longitud de la cadena y se asigna a una variable de tipo entero (int)
for(int n = 0; n < len; n++) //Se ejecuta el ciclo for dando como límite la longitud de la cadena para poder evaluar, imprimir y enseñar la cadena
{
char c = s[n]; //Se asigna a la varibale de tipo caracter (char), donde en el cicl for se le asigna de la cadena cada caracter
for(int fil = 0; fil <8; fil++) //Se ejecuta el ciclo for para las filas de la matriz { byte F = lista( c, fil); //Se le asigna a una variable de tipo byte el elemento de la lista dada la función “lista” for (int col =7; col >= 0 ; col–) //Se ejecuta el ciclo for para las columnas de la matriz
{
bool b = (F >> col) & 1; //Se evalúa una operación booleana (AND) asignada a una variable de tipo boolenana (bool) de cada bit de los elementos dado de la lista en ehxamedicmal con el 1
matriz[fil][7-col] = b; //Se le asigna el valor de la variable a la matriz principal
if(matriz[fil][7-col] == 1) //Condición donde se evalua los 0 y 1 dado de la evaluación de la operación booleana
{
Serial.print(c); //Si exite el 1, se imprime en el monitor serial el caracter de la cadena y un espacio
Serial.print(” “);
}
else //Si existe el 0, se imprime en el monitor serial un guíon y un espacio
{
Serial.print(“-“);
Serial.print(” “);
}
} //Fin del ciclo for de las columnas
Serial.println(); //Se imprime un salto de línea para que se vea claro la estructura del caracter de la cadena
} //Fin del ciclo for de las filas
Serial.println(“———————-“); //Se imprime un separador para la impresión de cada caracter de la cadena
colormatriz(color); //Se llama a la función de colormatriz para mostrar cada caracter y su transición respectiva en la matriz de leds
} //Fin del ciclo for de la longitud de la cadena
Serial.println(“Escriba otro color o ”Exit””); //Opción para escojer otro color para la matriz o acabar el programa
Serial.println(“+ Azul +”); //Opción para el color azul
Serial.println(“+ Verde +”); //Opción para el color verde
Serial.println(“+ Rojo +”); //Opción para el color rojo
Serial.println(“+ Morado +”); //Opción para el color morado
Serial.println(“+ Rosa +”); //Opción para el color rosa
Serial.println(“+ Naranja +”); //Opción para el color naranja
Serial.println(“+ Amarillo +”); //Opción para el color amarillo
} //Fin de la condición del monitor serial
} //Fin de la sección void loop
//Sección de transición del mensaje ne la matriz RGB
void colormatriz(String color) //Funcion de la matriz para mostrar la figura dada y realizar la transicon
{
if((color==”Azul”)||(color==”azul”)||(color==”AZUL”)) //Si el color seleccionado es azul
{
for (int j=22; j<30; j++) //Ciclo for para declarar entradas y evitar intervalos de colores diferentes
{pinMode(j, INPUT);} //Pines de entradas
for (int j=32; j<40; j++) //Ciclo for para declarar entradas y evitar intervalos de colores diferentes
{pinMode(j, INPUT);} //Pines de entradas
for (int j=42; j<50; j++) //Ciclo for para declarar las salidas y dar el color correcto {pinMode(j, OUTPUT);} //Pines de salidas apagar(); //Se apaga la matriz para evitar que se prendan leds no seleccionados for(int a=8; a>=-8; a–) //Ciclo for de transicion
{
for(int negro=0; negro<8; negro++) //Ciclo for para las filas
{
for (int azul= 0; azul < 8; azul++) //Ciclo for para las columnas
{
if(matriz[negro][azul] == 1) //Condicion para prender los leds de la matriz correctos
{
digitalWrite(negro+2, HIGH); //Se manda un 1 lógico a la fila correspondiente para el barrido de las filas
digitalWrite((azul+42)-a, LOW); //Se manda un 0 lógico a la columna correspondiente para el barrido de las filas junto con el factor de transicion
delay(1); //Este ”delay” representa el pulso dado para la matriz y el color
digitalWrite(negro+2, LOW); //Se manda un 0 lógico a la fila correspondiente para el barrido de las filas
digitalWrite((azul+42)-a, HIGH); //Se manda un 1 lógico a la columna correspondiente para el barrido de las filas junto con el factor de transicion
if(a==0) //Condicion que evalua si la figura a llegado al centro de la matriz
{
for(int b=0; b<30; b++) //Ciclo for que regula el tiempo de vizualisacion de la letra en el centro de la matriz
{
for(int negro=0; negro<8; negro++) //Ciclo for de las filas
{
for (int azul= 0; azul < 8; azul++) //Ciclo for de las columnas
{
if(matriz[negro][azul] == 1) //Condición donde se evalua los 0 y 1 dado de la evaluación de la operación booleana
{
digitalWrite(negro+2, HIGH); //Se manda un 1 lógico a la fila correspondiente para el barrido de las filas
digitalWrite(azul+42, LOW); //Se manda un 0 lógico a la columna correspondiente para el barrido de las filas
delay(1); //Este ”delay” representa el pulso dado para la matriz y el color
digitalWrite(negro+2, LOW); //Se manda un 0 lógico a la fila correspondiente para el barrido de las filas
digitalWrite(azul+42, HIGH); //Se manda un 1 lógico a la columna correspondiente para el barrido de las filas
} //Fin de la condicion que evalua los 0 y 1 dado de la evaluación de la operación booleana
} //Fin del ciclo for de las columnas
} //Fin del ciclo for de las filas
} //Fin del ciclo for que regula el tiempo de vizualisacion de la letra en el centro de la matriz
a–; //Se le resta al factor de transicion para romper la condicion y que la transicion continue
} //Fin de la condicion que evalua si la figura a llegado al centro de la matriz
} //Fin de la condicion para prender los leds de la matriz correctos
} //Fin del ciclo for de las columnas
} //Fin del ciclo for de las filas
} //Fin del ciclo for de transicion
} //Fin de la condicion del color seleccionado azul
if((color==”Verde”)||(color==”verde”)||(color==”Verde”)) //Lo mismo se aplica para las demas condiciones
{
for (int j=22; j<30; j++)
{pinMode(j, INPUT);}
for (int j=32; j<40; j++)
{pinMode(j, OUTPUT);}
for (int j=42; j<50; j++) {pinMode(j, INPUT);} apagar(); for(int a=8; a>=-8; a–)
{
for(int negro=0; negro<8; negro++)
{
for (int verde= 0; verde < 8; verde++)
{
if(matriz[negro][verde] == 1)
{
digitalWrite(negro+2, HIGH);
digitalWrite((verde+32)-a, LOW);
delay(1);
digitalWrite(negro+2, LOW);
digitalWrite((verde+32)-a, HIGH);
if(a==0)
{
for(int b=0; b<30; b++)
{
for(int negro=0; negro<8; negro++)
{
for (int verde= 0; verde < 8; verde++)
{
if(matriz[negro][verde] == 1)
{
digitalWrite(negro+2, HIGH);
digitalWrite(verde+32, LOW);
delay(1);
digitalWrite(negro+2, LOW);
digitalWrite(verde+32, HIGH);
}
}
}
}
a–;
}
}
}
}
}
}
if((color==”Rojo”)||(color==”rojo”)||(color==”ROJO”))
{
for (int j=22; j<30; j++)
{pinMode(j, OUTPUT);}
for (int j=32; j<40; j++)
{pinMode(j, INPUT);}
for (int j=42; j<50; j++) {pinMode(j, INPUT);} apagar(); for(int a=8; a>=-8; a–)
{
for(int negro=0; negro<8; negro++)
{
for (int rojo= 0; rojo < 8; rojo++)
{
if(matriz[negro][rojo] == 1)
{
digitalWrite(negro+2, HIGH);
digitalWrite((rojo+22)-a, LOW);
delay(1);
digitalWrite(negro+2, LOW);
digitalWrite((rojo+22)-a, HIGH);
if(a==0)
{
for(int b=0; b<30; b++)
{
for(int negro=0; negro<8; negro++)
{
for (int rojo= 0; rojo < 8; rojo++)
{
if(matriz[negro][rojo] == 1)
{
digitalWrite(negro+2, HIGH);
digitalWrite(rojo+22, LOW);
delay(1);
digitalWrite(negro+2, LOW);
digitalWrite(rojo+22, HIGH);
}
}
}
}
a–;
}
}
}
}
}
}
if((color==”Morado”)||(color==”morado”)||(color==”MORADO”))
{
for (int j=22; j<30; j++)
{pinMode(j, OUTPUT);}
for (int j=32; j<40; j++)
{pinMode(j, INPUT);}
for (int j=42; j<50; j++) {pinMode(j, OUTPUT);} apagar(); for(int a=8; a>=-8; a–)
{
for(int negro=0; negro<8; negro++)
{
for (int morado= 0; morado < 8; morado++)
{
if(matriz[negro][morado] == 1)
{
digitalWrite(negro+2, HIGH);
digitalWrite((morado+42)-a, LOW);
delay(1);
digitalWrite((morado+22)-a, LOW);
digitalWrite((morado+42)-a, HIGH);
delay(1);
digitalWrite((morado+22)-a, HIGH);
digitalWrite(negro+2, LOW);
if(a==0)
{
for(int b=0; b<20; b++)
{
for(int negro=0; negro<8; negro++)
{
for (int morado= 0; morado < 8; morado++)
{
if(matriz[negro][morado] == 1)
{
digitalWrite(negro+2, HIGH);
digitalWrite(morado+42, LOW);
delay(1);
digitalWrite(morado+22, LOW);
digitalWrite(morado+42, HIGH);
delay(1);
digitalWrite(morado+22, HIGH);
digitalWrite(negro+2, LOW);
}
}
}
}
a–;
}
}
}
}
}
}
if((color==”Rosa”)||(color==”rosa”)||(color==”ROSA”))
{
apagar();
for (int j=22; j<30; j++)
{pinMode(j, OUTPUT);}
for (int j=32; j<40; j++)
{pinMode(j, INPUT);}
for (int j=42; j<50; j++) {pinMode(j, OUTPUT);} for(int a=8; a>=-8; a–)
{
for(int negro=0; negro<8; negro++)
{
for (int rosa= 0; rosa < 8; rosa++)
{
if(matriz[negro][rosa] == 1)
{
digitalWrite(negro+2, HIGH);
digitalWrite((rosa+22)-a, LOW);
delay(1);
digitalWrite((rosa+42)-a, LOW);
delay(1.5);
digitalWrite((rosa+22)-a, HIGH);
delay(1);
digitalWrite((rosa+42)-a, HIGH);
digitalWrite(negro+2, LOW);
if(a==0)
{
for(int b=0; b<20; b++)
{
for(int negro=0; negro<8; negro++)
{
for (int rosa= 0; rosa < 8; rosa++)
{
if(matriz[negro][rosa] == 1)
{
digitalWrite(negro+2, HIGH);
digitalWrite(rosa+22, LOW);
delay(1);
digitalWrite(rosa+42, LOW);
delay(1.5);
digitalWrite(rosa+22, HIGH);
delay(1);
digitalWrite(rosa+42, HIGH);
digitalWrite(negro+2, LOW);
}
}
}
}
a–;
}
}
}
}
}
}
if((color==”Naranja”)||(color==”naranja”)||(color==”NARANJA”))
{
apagar();
for (int j=22; j<30; j++)
{pinMode(j, OUTPUT);}
for (int j=32; j<40; j++)
{pinMode(j, OUTPUT);}
for (int j=42; j<50; j++) {pinMode(j, INPUT);} for(int a=8; a>=-8; a–)
{
for(int negro=0; negro<8; negro++)
{
for (int naranja= 0; naranja <8; naranja++)
{
if(matriz[negro][naranja] == 1)
{
digitalWrite(negro+2, HIGH);
digitalWrite((naranja+32)-a, LOW);
delay(1);
digitalWrite((naranja+22)-a, LOW);
delay(2);
digitalWrite((naranja+32)-a, HIGH);
delay(1);
digitalWrite((naranja+22)-a, HIGH);
digitalWrite(negro+2, LOW);
if(a==0)
{
for(int b=0; b<20; b++)
{
for(int negro=0; negro<8; negro++)
{
for (int naranja= 0; naranja < 8; naranja++)
{
if(matriz[negro][naranja] == 1)
{
digitalWrite(negro+2, HIGH);
digitalWrite(naranja+32, LOW);
delay(1);
digitalWrite(naranja+22, LOW);
delay(2);
digitalWrite(naranja+32, HIGH);
delay(1);
digitalWrite(naranja+22, HIGH);
digitalWrite(negro+2, LOW);
}
}
}
}
a–;
}
}
}
}
}
}
if((color==”Amarillo”)||(color==”amarillo”)||(color==”AMARILLO”))
{
for (int j=22; j<30; j++)
{pinMode(j, OUTPUT);}
for (int j=32; j<40; j++)
{pinMode(j, OUTPUT);}
for (int j=42; j<50; j++) {pinMode(j, INPUT);} apagar(); for(int a=8; a>=-8; a–)
{
for(int negro=0; negro<8; negro++)
{
for (int amarillo= 0; amarillo <8; amarillo++)
{
if(matriz[negro][amarillo] == 1)
{
digitalWrite(negro+2, HIGH);
digitalWrite((amarillo+22)-a, LOW);
delay(1);
digitalWrite((amarillo+32)-a, LOW);
delay(1);
digitalWrite((amarillo+22)-a, HIGH);
delay(1);
digitalWrite((amarillo+32)-a, HIGH);
digitalWrite(negro+2, LOW);
if(a==0)
{
for(int b=0; b<20; b++)
{
for(int negro=0; negro<8; negro++)
{
for (int amarillo= 0; amarillo < 8; amarillo++)
{
if(matriz[negro][amarillo] == 1)
{
digitalWrite(negro+2, HIGH);
digitalWrite(amarillo+22, LOW);
delay(1);
digitalWrite(amarillo+32, LOW);
delay(1);
digitalWrite(amarillo+22, HIGH);
delay(1);
digitalWrite(amarillo+32, HIGH);
digitalWrite(negro+2, LOW);
}
}
}
}
a–;
}
}
}
}
}
}
}
void apagar() //Condicion para apagar la matriz
{
for(int on=2; on<10; on++) //Ciclo for de filas para apagarlas
{
for (int off= 22; off < 50; off++) // Ciclo for de columnas para apagarlas
{
digitalWrite(off, HIGH); //Se apagan las columnas
}
digitalWrite(on, LOW); //Se apagan las filas
}
}
[/code]
El código principal consta de 5 secciones:

  • Sección de listas.
  • Sección de función de listas.
  • Sección de declaración de salidas.
  • Sección de bucle.
  • Sección de las funciones color-matriz y apagar.

A continuación, se dará la explicación de cada sección.
Sección de listas.
En esta sección se declaran las listas de cada figura, las cuales incluyen el abecedario, números y símbolos,  las cuales se pueden editar siguiendo las instrucciones de cómo convertir los valores binarios a hexadecimales. Esta sección también incluye las variables de asignación usadas en la sección del bucle y transición, las cuales son dos de tipo “String” (‘color’ y ‘s’) y dos de tipo “Int” (‘opcion1’ y ‘ opcion2’), como también se declara la matriz principal que cambiará de forma dinámica su valores dependiendo de los caracteres de la cadena mandada por el monitor serial.
Sección de función de listas.
Esta sección consiste en una función de tipo “Byte” llamada en la sección bucle con dos parámetros, siendo uno el caracter de la cadena dada en el monitor serial, y otro el valor a regresar de la lista dado dentro del primer ciclo for. Esta función regresa un valor de la lista del carácter para ser evaluado y guardado en la matriz global declarada en la sección de listas y mostrar la letra.
Sección de declaración de salidas.
En esta sección (void setup) se declaran las salidas en el Arduino conectadas a la Matriz RGB, como también un mensaje que se mostrará una sola vez en el monitor serial, dando las instrucciones para teclear un color deseado para mostrar en la matriz o, si lo prefiere el usuario, terminar el programa.
Sección de bucle.
En esta sección (void loop), se ejecuta de forma continua la evaluación de cada carácter en la cadena enviada, llamando la función de la sección función de listas que da cada elemento de las listas del carácter. Para evaluar cada bit de los valores hexadecimales, existe una instrucción denominada “Shift”  (ShiftRight ‘>>’ o ShiftLeft ‘<<‘) la cual consiste en recorrer de posición cada bit y ser puesto en una operación booleana (AND) con el valor 1 y así obtener y llenar la Matriz RGB con los estados digitales. Se crean condiciones (if/else) para mostrar la estructura de cada caracter de la cadena evaluando los 0’s y 1’s. Al terminar con los ciclos for, se llama la función “Transición” donde cada carácter se mostrará en la Matriz RGB.
Sección de las funciones color-matriz y apagar.
Esta sección es una función vacía llamada en la sección de bucle, donde se le dan dos valores numéricos para mostrar los colores deseados. Esta función muestra cada carácter de forma dinámica dando una transición de derecha a izquierda donde evalúa cada fila y columnas con un factor de movimiento siendo el tercer bucle el valor de transición, cada transición es para cada color incluidos en las opciones, pues adentro de las condiciones de la función, se llama a la función “apagar” para que los colores se vean nítidos.

[nextpage title=”Prueba final de la matriz.”]
Una vez descargado el código al Arduino, ya se puede visualizar cualquier mensaje en la Matriz RGB, abajo está el vídeo de demostración.

Compártelo: