Embed Size (px)
Citation preview
Matriz de LEDS de 7 filas y 32 columnas. Tomado de la Revista ucontrol
Introducción
Matriz de LEDS de 7x32
En este proyecto veremos como diseñar y construir un display de diodos leds, que nos servirá de pantalla
para exhibir textos o imágenes, fijas o animadas. Los usos son varios, desde un sofisticado modding en el
gabinete de nuestro ordenador hasta su empleo como medio para exhibir mensajes o publicidad. Por
supuesto, sus dimensiones pueden resultar insuficientes para algunos usos, pero es fácilmente
expandible.
La gran mayoría de los aficionados a la electrónica, tarde o temprano, se propone la construcción de un
cartel basado en una matriz de diodos LEDs. El propósito de este artículo es explicar, de forma clara y
sencilla, la forma de hacerlo.
Un cartel formado por varias filas y columnas de LEDs, convenientemente programado, puede servir para
pasar mensajes publicitarios, decorar nuestra habitación, ordenador o lo que se nos ocurra. No solo se
trata de un proyecto más que interesante para llevarlo a cabo como hobbysta, sino que puede resultar
interesante como un producto comercializable. Es que estas matrices, que en algunos países se las
conoce como “cartel de LEDs ” o “Publik” , son un recurso muy frecuentemente utilizado con fines
publicitarios o informativos.
Descripción del proyecto
Por ejemplo, un PIC16F876A de 28 pines dispone de 22 dedicados a funciones de E/S, y su hermano mayor, el
PIC16F877A que cuenta con un total de 40 pines dedica 33 a estos menesteres. Habitualmente, con un número
así de pines de control es posible resolver correctamente casi cualquier situación que se nos plantee, ya que
normalmente en el diseño de un circuito de control basta con leer unos pocos pulsadores o sensores, y luego de
realizar internamente algún proceso con esas señales, se actúan (o no) unas pocas cargas conectadas a sus
salidas, generalmente mediante relés o interfaces de algún tipo. Sin embargo, hay caso concretos en que ningún
PIC (o microcontrolador de otras familias) puede aportar en número suficientes de E/S que permitan controlar
todas las cargas conectadas a el, y se deben recurrir a circuitos de apoyo comandados mediante señales de
control y utilizando un bus de datos. Uno de esos casos es el que nos ocupa en este artículo.
En lo que respecta a las entradas y salidas (E/S), cada microcontrolador, al igual que cualquier computadora,
dispone de un numero finito de ellas, y en general, se trata de un número no demasiado elevado. Está claro que
si queremos formar una imagen mediante pixeles compuestos por LEDs individuales, harán falta un numero de
líneas de control mucho mayor que las disponibles en cualquier microcontrolador.
Nuestra pantalla será semejante a esos displays que seguramente habrán visto en algún comercio o local de
servicios, en los que un texto realiza un scroll de derecha a izquierda, a una velocidad que permite la ilusión de
un movimiento suave y continuo. Estas matrices de leds generalmente están conformadas por un cierto número
de filas y de columnas.
Para permitir un texto legible, que represente claramente los caracteres correspondientes a las letras
mayúsculas y minúsculas hacen falta unas 7 filas de alto, y si queremos que el display muestre unos 10 o 12
caracteres simultáneamente, necesitaremos unas 100 columnas.
Si multiplicamos el numero de filas por las columnas, tendremos el numero de LEDs que hay presente en un
display de este tipo. Con los valores que mencionábamos recién, vemos que se necesitan 700 LEDs para un
display no muy complejo, y de un solo color.
Si nos limitáramos a los medios “tradicionales” para encender o apagar cada LED del display, es decir,
conectando cada uno de ellos a un pin de salida del PIC y encenderlos mediante 0 o 1 publicados en ese bit del
puerto, nos harían falta un PIC con al menos 700 pines, algo que debemos descartar de plano por que no existe.
Una solución posible seria utilizar varios PICs conectados entre si, de manera que cada uno maneje por ejemplo
dos o tres columnas, y mediante algún protocolo se envíen mensajes entre ellos para mostrar la parte del texto
que le corresponde. Esta alternativa tiene más posibilidades de éxito, pero cuenta con la contra de una
programación compleja y un costo elevado, ya que se necesitan unos 3 PICs por carácter, lo que
económicamente no es viable.
La respuesta a este problema viene de la mano de la multiplicación, el empleo de buses y circuitos de apoyo que
transformen datos enviados en forma serial a una representación en paralelo.
Multiplexado
El término “multiplexar” hace referencia a una técnica que permite aprovechar unas pocas líneas de datos para
diferentes tareas, cambiando la función que cumplen a lo largo del tiempo. Un ejemplo podría ser un sistema de
control de temperaturas de varios ambientes. Dado que la velocidad no es crucial, ya que en términos de
milisegundos (o microsegundos) la temperatura casi no varía debido a la inercia térmica, se puede utilizar un
único circuito que lea alternativamente cada sensor de temperatura. Esto evita la duplicación de circuitos y
permite resolver el problema con una fracción de los recursos (pines I/O) disponibles.
En el caso de este proyecto, la pantalla que construiremos esta formada por una matriz de 224 diodos LEDs
distribuidos una matriz de 32 columnas por 7 filas. Estos valores se eligieron por ser casi los mínimos para lograr
un display útil, ya que un carácter para ser legible necesita tener una altura de 5 o 7 píxeles, y un ancho como
mínimo de 5. Con estas dimensiones, lograremos ubicar un texto de unos 5 o 6 caracteres, que opcionalmente
puede irse desplazando por la matriz.
El hardware Tres Placas
Por razones de comodidad, el proyecto se distribuyo sobre tres placas de circuito impreso diferentes. La primera
de ellas, encargada de la alimentación, control lógico y la comunicación con la PC es la que incluye el PIC,
corazón del proyecto. Además, en ella se encuentra la etapa de alimentación, excepto el transformador, llave y
fusible que deberán alojarse en el gabinete que contenga esta placa.
La alimentación esta basada en un regulador de voltaje LM7805, capaz de entregar 500mA sin disipador, y hasta
1A si lo refrigeramos convenientemente. Si sacamos algunas cuentas, veremos que gracias al multiplexado
nunca debería haber más de una fila encendida al mismo tiempo, que en el caso más desfavorable tendría 32
leds encendidos. Cada LED consume unos 15 miliamperes (5V / 330 ohms = 0.015A), por lo que el consumo de
la “pantalla” es de 0.015 x 32 = 480mA, si esto sumamos el consumo del resto de la electrónica, el consumo total
ronda los 600mA. El LM7805 de mi prototipo apenas se entibia sin utilizar disipador.
El PIC se encarga de generar los pulsos de CLOCK y DATOs (pines 17 y 18) que son enviados a la “placa de
video” que es la que tiene los 74HC164N que forman un registro de desplazamiento. También tiene la posibilidad
de conectarse a una PC vía RS-232 y controla los drivers que proveen la corriente que alimenta cada fila del
display. Como la corriente es muy elevada para ser entregada directamente por el PIC, se incluyeron 7
transistores BC327 para esta tarea.
Se utilizo un cristal de 4MHz y dos capacitores de 22 nF para generar los pulsos de reloj del micro en lugar del
reloj interno, para lograr una mejor estabilidad con la temperatura, ya que en caso se utilizar la conexión RS-232
la velocidad es un tema delicado.
La segunda de las placas, que se conecta mediante un cable plano a la primera, es la encargada de controlar el
display. Recoge los pulsos de CLOCK y los datos provenientes de la placa controladora vía el cable plano, y
energiza las columnas que correspondan. Los 74HC164N se conectan a cada columna a través de una
resistencia de 330 o 390 ohms.
Si se quiere aumenta el brillo de los LEDS, pueden reemplazarse por resistencias de 220 ohms (o incluso
menores), pero asegurándose que el tiempo de encendido de los leds no pase de unos milisegundos por vez
para evitar su envejecimiento prematuro. También hay que prestar atención al consumo de corriente total, y
posiblemente cambiar los transistores BC327 por BC640, capaces de manejar corrientes mas elevadas.
Por último, la placa más sencilla, pero a la vez mas laboriosa desde el punto de vista constructivo es la “pantalla”
propiamente dicha, ya que está formada por 224 diodos LEDs. Esta placa recibe las señales de control
provenientes de la “placa de video” mediante pines de bronce que le otorgan soporte mecánico y eléctrico
simultáneamente, y mediante 7 pequeños cables que son los encargados de seleccionar la fila que vamos a
iluminar.
NOTA IMPORTANTE: En el esquema no figura la conexión del PIN 9 (RESET) del 74HC164N a +V, aunque si
está contemplado en el diseño del PCB. Ese pin DEBE estar a +V para que el circuito funcione.
El cable plano
Para enviar los datos desde la placa de control a la “placa de video” se utilizo un cable plano de 10 vías, con
fichas en los extremos muy parecidas a las empleadas para conectar unidades de CD-ROM dentro de la PC,
pero más pequeñas. Hay que tener cuidado que al armar el cable las fichas no queden invertidas, y las señales
de un extremo terminen siendo un espejo de las aplicadas en el otro.
Dado que los conductores de este cable son muy delgados, para evitar problemas se utilizaron dos cables de
más sección para llevar los 5V de alimentación hasta esta placa. Hay que tener en cuenta de conectarlos con la
polaridad correcta para evitar destruir algún componente.
Lista de componentes
1 porta fusible y fusible de 1 A.
1 transformador de 220V a 6V, 1 A.
1 puente de diodos de 1 A
1 regulador LM7805
2 capacitores cerámicos de 100 nF
2 capacitores cerámicos de 22 pF
1 capacitor electrolítico de 220uF/16V
1 dip-switch de 4 interruptores en formato DIL
1 diodo 1N4148
1 transistor BC547B
7 transistores BC327
1 cristal de 4 MHz.
1 resistencia de 33K
1 resistencia de 2K2
4 resistencias de 10K
7 resistencias de 1K5
32 resistencias de 330 ohms
224 leds rojos de 3mm
1 microcontrolador PIC 16F628A
4 Registros de desplazamiento 74HC164N
20 cm. de cable plano de 10 vías y dos fichas
3 borneras de 2 contactos, para circuito impreso
Varios: zócalos para los integrados, pines de bronce, circuito impreso virgen de una sola cara.
PCBs Son necesarias tres placas de circuito impreso para este proyecto, cuyos diseños son los siguientes:
Placa de control.(Descargar en PDF)
Placa de "video".(Descargar en PDF)
Placa del display.(Descargar en PDF)
El Software Programación
Si bien la construcción de este proyecto es un poco más compleja que otros encarados antes, la parte del
software es la que seguramente nos costara más trabajo, pero los resultados bien valen la pena. Hemos
adjuntado el listado correspondiente al programa que genera el texto “POWER” para que sirva de ejemplo, pero
la idea es que cada uno realice su propio software utilizando como punto de partida las ideas y datos que
expondremos a continuación.
Como dijimos antes, la pantalla está formada por una serie de filas y columnas. La intersección entre ambas
contiene un LED. Para que este encienda, tiene que recibir simultáneamente un “0” en la fila, y un “0” en la
columna. Cuando se dan estas condiciones, la electrónica de la “placa de video” se encarga del encendido.
La forma de generar un mensaje sobre el display es relativamente sencilla, si nos atenemos al siguiente
algoritmo:
1) Apagar todas las filas, escribiendo un 1 en PORTB.0 y PORTB.2 al 7
2) Escribir los valores correspondientes a la primer fila en el registro de desplazamiento, teniendo en cuenta
que el primer digito binario colocado corresponde al último LED de la fila, y el ultimo en poner al de la primer
columna.
3) Poner un “0” en la primer fila (PORTB.0 = 0), esperar un tiempo, y volver a apagarla con PORTB.0 = 1.
4) Repetir los pasos para las filas 2 a 7.
Los tiempos de demora que utilizamos en el programa de ejemplo permiten una visualización correcta, sin
molestos parpadeos y con los LEDS brillantes. Hay que tener en cuenta que si utilizamos tiempos mayores para
el encendido de cada fila, el brillo de los LEDS será mayor, pero también aumentara el parpadeo. No utilizamos
vectores ni otras alternativas que hubieran servido para crear un código mas compacto, buscando la claridad del
programa, para que pueda servir como base a otros mas completos/complejos.
El registro de desplazamiento
Vamos a detenernos un momento para explicar como se introducen los datos en el registro de desplazamiento.
Lo primero a tener en cuenta es que los datos deben entrar de izquierda a derecha, es decir, el primer dato que
introduzcamos sera “empujado” por los que vienen detrás hasta llegar a la ultima columna. En segundo lugar,
hay que saber (recomendamos la lectura de la hoja de datos del 74LS164N) 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 32 valores correspondientes a cada fila:
1) Fijar el valor del dato a escribir (si DATA es 1, hacer PORTA.1 = 1, si no PORTA.1 = 0)
2) Esperar un par de microsegundos (WaitUs 2)
3) Poner la línea de CLOCK en estado bajo (PORTA.0 = 0).
4) Esperar un par de microsegundos (WaitUs 2)
5) Poner la línea de CLOCK en estado alto (PORTA.0 = 1). En este punto el dato entra efectivamente en el
registro de desplazamiento.
6) Esperar un par de microsegundos (WaitUs 2)
7) Fin
Los tiempos de demora de dos microsegundos funcionan, pero se puede experimentar un poco con ellos, dado
que según la hoja de datos la frecuencia máxima de trabajo del 74LS164N es de 25MHz., por lo que demoras
menores deberían trabajar bien. Con estos tiempos, la escritura de los 32 bits de una línea demora unos 350
microsegundos, tiempo más que aceptable. En el código fuente se puede ver que por cada línea a escribir en la
pantalla se utiliza un bloque como el siguiente
aux = %0010001011111001 Gosub escribo
aux = %0100011100000010
Gosub escribo
Fila1 = 0
WaitMs 2
Fila1 = 1
Goto loop
End
Básicamente, se llama dos veces a la subrutina “escribo” que comentaremos en un momento, con 16 bits en la
variable “aux”.
Luego se enciende la fila escribiendo un “0” en el pin apropiado, se esperan un par de milisegundos, se apaga
escribiendo un “1”, y se pasa a la fila siguiente. La subrutina escribo se encarga de procesar el contenido de la
variable “aux”, bit por bit, viendo si son “0”o “1” y escribiendo el dato correspondiente en el registro de
desplazamiento. La instrucción “aux = ShiftLeft(aux, 1)” se encarga de rotar los 16 bits de la variable a la
izquierda, para tomar el bit siguiente.
Código fuente
A continuación, el código fuente de ejemplo, en BASIC del PIC SIMULATOR IDE.
'----------------------------
'Programa de ejemplo display 7x32
'Texto fijo: POWER
'
'PIC: 16F628A - 4Mhz XTAL, SIN RESET
'
'----- CONFIGURO PUERTOS-----
PORTA = 0
CMCON = 7 'Configuro PORTA como Digital I/O
'
'Configuro el portA:
TRISA.0 = 0 'Salida CLOCK
TRISA.1 = 0 'Salida DATA
TRISA.2 = 1 'Entrada Dip 0
TRISA.3 = 1 'Entrada Dip 1
TRISA.4 = 1 'Entrada Dip 2 TRISA.5 = 1 'Entrada Dip 3
'
'Configuro el portB:
TRISB.0 = 0 'Salida (Fila 1)
TRISB.1 = 1 'Entrada RS-232
TRISB.2 = 0 'Salida (Fila 2)
TRISB.3 = 0 'Salida (Fila 3)
TRISB.4 = 0 'Salida (Fila 4)
TRISB.5 = 0 'Salida (Fila 5)
TRISB.6 = 0 'Salida (Fila 6)
TRISB.7 = 0 'Salida (Fila 7)
'
'Simbolos
Symbol clock = PORTA.0
Symbol data = PORTA.1
Symbol fila1 = PORTB.0
Symbol fila2 = PORTB.2
Symbol fila3 = PORTB.3
Symbol fila4 = PORTB.4
Symbol fila5 = PORTB.5
Symbol fila6 = PORTB.6
Symbol fila7 = PORTB.7
clock = 0
data = 0
'
'Declaracion de variables
Dim col As Byte
Dim aux As Word
'
PORTB = 255 'Apago todas las filas antes de comen zar
'
'---------BUCLE PRINCIPAL------------
Loop:
aux = %0001111011111010
Gosub escribo
aux = %0010011100011110
Gosub escribo
fila1 = 0
WaitMs 2
fila1 = 1
'
aux = %0010001000001010
Gosub escribo
aux = %0010100010100010
Gosub escribo
fila2 = 0
WaitMs 2
fila2 = 1
'
aux = %0010001000001010
Gosub escribo
aux = %0010100010100010
Gosub escribo
fila3 = 0 WaitMs 2
fila3 = 1
'
aux = %0001111000111010
Gosub escribo
aux = %0010100010011110
Gosub escribo
fila4 = 0
WaitMs 2
fila4 = 1
'
aux = %0000101000001010
Gosub escribo
aux = %1010100010000010
Gosub escribo
fila5 = 0
WaitMs 2
fila5 = 1
'
aux = %0001001000001001
Gosub escribo
aux = %1100100010000010
Gosub escribo
fila6 = 0
WaitMs 2
fila6 = 1
'
aux = %0010001011111001
Gosub escribo
aux = %0100011100000010
Gosub escribo
fila7 = 0
WaitMs 2
fila7 = 1
'
Goto loop
'
End
'
'Subrutina que llena el registro de dezplazamiento
escribo:
For col = 1 To 16
If aux.15 = 0 Then
data = 1
WaitUs 2
clock = 0
WaitUs 2
clock = 1
WaitUs 2
Else
data = 0
WaitUs 2
clock = 0
WaitUs 2 clock = 1
WaitUs 2
Endif
aux = ShiftLeft(aux, 1)
Next col
Return
