Matriz 8x8 - Mensaje con Desplazamiento (Scroll)

http://electgpl.blogspot.com/2013/11/matriz-8x8-mensaje-con-desplazamiento.html
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/adapta
dor-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.
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
Sebastian Caccavallo29 de julio de 2016, 09:32
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!