logo

Matriz, LED, Matrix, Arduino, Tutorial, Proyecto, Arduino, Ejemplo, código

Matriz LED 8×8 Bicolor + 74CH595 


Hola amig@s!

Hoy os presentamos un nuevo Tutorial Arduino muy visual!!

Parte 1: ¿Que vamos a hacer?

En este proyecto arduino, vamos a aprender a conectar una matriz de LED 8×8 bicolor a través de unos registros de desplazamiento (Shift register) que nos van a permitir ahorrar muchos pines en nuestra placa, obteniendo un resultado tan espectacular como se puede ver en este video:

 
 
 
 
 

Podéis descargaros los archivos necesarios para este proyecto compartiéndonos en Twitter o Facebook a través de este enlace!!

También podréis exponer cualquier duda a través del foro oficial del tutorial en Arduino.cc AQUI

Material necesario para este tutorial:

  • 1 x Arduino Uno
  • 1 x Protoboard (o 2 si son pequeñas)
  • 1 x Matriz LED Bicolor
  • 2 x Registros de desplazamiento (Shift Register 74CH595)
  • 16 x Resistencias 220Ω
  • 1 x Juego de Cables

 

Parte 2: Diseñando el Hardware…


En este circuito, no reside demasiada complejidad a la hora de diseñarlo, pues ya conocemos perfectamente que es un diodo LED, como se conecta y cual es la resistencia que debemos colocar en función de sus características técnicas, y una matriz, como veremos, no es más que un montón de led en un mismo encapsulado, si no lo recordáis, podéis echar un vistazo a los siguientes post:

 

A la hora de pensar en el diseño del circuito, es simplemente seguir las instrucciones de cada fabricante para conectar tanto las matrices, como los registros de desplazamiento, así que nos centraremos en entender al máximo posible estos elementos para que podáis desarrollar por vosotros mismos, ya que las matrices no suelen tener nada que ver unas con otras y es probable que la que yo use aquí, no sea como la vuestra, pero si aprendemos a identificarlas correctamente, no habrá mayor problema!!

¿Qué es una matriz de diodos LED?

Una matriz de diodos LED, no es más que un montón de diodos LED dentro de un mismo encapsulado en el que distribuimos los ánodos en 8 columnas de 8 diodos unidos entre sí y los cátodos en 8 filas de 8 diodos (o viceversa, hay muchos modelos) formando, como su nombre indica, una matriz de “pixeles”, siendo cada pixel la intersección de una fila con una columna.

Cuando nos hablan de una matriz 8×8 o 7×5, se refieren a la cantidad de filas x columnas que posee, por lo que una matriz de 8×8 es una matriz de 64 diodos LED, veamos el diagrama de conexión de una matriz de un solo color 8×8 con cátodos en filas y ánodos en columnas.

"Diagrama matrid led 8x8", "Arduino led matrix", "led matrix",Matriz, LED, Matrix, Arduino, Tutorial, Proyecto, Arduino, Ejemplo, código

En primer lugar, debemos diferenciar entre la numeración de los PINES, con la numeración de las filas y columnas, donde el número de pin será aquella patilla física que conectaremos a nuestro Arduino, y la fila y columna,  la referencia que tomaremos para encontrar un LED determinado, al más estilo de hundir la flota, fila 2 – columna 3 = Hundido.. digo.. encendido..

Debéis siempre mirar vuestra hoja de características de la matriz, porque puede ser que difieran las conexiones internas de una marca a otra, o incluso en la misma marca, es decir, que en esta matriz, por ejemplo, la fila uno se corresponde con el pin 9, pero puede darse el caso que en otro modelo sea diferente, o que incluso las filas sean ánodos.

Una vez entendido esto, veamos como hacer que se encienda un diodo de la matriz.

Como antes comentaba, es muy similar al viejo juego de hundir la flota, una fila “i” con una columna “j” nos va a dar una coordenada única, y para encender ese diodo, tan solo tendremos que tener la fila conectada a masa y la fila a positivo.

Si tenemos varias filas conectadas a masa, por ejemplo la 1 la 3 y la 5, al introducir una tensión positiva por la columna 1, se encenderán los diodos correspondientes a F1 – C1, F3-C1 y F5 – C1, siendo F = Fila y C = Columna.

Pero claro, a nosotros nos interesa crear ciertas formas o letras en la matriz, y si quisiéramos “dibujar” dos filas diferentes entre si, no podríamos, ya que si tenemos la fila 1 y 2 conectadas a masa, y en la primera fila queremos encender el led de la primera columna, y en la segunda fila, el de la segunda columna, al tener constantemente alimentadas a positivo las dos columnas y a negativo las filas, se van a encender siempre los cuatro led de la esquina superior izquierda, intentar entenderlo, es importante.

Para solucionar esto, lo que se hace es sincronizar instantes, es decir, seguir el siguiente algoritmo:

  • Conecto a masa la fila uno y a positivo la columna 1
  • Quito masa de la fila uno y positivo de la columna 1.
  • Conecto a masa fila 2 y a positivo la columna 2.
  • Quito masa de la fila 2 y positivo de la columna 2.
  • ………

 

Y esto lo repetimos tan rápidamente, que al ojo humano, nos parece que están encendido los dos diodos constantemente, observar esta animación para entender como se dibuja la letra W en una matriz haciendo coincidir ciertas columnas con determinadas filas de una manera muy rápida.

"Matriz Led", Arduino, "refresco de matriz" "Led matrix 7x5", Matriz, LED, Matrix, Arduino, Tutorial, Proyecto, Arduino, Ejemplo, códigovía wikipedia

 

¿Qué es un registro de desplazamiento?

El CI (circuito integrado) 74CH595 es un chip con 8 salidas digitales las cuales vamos a poder controlar de una manera muy sencilla con solo tres pines de nuestro Arduino, además, se pueden conectar en cascada ilimitadamente en detrimento, eso sí, de la velocidad con la que queramos actuar en una salida determinada, siendo más baja, cuantos más integrados usemos.

¿Cómo lo consigue?

Nosotros le mandamos palabras de 8 bit (desde 00000000 hasta 11111111) por una salida digital y él las interpreta de tal manera que el primer 0 o 1 empezando por la derecha, establece el estado (0 o 1) de la primera salida del chip, el segundo 0 o 1, el de la segunda salida de chip, y así sucesivamente… Recomiendo familiarizarse con el sistema binario, y sobre como pasar de binario a decimal para comprender mejor este tutorial, podéis hacerlo desde ESTE ENLACE A WIKIPEDIA.

Para seguir explicando de una manera más técnica, veamos el esquema de patinaje de este chip:

"Desplazamiento de registro", "Matriz Led" "Led matrix", Arduino, Matriz, LED, Matrix, Arduino, Tutorial, Proyecto, Ejemplo, código

Donde:

  • Q0 – Q 7: Salidas en paralelo a las que conectaremos los ánodos de nuestra matriz.
  • Gnd: Masa de alimentación del chip.
  • Q7′: Salida serie donde conectaremos otro chip si nos hicieran falta más salidas digitales, de manera que la primera palabra de 8 bit pasaría de largo del primer chip y se derivaría por esta patilla al segundo.
  • MR: Master reset, el cual tendremos conectado a +Vcc.
  • SH_CP: Pin para el reloj que controlaremos desde Arduino y que marcará la frecuencia de desplazamiento del registro a modo de un pulso por bit, si tenemos un solo registro de desplazamiento, el tren de pulsos se vería como en la siguiente imagen:

 

"tren de impulsos" "Shift register" tiempo, osciloscopio, Matriz, LED, Matrix, Arduino, Tutorial, Proyecto, Arduino, Ejemplo, código

 

  • ST_CP: Pin para el latch, este pin deberemos ponerlo a “0″ desde arduino cuando queramos enviar un dato para que el chip nos “escuche” y a “1″ cuando hayamos terminado, hasta que nos se pone a “1″, no se escriben las salidas de ningún chip. Si observamos parpadeos o inestabilidades, se le debe colocar un condensador de 100nf (Nano Faradios, los cuales ya veremos más adelante). Aquí os dejo unas imágenes de la señal de latch sin condensador en la primera y con condensador en la segunda:

 

"proyecto Arduino" "tutorial arduino" Arduino, tutorial, proyecto

 

"Señal de Latch con condesador" "desplazamiento de registro" "Shift register" Arduino

 

  • /OE: Ouput enable negado, o salida disponible negada, la cual llevaremos a masa.
  • DS: Datos en serie que enviaremos desde nuestro Arduino para que los reparta por las salidas.
  • Vcc: Alimentación +5v del chip

 

Para identificar las patillas en vuestro chip, debéis colocarlo de manera que la muesca del extremo del chip, quede como en la imagen, así podréis saber cual es cada patilla sin lugar a dudas.

Con todo esto, ya debemos tener algo más claro el funcionamiento de estos nuevos componentes, así que veamos el circuito a montar y empecemos a programar!

Como comenté al principio, el circuito en sí es muy sencillo, simplemente se debe tener claro las características técnicas de la matriz y como funciona un registro de desplazamiento.

El esquema interno de una matriz bicolor, se corresponde al de la siguiente imagen:

"LED Matrix" "matrix led" "8x8" "bicolor" Arduino, tutoriales, proyectos, ejemplos,

De manera que lo único de debéis hacer es conectar las salidas de un registro a las columnas de un color, y las salidas de otro a las del otro color.

En cuanto a la conexión de los registros de desplazamiento, es muy sencilla, un pin para el latch, uno para el clock y otro para los datos.

La manera de encadenarlos es conectando Q7′ del primero a DS del segundo.

Veamos la distribución en protoboard para que quede todo más claro!

He decidido no enlazar los cables a la matriz para que así, cada uno simplemente busque en el datasheet (características técnicas) de su matriz, el pin correspondiente a cada fila y columna de cada color. Fácil, no? Haz click en la imagen para agrandarla.

"LED MATRIX", ELECTRONICA, 8X8, PROTOBARD, Matriz, LED, Tutorial, Proyecto, Arduino, Ejemplo, código

Aquí de nuevo no he colocado las conexiones a la matriz, de esta manera es menos lioso y así os hago trabajar un poco!! Simplemente tendréis que unir de Q0 a Q7 con cada ánodo columna de la 1 a la 8 respectivamente en vuestros desplazamientos de registros.

"tutoriales arduino" "ejemplos Arduino" "Proyectos arduino" "74 595" "led matrix" "shift register"

Una vez que tenemos todo conectado.. empecemos a programar!

Parte 3: Programando…

Antes de comenzar a darle caña al programa, os comento una novedad de Arduteka, a partir de ahora, cada proyecto tendrá enlazado su correspondiente hilo en el foro de Arduino.cc, de manera que allí podáis derivar vuestras consultas, dudas, sugerencias y versiones mejoradas tanto de software como de hardware, que yo me puedo equivocar muy fácilmente!! Descarga el programa haciendo click en el siguiente botón..


El enlace del foro para este proyecto es ESTE!

En cuanto al programa, he realizado uno muy sencillo, y nada optimizado, así que espero que aquellos ases de la programación colaboréis en mejorarlo, adaptarlo quemarlo o lo que haga falta en el foro, ok?

Observemos en primer lugar el programa al completo.

 Tutorial # 0008 Arduino Academy
 Matriz bicolor 8x8 + Shift Register 74CH595

 En este proyecto vamos a controlar los anodos de una
 matriz led bicolor con dos desplazamientos de registros,
 y las filas de la matriz con arduino directamente,
 reproduciendo asi una serie de caracteres previamente definidos.

 Todos los detalles en http://www.arduteka.com

 Este proyecto es de dominio público.
 */

int pinLatch = 10;    //Pin para el latch de los 74CH495
int pinDatos = 11;    //Pin para Datos serie del 74CH495
int pinReloj = 12;    //Pin para reloj del 74CH495

int letra = 0;         //Variable para cada letra
int ciclo = 0;         //Variable para los ciclos de cada letra en cada posicion
int desplaza = 0;      //Variable para generar desplazamiento en las filas

//Definimos los numeros decimales que hacen falta para dibujar cada caracter

#define SP {0, 0, 0, 0, 0}               //Espacio
#define EX {0, 125, 0, 0, 0}             //Exclamacion !
#define A {31, 36, 68, 36, 31}
#define B {127, 73, 73, 73, 54,}
#define C {62, 65, 65, 65, 34}
#define D {127, 65, 65, 34, 28}
#define E {127, 73, 73, 65, 65}
#define F {127, 72, 72, 72, 64}
#define G {62, 65, 65, 69, 38}
#define H {127, 8, 8, 8, 127}
#define I {0, 65, 127, 65, 0}
#define J {2, 1, 1, 1, 126}
#define K {127, 8, 20, 34, 65}
#define L {127, 1, 1, 1, 1}
#define M {127, 32, 16, 32, 127}
#define N {127, 32, 16, 8, 127}
#define O {62, 65, 65, 65, 62}
#define P {127, 72, 72, 72, 48}
#define Q {62, 65, 69, 66, 61}
#define R {127, 72, 76, 74, 49}
#define S {50, 73, 73, 73, 38}
#define T {64, 64, 127, 64, 64}
#define U {126, 1, 1, 1, 126}
#define V {124, 2, 1, 2, 124}
#define W {126, 1, 6, 1, 126}
#define X {99, 20, 8, 20, 99}
#define Y {96, 16, 15, 16, 96}
#define Z {67, 69, 73, 81, 97}

//Escribimos la frase separando cada letra por comas
//En el primer numero lo adaptaremos la longitud de la frase (caracteres)
byte frase[32][6]={B,I,E,N,V,E,N,I,D,O,S,SP,A,SP,A,R,D,U,I,N,O,SP,A,C,A,D,E,M,Y,SP,SP,SP};

//Almacenamos los pines de las filas que van conectadas a los catodos
int gnd[13]={0,0,0,0,0,2,3,4,5,6,7,8,9};

//Configuramos la placa
void setup()

{
  //Ponemos del pin 2 al 12 como salidas
  for (int i=2;i<=12; i++)
    {
      pinMode(i, OUTPUT);
    }  

  //Ponemos a nivel alto todas las lineas de los catodos de la matriz
  for (int g=2; g<=9; g++)
    {
      digitalWrite(g, HIGH);
    }
}

void loop()
{

//Pequeño contador para que salga una letra de cada color
for (int count = 0 ; count <= 1; count ++)
  {
    if (count < 1 )
      {
        for (desplaza = 9; desplaza>=0; desplaza--)
          {
            for (ciclo=0; ciclo<=35; ciclo++)
              {
                imprimeRojo();
              }
          }
      }
    else {
        for (desplaza = 9; desplaza>=0; desplaza--)
          {
            for (ciclo=0; ciclo<=35; ciclo++)
              {
                imprimeVerde();
              }
          }
        }

  //Una vez ha mostrado una letra, sumamos uno para que salga la siguiente
  letra++;

  }

//Cuando ha llegado al final de la frase, lo pone a cero para que vuelva a salir
//Si cambiamos la longitud de la frase, este valor hay que cambiarlo
if(letra == 32)
  {
    letra = 0;
  }
}

//Funcion que imprime en color rojo
void imprimeRojo()
{
 //Un contador del tamaño de las letras (5 lineas de ancho)
 for (int z=0; z<=5; z++)
       {
          int fila = z + desplaza;                                  //Le decimos en que linea empieza a dibujar
          digitalWrite(gnd[fila], LOW);                             //La ponemos a cero
          digitalWrite(pinLatch, LOW);                              //Le decimos a los registros que empiecen a escuchar los datos
          shiftOut(pinDatos, pinReloj, MSBFIRST, 0);                //Le decimos que en el ultimo registro no encienda nada
          shiftOut(pinDatos, pinReloj, MSBFIRST, frase[letra][z]);  //Le decimos que imprima la línea z de la letra en el primer registro (rojo)
          digitalWrite(pinLatch, HIGH);                             //Guarda y graba las salidas en los registros al poner a 1 el latch
          digitalWrite(gnd[fila], HIGH);                            //Apagamos esa fila poniendola en alto
        }
}

//Funcion que imprime en color verde
void imprimeVerde()
{
 //Un contador del tamaño de las letras (5 lineas de ancho)
 for (int z=0; z<=5; z++)
       {
          int fila = z + desplaza;                                  //Le decimos en que linea empieza a dibujar
          digitalWrite(gnd[fila], LOW);                          //La ponemos a cero
          digitalWrite(pinLatch, LOW);                     //Le decimos a los registros que empiecen a escuchar los datos
          shiftOut(pinDatos, pinReloj, MSBFIRST, frase[letra][z]);  //Le decimos que imprima la linea z de la letra en el segundo registro (verde)
          shiftOut(pinDatos, pinReloj, MSBFIRST, 0);       //Le decimos que en el primer registro no encienda nada
          digitalWrite(pinLatch, HIGH);                    //Guarda y graba las salidas en los registros al poner a 1 el latch
          digitalWrite(gnd[fila], HIGH);                         //Apagamos esa fila poniendola en alto
        }
}

En primer lugar hemos definido unas variables para los desplazamientos de registros, como veréis, aunque pongamos dos chip, seguimos usando tan solo dos patillas de Arduino!
Y luego unas pocas más para utilizar un poco más adelante en el programa.

int pinLatch = 10; //Pin para el latch de los 74CH495
int pinDatos = 11; //Pin para Datos serie del 74CH495
int pinReloj = 12; //Pin para reloj del 74CH495

int letra = 0; //Variable para cada letra
int ciclo = 0; //Variable para los ciclos de cada letra en cada posicion
int desplaza = 0; //Variable para generar desplazamiento en las filas

En segundo lugar tenemos algo nuevo:

#define nombredeConstante valor

Esta instrucción nos permite dar un nombre a un valor constante antes de que se compile el programa, de manera que luego la podremos llamar simplemente nombrándola.

Veamos antes que nada lo que hemos definido:

#define SP {0, 0, 0, 0, 0}               //Espacio
#define EX {0, 125, 0, 0, 0}             //Exclamación !
#define A {31, 36, 68, 36, 31}
#define B {127, 73, 73, 73, 54,}
#define C {62, 65, 65, 65, 34}
#define D {127, 65, 65, 34, 28}
#define E {127, 73, 73, 65, 65}
#define F {127, 72, 72, 72, 64}
#define G {62, 65, 65, 69, 38}
#define H {127, 8, 8, 8, 127}
#define I {0, 65, 127, 65, 0}
#define J {2, 1, 1, 1, 126}
#define K {127, 8, 20, 34, 65}
#define L {127, 1, 1, 1, 1}
#define M {127, 32, 16, 32, 127}
#define N {127, 32, 16, 8, 127}
#define O {62, 65, 65, 65, 62}
#define P {127, 72, 72, 72, 48}
#define Q {62, 65, 69, 66, 61}
#define R {127, 72, 76, 74, 49}
#define S {50, 73, 73, 73, 38}
#define T {64, 64, 127, 64, 64}
#define U {126, 1, 1, 1, 126}
#define V {124, 2, 1, 2, 124}
#define W {126, 1, 6, 1, 126}
#define X {99, 20, 8, 20, 99}
#define Y {96, 16, 15, 16, 96}
#define Z {67, 69, 73, 81, 97}

Lo que hemos hecho es definir cada letra del abecedario (menos la Ñ) por una serie de números decimales.

Estos números decimales son los que mandaremos a nuestros registros de desplazamiento para decirle que columnas de diodos LED debe iluminar.

¿Cómo hace esto?

Pasando de decimal a binario, observemos la siguiente imagen para entenderlo un poco mejor:

"matrix led" "decimal a binario" Arduino

Debemos imaginar que el primer diodo LED vale 1 (2^0), el segundo 2(2^1), el tercero 4 (2^2) y así sucesivamente, de manera que los que necesitemos tener encendidos, deberemos sumarlos entre sí.

En el ejemplo de arriba nos encendería el cuarto y el octavo diodo empezando por la izquierda.

Ahora, para dibujar una letra o símbolo, tan sólo hace falta tiempo y paciencia!

Por ejemplo, nuestras letras son de 7 columnas x 5 filas, de manera que la letra O por ejemplo sería:

#define O {62, 65, 65, 65, 62}

Que al pasarlo a binario nos quedaría así:

62 =>0 1 1 1 1 1 0
65 =>1 0 0 0 0 0 1
65 =>1 0 0 0 0 0 1
65 =>1 0 0 0 0 0 1
62 =>0 1 1 1 1 1 0

Y donde tenemos un 1, tenemos un diodo LED encendido!

Si seguimos con el programa, tenemos el lugar donde introduciremos un par de Arrays (listas) en las que almacenaremos las letras definidas que formarán nuestra frase y otra para los pines que tendremos conectados los cátodos de nuestra matriz.

//Escribimos la frase separando cada letra por comas
//En el primer numero lo adaptaremos la longitud de la frase (caracteres)
byte frase[32][6]={B,I,E,N,V,E,N,I,D,O,S,SP,A,SP,A,R,D,U,I,N,O,SP,A,C,A,D,E,M,Y,SP,SP,SP};

//Almacenamos los pines de las filas que van conectadas a los catodos
int gnd[13]={0,0,0,0,2,3,4,5,6,7,8,9};

Podéis ver que hemos colocado unos cuantos ceros al principio de la matriz de los cátodos, ya que es un pin que para este proyecto está libre, o usamos para crear una separación entre letras y que estas aparezcan por  el lateral derecho.

Aquí es donde espero la colaboración de algún programador experto que pula este programa XD

En cuanto a las matrices lo que debemos saber es que son una lista, matriz o array, como las queramos llamar, y símplemente es una colección de variables a las que se accede mediante un número de índice. Cualquier valor puede ser recogido haciendo uso del nombre de la matriz y el número del índice.

Debemos tener en cuenta que el índice siempre comienza en el 0, de manera que si tenemos un array de 10 elementos, accederemos a ellos del 0 al 9.

La forma de declarar un array es la siguiente:

int miArray[] = {valor0, valor1, valor2...}

Del mismo modo es posible declarar una matriz indicando el tipo de datos y el tamaño, para posteriormente, asignar valores a una posición especifica:

int lista[4]; // declara un array de enteros de 5 posiciones

lista[4] = 12; // asigna el valor 12 a la posición 5

Como decíamos arriba, para leer de un array basta con escribir el nombre y la posición a leer:

x = lista[4]; // x ahora es igual a 12 que está en la posición 5

Ahora tenemos la configuración de pines de nuestra placa:

//Configuramos la placa
void setup()

{
  //Ponemos del pin 2 al 12 como salidas
  for (int i=2;i<=12; i++)
    {
      pinMode(i, OUTPUT);
    }  

  //Ponemos a nivel alto todas las lineas de los catodos de la matriz
  for (int g=2; g<=9; g++)
    {
      digitalWrite(g, HIGH);
    }
}

El primer ciclo es para poner del pin 2 al 12 como salida, pues usaremos del 2 al 9 para los cátodos, y del 10 al 12 para los registros.

El segundo lo que hace es ponernos los cátodos a 5v para tener todos los diodos LED apagados.

Si seguimos el programa llegamos al loop, primero tenemos un contador de 0 a 1 para que alterne la llamada a la función imprimir en verde o imprimir en rojo, y como veis dentro de cada opción del la comparación tenemos un ciclo for llamado “desplaza”, que no  es más que un contador de 8 a 0 que se le irá sumando a las funciones de imprimir para desplazar la fila de cátodos por la que empieza a dibujar la letra, es algo simplón, pero funciona!

De nuevo, dentro de el contador “desplaza” tenemos un nuevo contador llamado “ciclo” que lo utilizamos para repetir la llamada a la función imprimir(verde o rojo) tantas veces como queramos, de manera que controlamos la velocidad con la se desplazan las letras.

void loop()
{

//Pequeño contador para que salga una letra de cada color
for (int count = 0 ; count <= 1; count ++)
  {
    if (count < 1 )
      {
        for (desplaza = 8; desplaza>=0; desplaza--)
          {
            for (ciclo=0; ciclo<=35; ciclo++)
              {
                imprimeRojo();
              }
          }
      }
    else {
        for (desplaza = 8; desplaza>=0; desplaza--)
          {
            for (ciclo=0; ciclo<=35; ciclo++)
              {
                imprimeVerde();
              }
          }
        }

  //Una vez ha mostrado una letra, sumamos uno para que salga la siguiente
  letra++;

  }

//Cuando ha llegado al final de la frase, lo pone a cero para que vuelva a salir
//Si cambiamos la longitud de la frase, este valor hay que cambiarlo
if(letra == 32)
  {
    letra = 0;
  }
}

Después de los contadores, sumamos 1 a la variable letra para que imprima la siguiente letra de la lista, y a continuación un pequeño chequeo para saber si ha llegado a la última letra de la frase, y si es así, que lo vuelva a poner a 0.

Ahora llega la miga del programa, mandemos los datos al desplazamiento de registro!!

void imprimeRojo()
{

 //Un contador del tamaño de las letras (5 lineas de ancho)
 for (int z=0; z<=5; z++)
       {
          int fila = z + desplaza;                        //Le decimos en que linea empieza a dibujar
          digitalWrite(gnd[fila], LOW);                   //La ponemos a cero
          digitalWrite(pinLatch, LOW);                    //Le decimos a los registros que empiecen a escuchar los datos
          shiftOut(pinDatos, pinReloj, MSBFIRST, 0);      //Le decimos que en el ultimo registro no encienda nada
          shiftOut(pinDatos, pinReloj, MSBFIRST, frase[letra][z]);   //Le decimos que imprima la linea z de la letra en el primer registro (rojo)
          digitalWrite(pinLatch, HIGH);                   //Guarda y graba las salidas en los registros al poner a 1 el latch
          digitalWrite(gnd[fila], HIGH);                  //Apagamos esa fila poniendola en alto
        }
}

Esta función es la que nos sincroniza los cátodos de las filas con la palabra que enviamos a los registros de desplazamiento.

Como vemos, empezamos con un contador de 0 a 5, esto nos servirá para decirle que linea de la letra es la que queremos imprimir, si recordamos el ejemplo de la letra 0, veremos que está compuesta por cinco lineas que deben ser impresas en las columnas de la matriz.

Luego seguimos con la sincronización de los cátodos con estas instrucciones:

int fila = z + desplaza;             //Le decimos en que linea empieza a dibujar
digitalWrite(gnd[fila], LOW);        //La ponemos a cero

La primera suma z + desplaza, esto nos va a devolver lo siguiente:

  1. 1 + 8 = 9
  2. 2 + 8 = 10
  3. 3 + 8 = 11
  4. 4 + 8 = 12
  5. 5 + 8 = 13
  6. 1 + 7 =  8
  7. 2 + 7 = 9
  8. 3 + 7 = 10
  9. 4 + 7 = 11
  10. 5 + 7 = 12
  11. 1 + 6 = 7
  12. 2 + 6 = 8
  13. 3 + 6 = 9
  14. ……

Con este valor variable aplicado a al pin que queremos poner en nivel LOW le estamos diciendo que cada vez empiece a imprimirnos una línea antes, de manera que primero hará un barrido con los pines almacenados de la posición 9 a la 13 de nuestro array, luego de la 8 a la 12, y así sucesivamente hasta que desaparece por la izquierda la letra, gracias a usar el pin 0 como “ayuda” para esconder las letra.. Repito.. programadores!! darle vuelta de tuerca a esto por favor!! XD.

A continuación ponemos el pin Latch de los registros de desplazamiento a “0″ para que empiecen a “escuchar” los datos que vamos a mandar.

digitalWrite(pinLatch, LOW);     //Le decimos a los registros que empiecen a escuchar los datos

Y le enviamos los datos a los dos registros de desplazamiento, recordando siempre, que el primer dato que enviamos, va al último registro de desplazamiento que tengamos conectado.

shiftOut(pinDatos, pinReloj, MSBFIRST, 0);        //Le decimos que en el ultimo registro no encienda nada
shiftOut(pinDatos, pinReloj, MSBFIRST, frase[letra][z]);   //Le decimos que imprima la linea z de la letra en el primer registro (rojo)

Arduino puede escribir en los registros de desplazamiento sin la necesidad de una librería, pues ya viene integrada esa instrucción, y además es muy fácil de usar, la sintaxis a utilizar es:

shiftOut(pinDatos, pinReloj, ordenBits, valor)

Donde:

  • pinDatos: el pin en el cual extraer cada bit (int)
  • pinReloj: el pin que hay que conmutar cada vez que a un pinDatos le ha sido enviado el valor correcto (int)
  • ordenBits: en qué orden desplazar los bits; si hacia el MSBFIRST (bit más significante primero) o hacia el LSBFIRST (bit menos significante primero).
  • valor: los datos que rotar. (byte)

Por último, le decimos a los registros que dejen de escuchar, e interpreten los datos enviados de una vez, y rápidamente colocamos  el pin del cátodo de la línea que hemos iluminado a 1 para apagarla, ya que hay que empezar de nuevo pero con la línea siguiente!! Y todo esto.. muy muy muy rápido… hace un scroll!!

Lo mismo es para la función imprimeVerde() solo que cambiamos el orden de los datos para que alterne los registros de desplazamiento.

Espero que os haya servido de utilizada este tutorial, yo os dejo un principio de programa para que empecéis a jugar.. pero quiero que desarrolléis más y mejor este tutorial!!

Para ello vamos a seguir la continuación de este proyecto, entre todos, en este hilo del foro!!

Un saludo a td@s!

Hasta pronto!!

Pablo Murillo. Técnico electrónico apasionado por la tecnología y el mundo de la impresión 3D. Comprometido en difundir el movimiento maker en cualquiera de sus vertientes. Fundador de Arduteka.com Colaborador en Arduino.cc
  1. Jorge Responder

    Gracias por el tutorial :), al principio se encendían todos los leds en oleadas, pero desconecté el condensador y funciona a la perfección.
    Ahora estoy intentando adaptar el código para que maneje los cátodos con un 74CH595 y transistores como aquí muestran http://tronixstuff.wordpress.com/2010/06/06/getting-started-with-arduino-chapter-nine/
    ¿habrá una manera mas simple?

  2. FranSolano Responder

    Impresionante proyecto, muy bien explicado y muy facil de entender. Ha sido un gran descubrimiento encontrarte. A la espera de mas tutoriales quedo que soy un noob… XD

    Por cierto: ¿Has visto este documental? http://www.fransolano.com/que-es-arduino/

  3. Jorge Responder

    Saludos, aqui esta el enlace a una aplicación que hice para sacar el código de nuevas letras o imágenes en la matriz de 5 x 7 , ojala a alguien le sirva!

  4. ruben Responder

    hola gracias por todos sus proyectos me han servido de muchisimo no tienes idea pero me surgio una duda como le puedo hacer para cincronizar dos matrices de leds espero y me puedas ayudar gracias

  5. Mauricio Guillen Responder

    Buen aporte.
    bro. tengo una pregunta es k yo tengo un problema
    yo kiero hacer una de 8*24 y pues el codigo cambia
    nose si podeis ayudarme…
    telo agradecere mucho.
    saludoss.

    • Arduteka Responder

      Hola!

      Te recomiendo que plantees tu duda en el foro de Arduino, allí estoy de moderador, la comunidad seguro te echa una mano.

      http://arduino.cc/forum/

      Comenta que quieres modificar este código para tu uso.

      Un saludo!

  6. Oscar Arrieta Responder

    Felicidades al Staff de arduino academy hacen un muy buen trabajo, todo perfecto me gusta mucho sigan asì.

    Saludos desde colombia

  7. Mauricio Guillen Responder

    no podrias subir mas imagenes de este proyecto
    para saver como esta hecha la instalacion

    • Arduteka Responder

      A que te refieres??

      Tienes el esquema eléctrico y un esquema visual en fritzing!!

      Dime que es lo que necesitas, y plantéalo en el hilo oficial del proyecto AQUI

      Un saludo!!

  8. Rodrigo Sandoval Responder

    hola!
    quisiera saber el codigo solo para desplegar mensajes en la matriz, sin los registros de desplazamiento, como se muestra al principio del video.

    Y que si me pudieran indicar cuales integrados son equivalentes al 74hc595?

    • Arduteka Responder

      Hola!

      Si te parece, plantea tus dudas en el hilo oficial del foro AQUI

      Pero tendrás que plantear tu duda con un boceto del código intentado por ti!! :)

      En el ejemplo se ve como estructurar un programa con o sin registros.. inténtalo y muéstranos que has conseguido!! Si la comunidad ve que lo has intentado, seguro que te ayudará!!

      En cuanto a las equivalencias, te remito al mismo lugar, así de cabeza no recuerdo ninguno.

      Un saludo!

  9. Jovani Ortega Responder

    Hola ! me gusto mucho el tutorial, sigue asi, para los estudiantes y principiantes es de gran ayuda!; solo hay un pequeño detalle en la conexion de el cable DATOS pero todo lo demas muy bien!

  10. Pingback: Comparativa - El diodo LED » Arduteka

  11. Charly Responder

    Hola, ¿cómo le podría hacer para adaptar este código para una matriz RGB como la que muestran en el vídeo?

    Gracias.

    • Pablo Murillo Responder

      Pues deberías controlar una línea más para el otro color con otro desplazamiento de registro y algo más de hardware, no te puedo poner el código, es muy extenso. También puedes usar rainbowduino que te lo facilita todo mucho más.

      Un saludo.

  12. ElectroGT Responder

    pregunta, veo en el tutorial que utilizo matriz de catodo comun, que problema existiera si uso una de anodo común?

    gracias!

    • Pablo Murillo Responder

      Deberá invertir la lógica. Cátodo común, es que están unidos sus polos negativos, y ánodo común, sus positivos.

      Un saludo.

  13. Olly Responder

    Hello from the UK.
    I see that you have connected the Serial Outputs togther. Q7* to Q7* in your diagrams?
    I think it should be Q7* in the first IC, to the DS in the second?
    is this a mistake, or is there a reason for this?

    Great Tutorial!
    Olly

  14. Miguel Responder

    Hola
    Yo también tengo una matriz anodo común.Puedes por favor comentar a qué te refieres con “invertir la lógica”

    Saludos

    • Pablo Murillo Responder

      Que en lugar de activar el LED con una salida en nivel bajo, se deberá hacerlo con nivel alto, y viceversa.

  15. esau Responder

    buen aporte solo una pregunta como podria hacer para darle el efecto de en vez de que valla de derecha a izquierda valla de arriba hacia abajo gracias.

  16. LaloW Responder

    el circuito 74CH595 Donde lo puedo conseguir…. por fa!!!!

  17. Daniel Responder

    hola! realicé este proyecto un par de veces pero nunca me ha resultado pues solo se ve toda la matriz fuertemente iluminada y casi imperceptible se ve como se dezplaza el mensaje, y en su video se muestra que solo la letra se ilumina, al parecer lo contrario de lo que pasa conmigo que podria estar pasando? saludos!

  18. Rafa Responder

    Hola estoy pensando en realizar un proyecto de una matriz RGB de 16X32 controlada por arduino en la que cada mudulo este controlado por un circuito con registros de desplazamiento 74HC595 como el de este proyecto:

    http://www.instructables.com/file/FUGNP1XGBVJ2558

    Me gustaría saber si se podría realizar y como podría hacer la comunicación de cada módulo con el siguiente, si debería enviarles la señal desde varias salidas de arduino o podría ponerlos en serie.

    Tengo conociemientos de electronica pero hace tiempo que no lo uso y me gustaría volver a refrescarlos y aprender cosas nuevas con estos proyectos que me planteo.

    Muchas gracias de antemano y espero vuestra respuesta. Las 8 matrices LED RGB de 8×8 ya las he pedido a muy buen precio.

  19. obadaia Responder

    buenas, soy estudiante de ingenieria electronica, tengo un pequeño problema con el codigo para este programa pero sin usar registro de desplazamiento, es decir como aparece en el video en el principio, me gustaria por favor que me ayudaran lo antes posible, si es posible me serviria ver el codigo sin el registro de desplazamiento con las salida para los anodos ya que soy muy noob y me encanta la programacion XD

Déjanos un comentario!

*

captcha *