Matriz 8x8 - Mensaje con Desplazamiento (Scroll)

Una de las aplicaciones mas comunes cuando uno utiliza una matriz de leds, es escribir caracteres o mostrar mensajes desplazándose por ella de forma tal que se pueda leer fácilmente un mensaje.

Como en post anteriores se mostró que la forma de que se pueda presentar una imagen estática en la matriz es mediante la técnica de multiplexado, es decir como en una matriz de 8x8 tenemos 64 puntos los cuales claramente no podemos acceder individualmente porque seria muy poco practico y extremadamente lleno de conexiones, la técnica para este es la de controlarlo de forma matricial con solo 16 pines, es decir 8 para las filas y 8 para las columnas, de esta forma si se activa una fila y una columna se encenderá el punto donde estas hacen intersección.
Ejemplo:
 
Como podemos ver en la imagen de arriba, al activar la columna E y la fila 4, logramos que la intersección entre estos encienda el punto de color azul, esta seria la forma en la que podemos encender un punto en una matriz.
Para que esto sea posible el multiplexado funciona de la siguiente forma:
Se activa la columna A, y se muestra el dato completo de las 8 filas. es decir Columna A, Filas (1,2,3,4,5,6,7,8), luego se repite lo mismo pero con la Columna B, y las 8 Filas nuevamente, y de esta forma hasta llegar ala columna H, entonces de esta forma se hace un recorrido de todas las columnas.
Ahora si el dato es siempre el mismo por ejemplo en el dibujo podemos ver que el único bit en 1 es el 4, y el resto están en cero, Filas(1,2,3,4,5,6,7,8) lo que seria en el dibujo como (000100000), y en este caso si nosotros hacemos el proceso de arriba de ir barriendo las columnas y el dato de las filas es siempre el mismo lo que se vera es una linea en toda la fila
Podemos ver en camara lenta como seria con el mismo dato en las filas.
Ahora en la realidad si nosotros realizamos este desarrollo tendremos que hacer que el barrido entre columnas sea lo suficientemente rápido como para que el ojo humano no perciba el multiplexado, lo cual como vemos en la imagen, el 4017 tendrá que conmutar mas rápido las columnas.
Bueno aquí aumente la frecuencia a 100Hz para que se pueda ver en velocidad, por un tema del gif animado no se puede apreciar el efecto, pero al generar un barrido de columnas de 100Hz la fila 4 queda encendida totalmente. Esto como mencionaba antes se debe a que el dato en las filas es siempre el mismo, como pueden ver en los seteos de estado de arriba de la imagen siempre mantiene el mismo encendido.
Pero en la realidad cuando requiere realizar un dibujo o una letra, tiene que variar estos datos de las filas, (las columnas siempre realizan el mismo trabajo de conmutación) pero en este nuevo concepto las columnas tienen que variar. La forma de esta variación sera en función de lo que se desee mostrar. 
Si uno quiere mostrar un circulo dibujado, tendrá que mostrar en cada columna el dato que corresponda, es decir observen la siguiente tabla de valores binarios:

COLUMNAS  
00011000  
00100100 F
01000010 I
10000001 L
10000001 A
01000010 S
00100100  
00011000  

Bueno analizando esta tabla, lo que tendríamos que haces es que para la columna A, el dato a mostrar en las filas sera 00011000, en la columna B, el dato sera 00100100, en la columna C, sera 01000010, luego seguirá como se muestra en la tabla. 
Nuevamente de forma lenta para comprender como se recorre la tabla:
Ahora al igual que antes vamos a verlo con una frecuencia de 100Hz pero gracias al gif otra vez se va a ver medio cortado. pero imaginen que lo hace rapido como se debe, conformando así el pseudo circulo sin que se pueda percibir por el ojo humano esta conmutación de columnas.
 
Bueno ahora la idea de hacer esto con un microcontrolador que pueden verlo en otro post en este blog [http://electgpl.blogspot.com.ar/2012/05/adaptador-de-matriz-de-5-x-7-puntos.html] aquí se muestra todo lo mencionado hasta ahora. 
En este otro post se puede ver como mediante una secuencia de tablas, es posible ir cambiando cada imagen estática [http://electgpl.blogspot.com.ar/2012/05/control-de-matriz-estatica.html]

Ahora el motivo de este nuevo post es el de crear una matriz dinámica, es decir que el texto que contenga no se muestre letra por letra de forma estática sino de forma dinámica como un desplazamiento o como se le dice en el resto del mundo Scroll.
A pesar de que la forma de generar un muestreo, conmutación o multiplexado de columnas se suele realizar mediante el uso de Timers en el microcontrolador, en este ejemplo lo haré de la forma mas sencilla sin ningún timer, simplemente con lazos for.
El uso de Timers se requiere para que de forma independiente se pueda generar el barrido de las columnas o el muestro (cantidad de frames) de la imagen a mostrar en la matriz, sea de forma independiente al resto del programa, esto es porque el muestreo de columnas suele ser mucho mas rápido que el desplazamiento del texto en la matriz, entonces se soluciona muy sencillo con el uso de los timers, pero en mi caso intento hacer lo mas sencillo posible este post para que sea muy fácil de entender.

Para esto veremos el programa y luego lo explicare.

#include <16F883.h>
#use delay(int=4000000)
#define LARGO 28                      //Longitud de la tabla
int const tabla[LARGO+8]={
                          0b00000000, //Espacio
                          0b00000000, //Espacio
                          0b00000000, //Espacio
                          0b00000000, //Espacio
                          0b00000000, //Espacio
                          0b00000000, //Espacio
                          0b00000000, //Espacio
                          0b00000000, //Espacio 
                          0b11111111, //Dato de tabla H
                          0b00001000,
                          0b00001000,
                          0b11111111,
                          0b00000000, //Espacio
                          0b01111110, //Dato de tabla O
                          0b10000001,
                          0b10000001,
                          0b01111110,
                          0b00000000, //Espacio
                          0b11111111, //Dato de tabla L
                          0b00000001,
                          0b00000001,
                          0b00000000, //Espacio
                          0b01111111, //Dato de tabla A
                          0b10001000,
                          0b10001000,
                          0b01111111,
                          0b00000000, //Espacio
                          0b00000000, //Espacio
                          };
void main(){
   byte const bitMask[8]={1,2,4,8,16,32,64,128}; //Mascara
   int i,j,k;                         //Variables contadores
   while(TRUE){                       //Ciclo infinito
      for(i=0;i<LARGO+8;i++){         //Recorrido de tabla
         for(k=0;k<20;k++){           //Refresco de matriz
            for(j=0;j<8;j++){         //Barrido de columnas
               output_a(~bitMask[j]); //Columnas ponderadas
               output_b(tabla[j+i]);  //Desplazamiento de tabla
               delay_ms(1);           //Demora de multiplexado
            }  
         }
      }
   }  
}   

Bueno aqui podemos ver principalmente la tabla con los caracteres realizados en funcion a las filas que forma la palabra HOLA, ahora lo mas importante que son los for anidados.
Notemos desde el for que se encuentra mas profundo hacia al for que se encuentra en la superficie.
El for(j=0;j<8;j++)cumple la función de recorrer las columnas que se encuentran en el puerto A, por eso encontramos la sentencia output_a(~bitMask[j]), donde bitMask[j] es el vector definido mas arriba que contiene los valores {1,2,4,8,16,32,64,128}, esto hace referencia a 00000001, 00000010, 00000100, 00001000, 00010000, 00100000, 01000000, 10000000. De esta forma activamos cada columna una a una. Luego como podemos ver tenemos la salida del puerto B la cual posee el vector de la tabla donde su indice dice j+i, bueno esto es clave para que la matriz desplace la palabra dentro de ella. 
Ahora el for(i=0;i<LARGO+8;i++)lo que hace es recorrer la tabla, como pueden ver el valor constante LARGO que se carga en la parte de arriba del programa es la longitud de la tabla, es decir el largo del vector, pero se le suma 8, esto es porque la matriz posee 8 columnas las cuales debe mostrar apagadas al finalizar dicho mensaje para que no se solape cuando se repita.
Volviendo a lo mencionado anterior que era clave el j+i lo que hace es que cada vez que se refrescan las columnas, se recorre toda la tabla, pero por cada refresco, la tabla se recorre desde un inicio distinto, es decir, para crear el movimiento de la matriz, lo que se hace es mostrar el contenido de la tabla desde su primer byte hacia el ultimo, pero cada vez que se genera un muestreo en lugar de comenzar del primero se comienza del segundo, luego del tercero, y por eso el j+i, lo que nos genera la ilusion óptica del movimiento. Ahora se mostrara en el siguiente gif animado, a velocidad lenta para la comprensión y a velocidad normal para ver el resultado obtenido.
Por ultimo el for(k=0;k<20;k++) lo que hace es la cantidad de frames, es decir la cantidad de veces que refresca la pantalla por cada barrido de columnas, lo que quiere decir es que realizara 20 barridos de matriz completa por cada movimiento del desplazamiento de la palabra en la matriz.
Tener en cuenta que el gif animado no se muestra en tiempo real, pero servirá para tener en cuenta el funcionamiento.
Esta sera la versión final a velocidad aceptable para leer y sin parpadeos.


 





101 comentarios:

  1. Hola buen dia...
    Una vez que la haces en fisico debe llevar 16 resistencia (1 cada pata)?
    Gracias...

    ResponderEliminar
    Respuestas
    1. Hola, con que pongas solo 8 resistencias en un solo puerto ya esta, ya que al estar en serie esa resistencia aplica para ambos puertos simultaneamente. podes probar con 470 Ohms.
      Saludos.

      Eliminar
  2. La mtariz en fisico se conecta directo al pic o se le ponen transistores?

    ResponderEliminar
    Respuestas
    1. Hola, solamente 8 resistencias en uno de los puertos, no hace faltan los transistores.
      Saludos.

      Eliminar
  3. Respuestas
    1. Hola, a que te referís con como se programa?, el código fuente o como se carga el código fuente en el microcontrolador?.
      El código fuente esta posteado, tenes que abrirlo con algún IDE que contenga el compilador CCS y luego compilarlo, te va a generar un archivo .hex.
      Despues necesitas de una placa programadora para el microcontrolador, que mediante un programa en la pc vas a buscar ese archivo .hex generado anteriormente y lo vas a transferir al microcontrolador.
      Luego de eso ya estaría el firmware en la memoria del microcontrolador listo para utilizarlo.
      Saludos.

      Eliminar
  4. Buenas noches, y si queremos unir varias matrices de leds?

    ResponderEliminar
    Respuestas
    1. Hola, como estas?, con este integrado sin ninguna otra cosa externa podrías poner hasta 2 matrices (que es lo que permiten los pinout), pero si queres mas cantidad de matrices tenes que usar alguna expansion del puerto, por ejemplo un conversor serial/paralelo por ejemplo el 74164, hay que modificar el código, voy a ver si puedo realizar este proyecto con mas matrices para hacer una marquesina. También vendría bien hacer una librería extra (o una función) donde se agreguen las letras del abecedario como para que sea mas amigable la forma de crear mensajes.
      Pero es un post pendiente.
      Saludos.

      Eliminar
  5. Saludos, si quisiera agregar más letras para formar un nombre solo tendria que agregar más tablas al programa como las del HOLA? o tendria que modificar aún más el programa?

    ResponderEliminar
    Respuestas
    1. Buen día, si queres que la palabra sea otra, tenes que agregar mas caracteres al vector donde esta la palabra HOLA, por ejemplo:
      #define LARGO 51 //Longitud de la tabla
      int const tabla[LARGO+8]={
      0b00000000, //Espacio
      0b00000000, //Espacio
      0b00000000, //Espacio
      0b00000000, //Espacio
      0b00000000, //Espacio
      0b00000000, //Espacio
      0b00000000, //Espacio
      0b00000000, //Espacio
      0b11111111, //Dato de tabla H
      0b00001000,
      0b00001000,
      0b11111111,
      0b00000000, //Espacio
      0b01111110, //Dato de tabla O
      0b10000001,
      0b10000001,
      0b01111110,
      0b00000000, //Espacio
      0b11111111, //Dato de tabla L
      0b00000001,
      0b00000001,
      0b00000000, //Espacio
      0b01111111, //Dato de tabla A
      0b10001000,
      0b10001000,
      0b01111111,
      0b00000000, //Espacio
      0b00000000, //Espacio
      0b00000000, //Espacio
      0b00000000, //Espacio
      0b11111111, //Dato de tabla P
      0b10001000,
      0b10001000,
      0b01110000,
      0b00000000, //Espacio
      0b11111111, //Dato de tabla E
      0b10001001,
      0b10001001,
      0b10000001,
      0b00000000, //Espacio
      0b11111111, //Dato de tabla P
      0b10001000,
      0b10001000,
      0b01110000,
      0b00000000, //Espacio
      0b11111111, //Dato de tabla E
      0b10001001,
      0b10001001,
      0b10000001,
      0b00000000, //Espacio
      0b00000000, //Espacio
      };

      Fíjate que ahí agregue PEPE, quedando así HOLA PEPE, y el vector ya no tiene 28 posiciones sino 51, entonces también tenes que cambiar el numero 28 por 51 en la linea anterior a la definición del vector "#define LARGO 51 //Longitud de la tabla"
      Solo eso.
      Saludos!

      Eliminar
    2. Perdón calcule mal, es #define LARGO 43, en lugar de 51 ya que el vector es tabla[LARGO+8] suma LARGO + 8, siendo 43 + 8 = 51.
      Saludos!

      Eliminar
    3. Gracias por su pronta respuesta, si no le molesta quisiera saber que programa puedo utilizar para poder modificar el código y poder generar el archivo .HEX pues he intentado con pic basic y no he tenido buenos resultados.

      Eliminar
    4. Hola, por nada, el lenguaje de programación que esta usando ese programa es C, y el compilador es CCS, deberia bajar un IDE para tal compilador, podría recomendarle el PCW

      http://www.ccsinfo.com/cgi-bin/update.cgi?rnum=P11111111&RadioButton=demo&customer=ieeesb-uniovi&customer=example@example.com&demo=Download+Demo

      Ahí deje una versión Demo pero sirve para compilar este código y otros.
      Saludos.

      Eliminar
  6. Hola! ... Antes que nada quería decir que esta muy bueno este Blog, los proyectos y la forma en la que se los explica, algunos me han sido de gran ayuda. Ahora bien, use este código y una rutina que saque de otro lado para manejar un CD4094 y asi solo usar un puerto y solo 3 pines del otro, el pic que uso es un 16F628A, el programa funciona ,por lo que se ve en el simulador, bien hasta cierto punto que ya deja de funcionar. Adjunto el Codigo, si por favor, podes mirarlo:
    #define LARGO 28 //Longitud de la tabla
    #define DATA pin_a0
    #define CLOCK pin_a1
    #define STROBE pin_a2
    void escribir_4094(int caracter);
    int b;
    byte const bitMask[8]={128,64,32,16,8,4,2,1}; //Mascara
    int const tabla[LARGO]={
    0b11111111, //Espacio
    0b11111111, //Espacio
    0b11111111, //Espacio
    0b11111111, //Espacio
    0b11111111, //Espacio
    0b11111111, //Espacio
    0b11111111, //Espacio
    0b11111111, //Espacio
    0b00000000, //Dato de tabla H
    0b11110111,
    0b11110111,
    0b00000000,
    0b11111111, //Espacio
    0b10000001, //Dato de tabla O
    0b01111110,
    0b01111110,
    0b10000001,
    0b11111111, //Espacio
    0b00000000, //Dato de tabla L
    0b11111110,
    0b11111110,
    0b11111111, //Espacio
    0b10000000, //Dato de tabla A
    0b01110111,
    0b01110111,
    0b10000000,
    0b11111111, //Espacio
    0b11111111, //Espacio
    };
    void main(){
    int i,j,k; //Variables contadores
    while(TRUE){ //Ciclo infinito
    for(i=0;i<LARGO;i++){ //Recorrido de tabla
    for(k=0;k<20;k++){ //Refresco de matriz
    for(j=0;j<8;j++){ //Barrido de columnas
    escribir_4094(j); //Columnas ponderadas
    output_b(tabla[j+i]); //Desplazamiento de tabla
    delay_ms(1); //Demora de multiplexado
    }
    }
    }
    }
    }


    void escribir_4094(int caracter){ //Subrutina que carga los Datos en el CD4094
    int contador_8;
    output_low(DATA);
    output_low(STROBE);
    output_low(CLOCK);
    for(contador_8=0;contador_8<8;contador_8++){
    output_bit(DATA,bit_test(bitMask[caracter],contador_8));
    output_high(CLOCK);
    delay_cycles(1);
    output_low(CLOCK);

    }
    output_high(STROBE);
    delay_cycles(1);
    output_low(STROBE);
    b=b+1;
    }

    ResponderEliminar
    Respuestas
    1. Hola Gracias!, nunca use el 4094, hice un firmware como el tuyo pero para el registro 74164, lo que veo que te falta (para que no se te quede trabada la matriz) es cuando definis el vector tabla[LARGO]=... tenes que agregarle table[LARGO+8]=... al agregarle el 8 lo que haces es sumarle 8 espacios sin datos que se usan para que la tabla termine de recorrer las 8 columnas y no encuentre un valor "blanco" al final del vector, ya que todos los vectores al final terminan con un caracter blanco que es el que te traba todo.
      Saludos!!!

      Eliminar
    2. como haria para que fuese mas extenso en filas
      me gustaria que lo hagas con el 74164
      no entiendo como lo hacen con registros

      Eliminar
    3. Hola, tengo pendiente realizar una matriz mas grande, pero en columnas, ya que el caracter estándar ASCII maneja 7 u 8 filas.
      Te comento que el 74164 es un registro de desplazamiento al igual que el 4094, 74595, etc...
      Saludos.

      Eliminar
    4. Hola, Buen dia.. Una preguntita... Podría ser posible ampliar esta matriz? Porque esta bastante facil el funcionamiento, sin embargo llevo un tiempo probando distintas cosas y no le encuentro la vuelta como quien dice jaja.. Ya con la corrección que me habias marcado funciona muy bien.
      Creo que el barrido es mejor por filas no? Seria desde el puerto b, y con registros manejar el desplazamiento? Agradezco tu tiempo!

      Eliminar
    5. Si, es uno de los post pendientes que tengo, pero por los exámenes no lo he abordado aun., la forma que se suele utilizar es barrido de columnas mediante algún registro de desplazamiento y las 8 filas directas del puerto del microcontrolador, es la forma mas sencilla también. Lo que quiero hacer es crear una librería de caracteres predefinidos, para luego ingresar un string cualquiera y que lo reproduzca, solo que esto va a demandar un microcontrolador mas potente y sobre todo con mayor memoria.
      Saludos.

      Eliminar
    6. A bien, voy a seguir intentando entonces. Por lo otro, parece mejor tener ya predefinida las letras e ir reproduciendolas como decis y claro que lleva mas memoria. Bueno, Gracias por tu tiempo..

      Eliminar
    7. A bien, voy a seguir intentando entonces. Por lo otro, parece mejor tener ya predefinida las letras e ir reproduciendolas como decis y claro que lleva mas memoria. Bueno, Gracias por tu tiempo..

      Eliminar
    8. La verdad no me gusta dejar colgado un post, pero estoy algo complicado mas que nada porque lleva ensayo y quiero subir un codigo eficiente y que funcione.
      Pero si tenes cualquier consulta sobre tu investigacion de este proyecto, consultame lo que quieras!
      Saludos.

      Eliminar
  7. Saludos, me parece muy bueno tu codigo, no se si alguien mas le pasó pero a mi me aparecio un "fantasma", aparecen letras cuando no deben de aparecer, para evitar eso lo unico que hice fue apagar el puerto b antes de repetir el proceso:

    while(TRUE){ //Ciclo infinito
    for(i=0;i<LARGO+8;i++){ //Recorrido de tabla
    for(k=0;k<20;k++){ //Refresco de matriz
    for(j=0;j<8;j++){ //Barrido de columnas
    output_a(~bitMask[j]); //Columnas ponderadas
    output_b(tabla[j+i]); //Desplazamiento de tabla
    delay_ms(1); //Demora de multiplexado
    output_b(0b00000000); //linea de código para limpiar el puerto b antes de repetir el proceso
    }
    }
    }
    }
    }

    ResponderEliminar
    Respuestas
    1. Buen Día, a mi no me ha pasado, esta buena tu modificación!
      Gracias!!!

      Eliminar
  8. Buenas... Luego de un rato de ensayo, de 8x8 pasa a ser de 8x16. Aunque el código me parece poco eficiente, y creo que es mejor hacer el barrido por Filas (la conexión de 16 Leds).Pic 16F648A con cristal de 10MHz. Dejo el código por si a alguien le interesa :
    #define LARGO 65//Longitud de la tabla
    #define DATA pin_a0
    #define CLOCK pin_a1
    #define STROBE pin_a2
    void escribir_4094(int16 caracter);
    signed int16 bitMask[16]={0b0111111111111111,
    0b1011111111111111,
    0b1101111111111111,
    0b1110111111111111,
    0b1111011111111111,
    0b1111101111111111,
    0b1111110111111111,
    0b1111111011111111,
    0b1111111101111111,
    0b1111111110111111,
    0b1111111111011111,
    0b1111111111101111,
    0b1111111111110111,
    0b1111111111111011,
    0b1111111111111101,
    0b1111111111111110};
    int const tabla[LARGO+16]={
    0b00000000, //Espacio
    0b00000000, //Espacio
    0b00000000, //Espacio
    0b00000000, //Espacio
    0b00000000, //Espacio
    0b00000000, //Espacio
    0b00000000, //Espacio
    0b00000000, //Espacio
    0b00000000, //Espacio
    0b00000000, //Espacio
    0b00000000, //Espacio
    0b00000000, //Espacio
    0b00000000, //Espacio
    0b00000000, //Espacio
    0b00000000, //Espacio
    0b00000000, //Espacio
    0b00000000, //Espacio
    0b00000000, //Espacio
    0b00000000, //Espacio
    0b00000000, //Espacio
    0b10000001, //Dato de tabla I
    0b10000001,
    0b11111111,
    0b10000001,
    0b10000001,
    0b00000000, //Espacio
    0b11111111, //Dato de tabla P
    0b00010001,
    0b00010001,
    0b00010001,
    0b00001110,
    0b00000000, //Espacio
    0b11111111, //Dato de tabla E
    0b10001001,
    0b10001001,
    0b10001001,
    0b10000001
    0b00000000, //Espacio
    0b00000001, //Dato de tabla T
    0b00000001,
    0b11111111,
    0b00000001,
    0b00000001,
    0b00000000, //Espacio
    0b00000000, //Espacio
    0b00000000, //Espacio
    0b11100001, //Dato de Tabla 2
    0b10010001,
    0b10010001,
    0b10010001,
    0b10001110,
    0b00000000, //Espacio
    0b10001111, //Dato de tabla 5
    0b10001001,
    0b10001001,
    0b10001001,
    0b01110001,
    0b00000000, //Espacio
    0b01111110, //Dato de Tabla 0
    0b10010001,
    0b10001001,
    0b10000101,
    0b01111110,
    0b00000000, //Espacio
    0b00000000, //Espacio
    0b00000000, //Espacio
    0b00000000, //Espacio
    0b00000000, //Espacio

    };
    void main(){
    set_tris_b (0x00);
    set_tris_a(0x00);
    int i,j,k; //Variables contadores
    while(TRUE){ //Ciclo infinito
    for(i=0;i<LARGO;i++){ //Recorrido de tabla
    for(k=0;k<30;k++){ //Refresco de matriz
    for(j=0;j<16;j++){//Barrido de Columnas
    escribir_4094(j); //Columnas ponderadas
    output_b(tabla[j+i]); //Desplazamiento de tabla
    delay_us(1); //Demora de multiplexado
    }
    }
    }
    }
    }


    void escribir_4094(int16 caracter){ //Subrutina que carga los Datos en el CD4094
    int contador_8;
    output_low(DATA);
    output_low(STROBE);
    output_low(CLOCK);
    for(contador_8=0;contador_8<16;contador_8++){
    output_bit(DATA,bit_test(bitMask[caracter],contador_8));
    output_high(CLOCK);
    delay_cycles(1);
    output_low(CLOCK);

    }
    output_high(STROBE);
    delay_cycles(1);
    output_low(STROBE);
    }

    Bueno Sebastian, de a poco va queriendo jaja.. Saludos..

    ResponderEliminar
    Respuestas
    1. Buenisimo che, me alegra que este funcionando bien!!!, aparte en estos programas es donde uno aprende y encuentra mejoras constantes, lo importante es hacerlo uno, pensar todo el programa por uno mismo hace que comprendas bien el funcionamiento y agilices la programacion.
      Mira te dejo una pagina que es para compartir codigo fuente (podes pegar tu fuente ahi y compartir el link o podes crearte una cuenta y guardar tus fuentes en un repositorio) yo particularmente uso google drive y demas... pero para compartir me gusta este sitio porque te resalta sintaxis y no hace falta que nadie este logeado a nada para verlo.
      http://pastebin.com/3Zb2i7q4
      Saludos!

      Eliminar
    2. Acá tengo otra versión que he realizado el día de ayer, espero que te sea de utilidad, se puede ampliar.
      http://electgpl.blogspot.com.ar/2015/12/matriz-8x32-scroll-ampliable.html
      Saludos!

      Eliminar
  9. Olá boa tarde amigo:
    estou começando a entender das coisas mais ainda apanho muito, será que vc teria condições de me passar alguma coisa deste tipo mais com 2 matrizes ou mais, gostei muito das suas explicações são 10, se sim agradeço
    Decio
    microinformatica@microinf.com.br
    SP-Brasil

    ResponderEliminar
    Respuestas
    1. Bom dia, só aqui em cima há uma contribuição de um leitor "Agustin Griotti" que implementou mais matrizes com base neste código, expandindo portas com integrado 4094. Talvez seja útil, eu tentei isso no simulador e ele tem dado bons resultados.

      Saudações!

      Eliminar
    2. http://electgpl.blogspot.com.ar/2015/12/matriz-8x32-scroll-ampliable.html

      Saludos!

      Eliminar
  10. hola, primero q nada muchas gracias el blog esta genial: pero tengo un problema con el dezplasamiento de los bits estos se ven en mi simulacion de abajo hacia arriba, es decir la palabra hola dezplaza de abajo a arriba no de derecha a izquierda, y ay he revisado varias veces tengo la misma conexion tuya. gracias

    ResponderEliminar
    Respuestas
    1. Hola eso mas que seguro sea por la matriz que estas usando en la simulación, proba volver a elegir la matriz pero antes de montarla en el diagrama rotala 180° para invertir los pines.Si ya lo tenes montado en el proteus, podes soltar la matriz arriba de la que tenes y listo, pero rotala 180° antes y volve a probar. Saludos!

      Eliminar
    2. hola, ya habia hecho eso profe en todaas las formas pero el mensaje sale de la misma forma, teniendo en cuenta q las conexiones son arriba y abajo probe normal y probe en 180º. para q se me vea el mensaje de derecha a izquierda me toca cojerla desde el inicio antes de montarla y jirarla 270º pero asi quedan los pines de conexion a los lados izquierdo y derecho y se me dificulta al momento de montar mas matrices con registros de dezplazamiento, q por cierto aun no logro hacer,te recomiendo si puedes hacer uno con mas paneles. gracias

      Eliminar
    3. Hola, te paso los archivos "Este es para la de 8x32" https://sites.google.com/site/electgpl/storage/Matrix%208x32%2074595.7z?attredirects=0&d=1
      "Este es para la de este post" https://sites.google.com/site/electgpl/storage/Matriz%20led.7z?attredirects=0&d=1
      Ahi tenes los archivos del Proteus para que corrobores el funcionamiento.
      Saludos!

      Eliminar
  11. Buen aporte, me pueden ayudar a entender mejor lo del void main, no entiendo la secuencia de los "FOR"
    Gracias

    ResponderEliminar
    Respuestas
    1. Hola, pudiste ver el vídeo de youtube?

      Saludos!

      Eliminar
    2. no he llegado a ver el video de youtube, me puedes dejar el link please.
      Gracias por tú pronta respuesta.
      Saludos.

      Eliminar
    3. Hola, es verdad parece que no esta saliendo en blogger. https://www.youtube.com/watch?v=bCpupQrUmcM
      Saludos!

      Eliminar
    4. Gracias. por tú respuesta y por tú aporte
      Saludos.!

      Eliminar
  12. Hola yo tengo una pregunta, he comprendido el codigo y hago una programación dde mas caracteres alrededor de unos 12, cuando lo programo me corre perfecto y se ve bien la matriz, ell problema es que al final del mensaje la matriz prende leds a lo tonto y/o aveces no regresa al programa desde el principio

    por que sucede esto?

    ResponderEliminar
    Respuestas
    1. Hola como estas?, cambiaste la longitud del vector? fíjate que dice LARGO 28 (suma los primeros 8 espacios en blanco mas los 20 útiles que escribís), en tu caso si son 12 útiles donde tenes información tenes que sumarle los 8 en blanco, por lo que tendrías que poner LARGO 20. Siempre dejando los primeros 8 en blanco como esta en el código. Con eso debería funcionar bien.
      Cualquier cosa avisa.
      Saludos!

      Eliminar
  13. hola, quiero saber como hacerlo en fisico el codigo ya lo tengo pero mi problema es que no puedo conectar mi matriz de 8x8 GMM-12088ASB ese es mi unico problema hasta ahora, el no saberla conectar

    ResponderEliminar
    Respuestas
    1. Si pudieras hacer un video de como hacerlo, o bueno una forma simple de responderme, trabajo con arduino mega tengo el codigo de programacion pero lo unico que no me sale es conectar la matriz de 8x8 GMM-12088ASB

      Eliminar
    2. Hola, ni bien me haga un tiempo te hago el vídeo para conectar la matriz!

      Saludos.

      Eliminar
  14. Hola muy buenos días Sebastian: De casualidad no puedes hacerme el favor y explicarme como seria el código o como hacerle después de hacer las tablas simplemete escribir el texto a mostrar? algo asi como Imprintf(H,O,L,A,P,E,P,E) cual seria el paso en medio del código? Muchas gracias de antemano, excelente Posteo!

    ResponderEliminar
    Respuestas
    1. Buen día, como estas?, creo que por algún lado tengo otro programa donde se escribía letra por letra como mencionas vos. Pero no tendría mucho sentido modificar este ya que es completamente diferente... Habría que crear un abecedario matricial para que cuando llamas a la letra el mismo devuelva los puntos de la matriz en cuestión, habría que crear un array de memoria dinámica para que termine al finalizar los caracteres y el núcleo central del programa hay que modificarlo, por eso te digo que no se si vale la pena modificar este código, tal vez seria conveniente un código nuevo. De todas formas lo voy a analizar mejor porque podría ser interesante.
      Saludos!

      Eliminar
  15. Hola Sebastian buenas noches.
    arme el proyecto y todo corre muy bien pero siento que el brillo de los leds esta al 60% como puedo incrementar el brillo de los leds a su maxima potencia de luminosidad

    ResponderEliminar
    Respuestas
    1. Buen día!, como estas?, es correcto los leds no están a su máximo brillo pero tene en cuenta que están siendo alimentados directamente desde el micro, lo ideal seria alimentar estos leds con un array externo de buffers o transistores, por ejemplo, ULN2803 + transistores o algo asi, de esa forma el microcontroaldor no se carga con el consumo de la matriz y podemos sacar mas brillo a los mismos.
      Saludos.

      Eliminar
  16. Hola buenas que tal, me gusto mucho el funcionamiento de esta matriz y gracias a tu excelente post logre comprender mucho más, mi pregunta es yo quiero hacer un proyecto así pero utilizando GAL22v10 necesito dos gal verdad, y podre hacer la función de Scroll con wincupl? serias tan amable de indicarme cual es la función ya que no encuentro dicha función en el lenguaje de wincupl estoy apenas iniciando en esto, te agradezco de antemano saludos cordiales. El pulso lo generaria en el pin 1 del gal que es el reloj y con un astable 555.

    ResponderEliminar
    Respuestas
    1. Buen día, como estas?, te comento que no tengo mucha practica con PLD o FPGA, ya que solo los he implementado de forma educativa en la universidad, aquí no se consigue muy fácil y los que consigo son demasiado costosos (mas que un MCU gama media o alta).
      Lamento no poder ayudarte con el GAL22.
      Saludos!

      Eliminar
    2. Pero, ahora que me lo mencionas, voy a ver si consigo alguno a buen precio, ya que me interesa probar algún desarrollo, ya que son mucho mas rápidos que los MCU. Voy a mandar un mail al local de electrónica que frecuento a ver si lo pueden traer y cuanto cuesta.
      Saludos!

      Eliminar
  17. Hola!!
    Una consulta, en donde debo compilar esto, para verlo funcionar ¿?

    ResponderEliminar
    Respuestas
    1. Hola, esta programado en C, se compila con CCS, podes descargar el PICC o PCWH.
      http://www.ccsinfo.com/ccsfreedemo.php

      Saludos!

      Eliminar
  18. bueno tengo un proyecto en mente ya tengo el código corriendo pero me gustaría agregar una animación sera que me podrías ayudar con un pequeño código para hacer animación
    MUCHAS GRACIAS fredyjf16@gmail.com

    ResponderEliminar
    Respuestas
    1. Hola, si decime que necesitas de la animación, ya viste que es super sencillo si la pensas cuadro por cuadro, fíjate este post! http://electgpl.blogspot.com.ar/2015/12/matriz-8x8-con-motivo-de-navidad.html
      Saludos!

      Eliminar
  19. Respuestas
    1. Si claro que se puede realizar en assembler, es un poco mas laborioso, necesitas una mano con eso?
      Saludos.

      Eliminar
  20. buenas en circuito echo se usa cristal para oscilacion??

    ResponderEliminar
    Respuestas
    1. Hola como estas?, usa oscilador interno, no requiere de componentes extra. Saludos!

      Eliminar
  21. buenas quisiera saber que quiere decir
    ( int const tabla[LARGO+8]={ )

    ResponderEliminar
    Respuestas
    1. Hola como estas, "tabla" es un array o vector que posee valores en su interior, en este caso del tipo entero y alojado de forma constante, por ello "int const" luego le sigue el nombre que le puse "tabla" pero puede ser cualquier cosa como por ejemplo "pepe" que daría lo mismo, luego entre corchetes se debe ingresar la longitud del vector o array, en este caso sera la cantidad de variables que tiene dentro. Las variables están dentro de las llaves {} y separadas por coma, fíjate que tiene 28 variables en su interior (en realidad constantes porque no varían), entonces podríamos definirlo como int const tabla[28]={...}, pero como la matriz es de 8 x 8, queremos que al inicio comience apagada, para ello las primeras 8 variables estarán apagadas, por ello le sumamos 8 mas, y quedaría 28+8, podríamos poner el valor directamente pero como podes agrandar la longitud del mensaje queda como variable y se pone tabla[LARGO+8]={...} donde "LARGO" esta definido arriba de este como el numero 28.
      Saludos!

      Eliminar
  22. Saludos estoy estudiando este código pero apenas estoy aprendiendo y me cuesta un poco entenderlo
    completamente por favor podrías explicarme mas a fondo los for esto es lo que tengo entendido
    hasta ahora corrígeme si me equivoco por favor

    el for(i=0;i<LARGO+8;i++) aumenta de 1 en 1 la variable i hasta 28 que es el largo del mensaje
    "HOLA" mas 8 espacios vacios porque la matriz tiene 8 columnas

    el for(j=0;j<8;j++) lo que hace es aumentar la variable j que esta ligada con output_a(~bitMask[j]) para recorrer un bit encendido en las columnas y con la instruccion output_b(tabla[j+i]) para "encagar" por así decirlo los datos de la tabla en las filas con el bit que se reccorre en las columnas para formar las letras
    lo que no entiendo es porque sumar j+i y en el for(k=0;k<20;k++) estoy totalmente perdido no entiendo cual es su funcion??
    Gracias

    ResponderEliminar
    Respuestas
    1. Hola como estas?, pudiste ver el vídeo de explicación de este post?
      https://www.youtube.com/watch?v=bCpupQrUmcM
      Es correcto el análisis, la variable i+j, lo que hace es el scroll o el movimiento de las letras de derecha a izquierda, ya que por cada frame, actualización o refresco, muestra la letra en cuestión corrida una columna a la izquierda, lo que da el efecto de que se desplaza y se genera el movimiento de las letras.
      Ese ultimo for lo que hace es refrescar la matriz, es decir, cuantas veces repite lo que ves por segundo, recorda que el ojo humano tiene un refresco de al rededor de 24 imágenes por segundo, por ello las películas antiguas (las de rollo) eran a 24 cuadros, de esa forma el ojo no se da cuenta de que esta cambiando y aparece encendida a la vista.
      Saludos!

      Eliminar
  23. Hola, que pena molestarte, pero trate de hacer la figura del circulo en la matriz, pero contrario a todo lo que dijiste, se ve cortado, y no se percibe la imagen del circulo. Le puse como tu dijiste 100Hz como frecuencia. Qué puedo hacer, me podrías ayudar por favor?

    ResponderEliminar
    Respuestas
    1. Hola como estas?, intentaste hacer el circulo con proteus? con electrónica discreta ?, Supongo que tendrás que darle mas precisión al proteus. El proteus realiza una simulación en tiempo real del circuito que montas, pero depende de que poder de proceso le configures, sera el resultado de la simulación. (mientras mas aumentes el poder de simulación mas potente tendrá que ser la PC, en mi caso no me permite ponerlo al máximo porque mi pc no lo soporta).
      Saludos.

      Eliminar
  24. hola si quiero poner todo el abecedario

    ResponderEliminar
  25. Este comentario ha sido eliminado por el autor.

    ResponderEliminar
  26. Hola, me gustaría saber cómo es la programación para el PIC 16F648 en PIC C compiler

    ResponderEliminar
    Respuestas
    1. Hola básicamente es lo mismo, no importa el modelo del microcontrolador, lo que si es necesario contar con la misma cantidad de entradas y salidas (si es que queres realizar este proyecto), también si soporta oscilador interno o no, ya que en este proyecto usar el oscilador externo sacrifica dos pines del puerto. Luego es lo mismo, solo tenes que cambiar la librería (#include<16F648.h>) siempre que tenga los mismos puertos esa sera la única modificación. Sino hay que reorganizar los pines y demás.
      Saludos!

      Eliminar
  27. Hola, ¿disculpa cómo se podría realizar sin microcontroladores? Saludos ^^

    ResponderEliminar
    Respuestas
    1. Hola, es un poco complejo, se puede pero tendrías dos docenas de circuitos integrados para realizar la secuencia, el uso de memorias, registros, etc.. no es practico, pero se puede.
      Básicamente tendrías que conseguir una memoria de 8bits paralela (puede ser EEPROM, EPROM, SRAM, DRAM), tenes que cargar en ella los bits que vas a mostrar en la matriz, al igual que en este programa en el vector. (posiblemente uno por uno).
      Después tenes que recorrer la matriz con un secuenciador (algún deco y un timer tipo 555), esto seria para las filas, en cuanto a las columnas tenes que hacer un barrido por ejemplo con un deco también, y si queres hacerlo como aca, tenes que sincronizar todo y generar los frames (refrescos de pantalla).
      Hay otro método mas sencillo y menos preciso, que es el concepto de barrido horizontal y vertical como en un TV. Para ello basicamente lees la memoria (una vez ya cargada) a determinada velocidad, y luego las columnas las barres de forma horizontal con un 4017 y un 555, de esta forma ajustando la frecuencia, si igualas la frecuencia de barrido horizontal con la de la memoria, te quedara quieta la imagen, si estas por debajo o por encima de la frecuencia de la memoria, entonces se genera un "scroll" que no va a estar sincronizado pero a los efectos visuales sera muy similar.
      Saludos!

      Eliminar
  28. hola eh armado como esta en la imagen todas las conexiones en los mismos pines y claro la alimentacion negativa doble y la alimentacion positiva...y al conectarlo a los 5 voltios pues ocurre un error corre letras supestamente para un lado pero la columna 5,7 y 8( o 1,2 y 4) si lo vez al reves) siempre estan encendidos no apagan para nada o bueno siempre estan prendidas ni disminuyen su iluminacion en ningun momento a que creas que se deba.....

    ResponderEliminar
  29. sera que hay diferencia en una matrix led 8x8 normal o de un solo color a una rgb?

    ResponderEliminar
  30. Este comentario ha sido eliminado por el autor.

    ResponderEliminar
  31. Tambien encontre el otro esquema que es igual solo cambia la conexion de los pines y el mensaje es un arbol y feliz navidad y ocurre lo mismo las dos primeras filas y la cuarta se quedan prendidos y por eso ni se logra ver si estara saliendo el msj correctamente pero cuando lo armo en el proteus si aparece que sale bien...no se cual sea mi error en el armado o sera el tipo de matrix que tiene que ser rgb...

    ResponderEliminar
    Respuestas
    1. Hola como estas, es un problema muy comun, ya que no todas las matrices estan internamente conectadas de la misma manera, en mi caso me ha pasado con matrices que he comprado y con las del simulador tambien.
      Te dejo el archivo de simulacion completo para que lo pruebes en Proteus como lo he probado yo con la matriz que va.
      https://sites.google.com/site/electgpl/storage/Matrix%208x8%20Navidad.7z?attredirects=0&d=1
      Saludos!

      Eliminar
    2. como te digo en el proteus si me sale ya lo probe con esa programacion y si sale perfecto en el proteus en todo caso supongo que al no estar conectadas de la misma manera todos las matrices led tendria que cambiar la forma de conectarlo como podria saber como conectarlos...

      Eliminar
    3. Aa, esta bien, no había entendido bien la pregunta.
      Entonces es definitivamente un tema de la matriz, que puede ser de lógica positiva o negativa.
      Saludos!

      Eliminar
    4. jajaj disculpa la ignorancia pero sigo sin entender como puedo areglar eso testeano cada pin o como...bueno que me queda... :(

      Eliminar
    5. No hay problema, testar cada pin seria midiendo entre X e Y, para saber donde esta cada anodo y catodo de cada led de la matriz, una vez que sabes eso, podes decidir como interconectar la matriz., Los pines correspondientes estan en el datasheet de la matriz pero tendrias que fijarte el codigo de la misma para saber cual es y que datasheet le corresponde.
      Saludos!

      Eliminar
  32. Saludos. Muy buen post :D
    Tengo unas cuantas dudas
    En qué parte van las resistencias? en las filas o columnas? Vi que en tu post de la matriz estática los pusiste en las filas, es igual aca?
    Los pines que no llevan resistencia se conectan directo al PIC?
    Una vez programado el PIC, este corre el programa automáticamente desde 0 una vez que demos corriente?
    Esta bien si uso una fuente de 6V a 500mA?
    Espero puedas resolver mis dudas :) De antemano, gracias

    ResponderEliminar
    Respuestas
    1. Hola, Gracias,
      Es indiferente, con que esten en un lugar de los dos. Yo suelo ponerlo en las filas por costumbre nada mas.
      Si, los pines que no llevan resistencia van directo al micro.
      Exactamente, una vez que lo encendes comienza a correr el programa.
      Hasta 5V regulados podes poner en el microcontrolador.
      Saludos!

      Eliminar
  33. Buenas noches sus post me han sido de gran ayuda, pero en esta oportunidad debo diseñar un mensaje que se desplace en una matiz de leds de 7x25 implementando la herramienta llamada Psoc que no es mas que el uso de componentes digitales como compuertas flip flops y de mas.

    Agradecería demasiado cualquier ayuda.

    ResponderEliminar
    Respuestas
    1. Hola como estas?, comprendo, pero no tengo ningun ejemplo desarrollado con PSOC, PLD, FPGA, o alguna otra logica electronica. Te recomiendo que busques algo con PLD o FPGA que vas a encontrar mas que para PSOC y ahi se maneja la logica como vos estas buscando.
      Saludos.

      Eliminar
  34. podrias hacer un ejemplo con recorrido en doble matriz

    ResponderEliminar
    Respuestas
    1. Hola, que seria en doble matriz?, tengo otra nota donde se usa una matriz de 8x32, que serian 4 matrices de 8x8, pero podrias ponerle 2 o mas.
      Saludos.

      Eliminar
  35. hey hola me gustaria saber como podria configurar solamente con los 4017 no necesito el pic ya que necesito hacerlo unicamente con compuertas logicas te agradeceria tu respuesta

    ResponderEliminar
    Respuestas
    1. Hola, podes usar el 4017 u otro integrado que realice barrido, pero si queres que se escriba algo en pantalla o se muestre alguna imagen en concreto, vas a necesitar de una memoria donde tengar esos datos cargados... si no queres usar microcontroladores, podes usar una memoria eprom y cargarle los datos para luego leerla y mandarla a la matriz, ahí no usarías ningún mcu, si no queres usar la memoria, tenes que hacerla vos mismo con una matriz de diodos para "grabarle" la secuencia.
      Saludos.

      Eliminar
  36. hola quiciera saber como hacer el barrido con el 4017 ya que quiero hacerlo con el 16f84a me prdrias ayudar

    ResponderEliminar
    Respuestas
    1. Hola, queres hacerlo con el 4017 o con el 16F84A? el 4017 requiere de un timer para la señal de clock y listo, hace el barrido, el micro tenes que crearle un timer interno o usar un timer por hard para que pueda accionar el 4017. Saludos.

      Eliminar
    2. como seria eso me podrias ayudar soy nuevo en lenguaje c y hacerlo en ensamblador seria muy tedioso solo me falta poder hacer el barrido ya adapte el ejemplo que muestras pero me hace falta accionar el barrido accionando el 4017 con el pic

      Eliminar
    3. el 4017 requiere un clock nada mas para que haga el barrido, podes tomar un pin de salida y ponerlo en 1, esperar un delay (Depende del resto del programa que tengas) y luego ponerlo a 0, y otra vez el mismo delay, con eso haces un pulso __|´´|__|´´ según la cantidad de pulsos que haces, sera cuanto se desplaza el 4017.
      Saludos.

      Eliminar
  37. necesito la prgramacion en bascon avr tengo en atmega 32

    ResponderEliminar
    Respuestas
    1. Hola, no la tengo realizada, tendrías que portarla a avr.
      Saludas

      Eliminar
  38. Buenas muy buena explicacion. Lo he desarrollado para el PIC 16870 en fisico y no funciona, pero en PROTEUS funciona perfectamente ¿ que puede ser? Ya he configurado un reloj externo. Un cristal de 4MHZ y dos capacitores de 15pF. Gracias de antemano

    ResponderEliminar
    Respuestas
    1. Hola, habría que ver si tenes algún warning o algo en la compilación, o si la matriz tiene el mismo común que en este diagrama sino no vas a encender ningún led o se van a encender mal.
      Saludos.

      Eliminar
  39. Hola Sebastian como estás, mi nombre es Osvaldo, Gracias por compartir el programa de como
    hacer letras en matriz, estoy tratando de aprender a programar en pics es lo que me gustaría aprender más, me ha parecido genial tu forma de mostrar como crearlas, he realizado el programa con todos los colores de las matrices en Proteus, pero noto que en la de color rojo las letras se ven menos iluminadas que el resto de los led de la matriz, podrías por favor ayudarme a resolver esta duda, o se debe conectar otro elemento a la matriz en la simulación en Proteus, Gracias por tu ayuda.

    ResponderEliminar
    Respuestas
    1. Hola como estas?, no creo que sea un tema para modificar firmware o hardware, las matrices de simulación de proteus son solo para comprobar que "funciona" tu hard y tu firmware, tendrías que montar el circuito para ver como se comporta la matriz física que tenes vos, y en función a las características eléctricas se podría evaluar si es que necesita o no drivers para aumentar el brillo o si hay que modificar el ciclo de trabajo de los leds para que brillen mas.
      Saludos.

      Eliminar
  40. Buenas, y para controlar una matriz rgb?

    ResponderEliminar
    Respuestas
    1. Tendrías que usar algún shift register como el 74595, uno por cada color, y luego un puerto paralelo de 8 bit del micro, en el programa tenes que realizar 3 matrices de datos, no una, ya que tenes 3 veces la información.
      Saludos.

      Eliminar