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.