TUTORIAL: Programación de Microcontroladores – Parte 11

Esta es la última entrega de la serie de artículos que dedicamos a la construcción de un cartel de LEDS. Abordaremos la programación del hardware visto en la entrega anterior, de forma que cada lector pueda desarrollar su propio proyecto.

Como vimos en la primer y segunda entrega de esta serie, el cartel del LEDs que estamos construyendo puede adoptar diferentes tamaños de acuerdo a las necesidades o componentes que cada uno consiga. Esto hace que sea imposible proporcionar un programa específico que funcione en cualquier versión de cartel que se haya construido, pero sin embargo podemos hacer algo mucho mejor: ver de qué manera se escribe un programa de este tipo en BASIC (PIC SIMULATOR IDE) para que cada uno lo adecue a su proyecto.

Debemos pensar en un programa que nos permita mostrar pixeles individuales representados sobre la pantalla de nuestro cartel. Vamos a tomar como ejemplo un cartel que tenga una longitud de 80 columnas y 7 filas de altura, pero todo lo que expliquemos puede ser adecuado para carteles de otro tamaño.

Lo primero que necesitamos saber es que el “barrido” del cartel debe hacerse por filas. Es decir, mostraremos el contenido de la primera fila, esperamos un tiempo determinado (unos pocos milisegundos), mostramos el de la segunda fila, esperamos nuevamente, y así hasta llegar a la última fila. El motivo de no emplear las columnas para realizar el barrido es que como son más numerosas, el tiempo total que se necesita para “escribir” por filas es mucho menor que el necesario para escribir por columnas, y en la práctica eso significa que el brillo de nuestro cartel será mucho mayor si lo hacemos por filas, ya que cada LED permanecerá encendido 1/7 del tiempo. Si lo hiciésemos por columnas, cada LED estaría encendido solo 1/80 del tiempo, por lo que su brillo seria unas 10 veces menor.

Ahora bien, el primer problema a resolver es ¿Cómo escribo los datos de una fila del cartel? Bien, este tiene una solución más que simple: solo debemos introducir en el registro de desplazamiento los “0” y “1” necesarios para que los LEDs que queremos estén encendidos en esa fila tengan +V en sus ánodos. Por supuesto, mientras hacemos esto todos los pines del microcontrolador que controlan las filas deberán estar apagados, para que no se perciba una débil luminosidad en todos los LEDs de la fila que estamos escribiendo a medida que pasan los datos a través del registro.

El primer valor que se debe “meter” en el registro de desplazamiento es el que corresponder a la última columna. A medida que vamos ingresando los siguientes, se van desplazando (de ahí viene el nombre de “registro de desplazamiento”) hacia el final del cartel. Cuando hayamos introducido el valor número 80 (que corresponderá a la primera columna) el primer valor que metimos habrá llegado a su posición. En ese momento tenemos todo el registro escrito, y ya podemos activar la salida del PIC que corresponde a esa fila en particular.

El tiempo que debe estar encendida la fila se puede determinar empíricamente, pero por lo generan unos 10 milisegundos es suficiente. Si tenemos 7 filas, 10 milisegundos de demora permitirían escribir todo el cartel en unos 70 milisegundos, por lo que obtendríamos un máximo de 1000/70 = 14 “frames” por segundo. Este es un muy buen valor para una pantalla de este tipo, ya que solo estamos mostrando un texto y no un video.

En los cálculos anteriores no tuvimos en cuenta el tiempo que se demora en escribir los 80 valores en el registro de desplazamiento. Veamos porque: cada valor ingresado en el registro de desplazamiento demora unos 2 microsegundos. Es decir, demoramos 2 x 80 = 160 millonésimas de segundo en escribir toda la fila. Si multiplicamos este valor por 7 tendremos en tiempo que necesitamos para escribir las 7 filas del cartel, lo que nos da 1136 millonésimas de segundo, es decir, poco más de 1 milésima. Este es un tiempo despreciable frente a las 70 milésimas que nos tomamos para mostrar la imagen de cada fila.

Ahora vamos a ver, en BASIC, como hacer para escribir un valor en el registro de desplazamiento. Recordemos que el dato ingresa al registro en el momento que se produce la transición de “0” a “1” del pulso de CLOCK, por lo que se deberán seguir los siguientes pasos para ingresar cada uno de los 80 valores correspondientes a cada fila:

1) Fijar el valor del dato a escribir (si DATA es 1, hacer PORTA.0 = 1, si no PORTA.0 = 0)
2) Poner la línea de CLOCK en estado bajo (PORTA.1 = 0).
3) Esperar un 1 microsegundo (WaitUs 1)
4) Poner la línea de CLOCK en estado alto (PORTA.1 = 1). En este punto el dato entra efectivamente en el registro de desplazamiento.
5) Esperar un 1 microsegundo (WaitUs 1)
6) Fin

En BASIC, si hemos declarado que

Symbol clock = PORTA.1
Symbol data = PORTA.0

Un “0” se escribiría así:

data = 0
clock = 0
WaitUs 1
clock = 1
WaitUs 1

Y un “1” de la siguiente manera:

data = 1
clock = 0
WaitUs 1
clock = 1
WaitUs 1

Para escribir los 80 valores de la fila necesitamos hacer una subrutina que, tomando 10 bytes de la memoria EEPROM (10 bytes x 8 bits = 80 bits, es decir, una fila completa) los vuelque al registro de desplazamiento.

Si repetimos 7 veces este procedimiento, tendríamos una pantalla de 7×80 completa. Eso significa que en la EEPROM cada pantalla va a necesitar de 70 bytes (10 bytes por fila, 7 filas) para almacenar el mapa de bits correspondiente.

Veamos un ejemplo de cómo podría ser la subrutina encargada de escribir un byte tomado de la EEPROM en el registro de desplazamiento, a la que hemos llamado escriboByte:

escriboByte:
For columna = 1 To 8
If dato.7 = 0 Then
data = 0
clock = 0
WaitUs 1
clock = 1
WaitUs 1
Else
data = 1
clock = 0
WaitUs 1
clock = 1
WaitUs 1
Endif
aux = ShiftLeft(dato, 1)
Next columna
Return

Esta función debe ser llamada 10 veces para escribir la fila completa, con el valor a escribir guardado en la variable “dato”. El motivo por el cual el bucle FOR-NEXT toma los bits del byte desde el 7 hasta el 0 se debe a que justamente el último bit es el que debe ingresar primero al registro de desplazamiento, tal como explicamos antes.

Debemos partir de la base de que la información de la EEPROM la vamos a grabar desde un ordenador, y que seguramente crearemos un programa que permita, a partir de un texto determinado, generar los bits individuales que componen el bitmap de cada pantalla del cartel. Esto simplifica muchísimo la programación del microcontrolador, ya que solo debe dedicarse a leer la EEPROM y volcar su contenido al registro de desplazamiento, sin tener que “dibujar” las letras a partir de una tabla ni nada por el estilo.

Para animar el texto mostrado en el display hay dos opciones. La primera de ella es que, una vez que el bitmap de la EEPROM ha sido mostrado en la pantalla, comencemos a redibujarla continuamente (si no lo hacemos, el texto desaparecerá de la pantalla) pero cada un tiempo determinado (1 segundo por ejemplo) escribimos un bit “0” más en cada fila. Es decir, escribimos 81 bits en el primer segundo, 82 en el segundo, etc. Esto hará que el texto se desplace de izquierda a derecha, y es la animación más fácil de implementar. Sin embargo, lo normal es que los textos de desplacen en sentido contrario, por lo que nuestro programa debería hacer lo siguiente: comenzar escribiendo 80 “0”s en el registro ANTES de enviar la información de la fila, luego escribir 79 “0”s , y así sucesivamente. De esa manera, el texto al principio no será visible (estará “dibujado” a la derecha, fuera del registro de desplazamiento), y luego a medida que el numero de “0”s escritos va disminuyendo, comenzara a ser visible, entrando desde la derecha.

La segunda manera es que el software que escribe los datos en la EEPROM guarde cada “cuadro” de la animación, uno a continuación del otro, y que el PIC se limite a escribir cada cuadro leído durante (por ejemplo) un segundo. Esto vuelve a facilitar mucho la programación del PIC, a la vez que permite animaciones mucho más complicadas.

Si sabemos que cada pantalla necesita de 70 bytes para almacenarse en la EEPROM, con una 24C256 de 32.768 Bytes podemos almacenar unas 470 pantallas, una cantidad nada despreciable.

Con esta entrega damos por terminado nuestro proyecto. Creemos que en los tres capítulos que dedicamos a este tipo de carteles están las bases como para que cualquier hobbysta o estudiante se anime y pueda hacer realidad su propio cartel de LEDs animado. No se trata de un proyecto sencillo, pero una vez terminado seguramente los llenara de orgullo. Desde NeoTeo los animamos a que encaren este proyecto, y que por supuesto, nos comenten los resultados.