parte 11
TRANSCRIPT
SERVICIO NACIONAL DE ADIESTRAMIENTO EN TRABAJO INDUSTRIAL
PROYECTO DE INNOVACION ACADEMICA
“DISEÑO DE PANEL DIGITAL PROGRAMABLE CON RELOJ DIGITAL”
PROGRAMA : TECNICOS INDUSTRIALES
ESPECIALIDAD : ELECTROTECNIA INDUSTRIAL
PARTICIPANTES : EDGARD RENATO VALDIVIA SALAS
IVAN LELIS VILCAZAN ATENCIO
INGRESO : 2006 – II
EMPRESA : HOSPITAL REGIONAL HONORIO
DELGADO ESPINOZA
AREQUIPA – PERU
2009
DEDICATORIA:A mi padre por ser mi punto de
partida y ejemplo, a mi madre por su
perseverancia y fuerza; ya que ellos a
la luz de su ejemplo y esfuerzo hacen
más liviano mi camino.
1
AGRADECIMIENTO:
Mediante el presente trabajo aprovechamos la oportunidad para hacer un
reconocimiento al personal académico del SENATI “Servicio Nacional de
Adiestramiento en Trabajo Industrial” y en especial a nuestros instructores por
brindarnos la oportunidad de permitir cumplir la mas anhelada meta de cualquier
estudiante que ha cursado una carrera técnica y en este caso es el de poder
terminar la carrera técnica profesional de electrotecnia industrial.
2
INDICE Pág.
CAPITULO I.......................................................................................................7
Presentación..........................................................................................8
Antecedentes.........................................................................................9
Objetivos................................................................................................9
CAPITULO II....................................................................................................10
I. Microcontrolador PIC.................................................................... 11
1. introducción..............................................................................11
2. matriz de diodos Led................................................................11
II. Utilidad de un panel de diodos Led................................................12
1. Resolución................................................................................12
2. Diámetro...................................................................................12
3. Visibilidad.................................................................................13
4. Brillo.........................................................................................13
5. Angulo de visualización............................................................14
6. Cantidad de caracteres............................................................14
CAPITULO III ..................................................................................................15
I. Memoria.........................................................................................16
II. Hardware........................................................................................16
III. Encendido de un Led.....................................................................16
CAPITULO IV...................................................................................................18
I. Multiplexado...................................................................................19
II. Registros de desplazamiento.........................................................21
III. El CD4094......................................................................................25
IV. Diagrama de tiempos.....................................................................26
V. Filas y columnas............................................................................27
CAPITULO V....................................................................................................28
I. Funcionamiento de la matriz..........................................................29
II. Brillo de los leds.............................................................................29
III. El circuito controlador.....................................................................30
CAPITULO VI...................................................................................................32
I. El reloj............................................................................................33
II. El display........................................................................................34
3
CAPITULO VII..................................................................................................36
I. PIC16F873A...................................................................................37
1. Principales características.......................................................39
1.1. Características especiales.............................................39
2. Descripción de los terminales..................................................40
2.1. Terminales entrada/salida.................................................40
2.1.1. PortA RA0-RA5........................................................40
2.1.2. PortB RB0-RB7........................................................40
2.1.3. PortC RC0-RC7........................................................40
2.2. Otros terminales..........................................................40
3. El PIC por dentro......................................................................41
3.1. Diagrama de bloques........................................................41
3.2. El procesador o CPU .......................................................42
3.3. Memoria de programa ......................................................42
3.4. Memoria de datos ............................................................42
3.5. Circuito de reloj.................................................................43
3.6. Estado de reposo .............................................................44
3.7. Perro guardián..................................................................44
4. Temporizadores.......................................................................44
4.1. Temporizador TMR0..........................................................44
4.2. Temporizador TMR1..........................................................44
4.3. Temporizador TMR2..........................................................45
CAPITULO VIII.................................................................................................46
I. El software.....................................................................................47
1. Programación...........................................................................47
2. Registros de desplazamiento...................................................48
CAPITULO IX ..................................................................................................49
I. Circuito final...................................................................................50
II. Programa para el panel..................................................................51
CAPITULO X....................................................................................................68
I. Lista de componentes y costos......................................................69
II. Cronograma de actividades...........................................................70
III. Conclusiones..................................................................................71
IV. Webgrafia.......................................................................................71
4
CAPITULO I
5
PRESENTACIÓN
Señores instructores del SENATI
Presentamos a vuestra consideración el presente proyecto
En este proyecto veremos cómo diseñar y construir un panel de diodos LEDs, que
nos servirá de pantalla para exhibir textos o imágenes ya sean fijas o animadas.
Los usos son varios, podemos construir un sofisticado modding en nuestro gabinete
o emplearlo como medio para exhibir mensajes o publicidad.
Sus dimensiones pueden resultar insuficientes para algunos usos, pero es
fácilmente ampliable.
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.
Como es de suponer, el desarrollo, construcción y programación de un cartel e este
tipo es una tarea bastante compleja, pero perfectamente posible para cualquiera
que tenga conocimientos básicos de electrónica y programación.
ANTECEDENTES
6
La realización de este proyecto se llevo a cabo por la necesidad de una
mejor señalización en el área de emergencias.
La necesidad de un reloj en diversas áreas del hospital.
OBJETIVOS Mejorar la señalización de cada área.
Mostrar la hora en cada área ya que es indispensable.
DESCRIPCIÓN DEL PROYECTOEste proyecto se basa en el microcontrolador PIC16F877A que es el
corazón de nuestro proyecto, también se introdujo los registros de desplazamiento
serie paralelo para el multiplexado, y a la vez cuenta con un reloj de tiempo real
DS1307, estamos utilizando unas matrices de diodos LEDs.
7
CAPITULO II
I. MICROCONTROLADOR PIC
8
1. INTRODUCCIONEl uso de microcontroladores se extiende a prácticamente todos los aspectos de
nuestra vida actual. Desde teléfonos celulares, juguetes y electrodomésticos hasta
alarmas, sistemas de control de procesos, tarjetas de adquisición de datos,
computadoras y mucho más.
2. MATRIZ DE DIODOS LEDE propósito de este proyecto es explicar, de forma clara y sencilla, la forma de
hacerlo.
A lo largo de estos párrafos veremos la forma de abordar el problema, y el principio
de funcionamiento de una matriz de LEDs de un tamaño cualquiera.
9
El propósito de este proyecto es explicar, de forma clara y sencilla, la forma de
hacerlo.
A lo largo de estos párrafos veremos la forma de abordar el problema, y el principio
de funcionamiento de una matriz de LEDs de un tamaño cualquiera.
II. UTILIDAD DE UN PANEL DIGITAL DE DIODOS LEDs
Un panel digital convenientemente programado, puede servir para pasar mensajes
publicitarios dar la hora decorar nuestra habitación o lo que se nos ocurra. No solo
se trata de un proyecto más que interesante sino que puede resultar como un
producto comercializable.
Es que estos paneles, que en algunos países se les conoce como “cartel de LEDs”
o “publik” son un recurso muy frecuentemente utilizado con fines publicitarios o
informativos.
1. RESOLUCIÓN DE UNA MATRIZLa matriz es el parámetro descriptivo más importante de un panel digital.
Matriz es la cantidad de puntos luminosos que componen el panel. Se le expresa en
cantidad de filas por cantidad de columnas. De la matriz dependen la visibilidad del
cartel, la calidad de su tipografía y en la cantidad de caracteres visibles.
2. DIÁMETRO DE CADA LED O PUNTOLos puntos luminosos de estos paneles se forman con un componente denominado
LED. Por eso, a la matriz anterior se le dice “matriz de leds”.Normalmente cada punto se hace con un solo LED, que generalmente es de 5mm
de diámetro. Hay paneles que para mejorar la visibilidad usan varios LEDs por
punto, o de LEDs de diámetro mayor que 5mm. Es por lo tanto útil saber cuantos
LEDs por punto se emplean y de que diámetro.
10
3. VISIBILIDADLlamamos visibilidad o alcance visual al rango de distancias desde donde el panel
puede ser leído por una persona con vista normal.
Un cartel de LEDs se lee desde mas lejos que uno convencional (impreso) con la
misma altura de letra, porque las letras son luminosas. Si la matriz es buena, un
letrero pasa-mensajes de 5cm de altura de letra se lee perfectamente desde 25
metros.
El tamaño influye en la visibilidad de lejos, pero no tanto como la matriz y el
diámetro de cada punto luminoso. De lejos, un display de 5 cm de altura se ve casi
tanto como uno de 7cm, si es que su matriz y diámetros de LED son iguales.
Sin embargo, para leer a poca distancia, es mejor el panel de 5 cm, porque los
LEDs dispersos son incómodos para leer de cerca.
4. BRILLOSe clasifican en:
· Brillo estándar: Se usan poco, en paneles de bajo costo tales como los
importados más económicos.
· Alto brillo: Son los más empleados.
Híper/Súper brillo: Se usan exclusivamente para paneles para exteriores que
tengan incidencia directa de la luz solar.
El brillo mas adecuado dependerá de la intensidad de la luz que incida sobre el
panel. Por ejemplo, si va a recibir luz solar directa durante la mayor parte de la
jornada, convendrá utilizar un panel de híper/súper brillo, los cuales se especifican
como aptos para tal aplicación.
Un brillo excesivo incomoda la lectura, así que para estudiar la necesidad de un
panel para sol directo hay que analizar la proporción del tiempo que vaya a estar
recibiendo sol directo sobre el total.
Además, los LEDs de mucho brillo generalmente concentran la luz, empeorando así
un parámetro importante que hace a la visibilidad del panel, llamado ángulo de
visualización. Por lo tanto, carteles con mayor brillo que el necesario no son
convenientes.
5. ANGULO DE VISUALIZACIÓNEste parámetro nos indica que tan “de costado” podemos colocarnos sin dejar de
poder leer el panel. En algunos modelos es muy amplio, mientras que en otros
necesitamos estar parados prácticamente de frente para poder leerlos.
11
A mayor ángulo de visualización, mayor área de captación. Por ejemplo, el área de
cobertura con ángulo de visualización de 60º es de solo un tercio de la de uno con
ángulo de 180º. Eso quiere decir que el segundo transmite mensajes a tres veces
más público.
6. CANTIDAD DE CARACTERES La máxima cantidad de caracteres que puede mostrar un display en un mismo
instante nos da pautas sobre que tan destacados serán los mensajes en
movimiento y que tanto se van a poder aprovechar los efectos del texto fijo.
Esta cantidad depende fundamentalmente de cuántas columnas tenga la matriz. Es
otro ejemplo de la importancia de la resolución de la matriz, por eso decíamos que
este es el parámetro mas importante.
Hay también técnicas para aumentar la cantidad de caracteres, tales como las
tipografías de un ancho variable, en las cuales por ejemplo una ”i” ocupa menos
que una “m”. Estas, además de maximizar la cantidad de caracteres, le dan un
aspecto más elegante al texto.
12
CAPITULO III
I. MEMORIA
13
Muchas aplicaciones requieren paneles con memorias que conserven su contenido
aunque estén apagados. Esto se solía implementar con pilas recargables, que
estaban soldadas dentro del cartel. El problema con esas pilas es que su vida útil
es corta (3 a 5 años). Entonces, los paneles requerían de mantenimiento a los
pocos años de uso.
II. EL HARDWAREDesde el punto de vista del hardware, básicamente consiste en una matriz de
píxeles similar a los de la pantalla de un ordenador, generalmente de un solo color
(la mayoría de las veces rojos), aunque con el descenso de los precios de los LEDs
individuales o en paneles, es cada vez más frecuentes ver carteles “bicolores” o
incluso “multicolores”, aprovechando la ventaja del los LEDs RGB, que pueden
mostrar cualquier color.
Como es de suponer, el desarrollo, construcción y programación de un panel de
este tipo es una tarea bastante compleja, pero perfectamente posible para
cualquiera que tenga conocimientos básicos de electrónica y programación. Este
artículo puede ser utilizado como una guía paso a paso del proceso de creación de
un cartel de este tipo.
Para mantener el nivel de la explicación dentro de lo razonable, y para no gastar
una fortuna en nuestro panel, lo diseñaremos monocromático, utilizando LEDs de
color rojo únicamente. Las dimensiones de la matriz utilizada para mostrar los
textos, pueden variar, pudiendo ser tan pequeña (7 filas y 5 columnas) o tan grande
como se desee. Un tamaño razonable y muy empleado es el de 7 filas por 80
columnas, que permite escribir unas 14 o 16 letras de 7 “pixeles” de altura. A pesar
de no ser demasiado grande, ya habrás sacado la cuenta de que se necesitan 560
LEDs individuales para armar el cartel.
III. ENCENDIDO DE UN LED
Por supuesto, los LEDs resultan ser la lámpara ideal para los microcontroladores.
Su bajo consumo de corriente hace que puedan manejarse directamente con
Sus pines (casi siempre) sin necesidad de etapas intermedias. Pero antes de
realizar cualquier diseño electrónico, debemos asegurarnos que la corriente
suministrada por las salidas del microcontrolador en cuestión es suficiente
14
Para el modelo de LED que vamos a emplear. La figura siguiente ilustra la forma en
que podemos conectar un LED a un PIC. Vamos a suponer que la tensión
disponible en el pin del PIC es de 5V, que la corriente que atravesara el LED es de
15 mA, y que la caída de tensión en este es de 2V. Eso nos da un valor para R
de 200 Ohms, por lo que utilizaremos una de 220 Ohms, valor disponible
comercialmente, más cercano.
Ejemplo para el encendido de un Led.
15
CAPITULO IV
I. MULTIPLEXADO
16
El secreto, por supuesto, está en el multiplexado. Esta técnica permite utilizar unos
pocos pines de E/S del microcontrolador para manejar una serie de circuitos
integrados que se encarguen de excitar los LEDs. Hay varias maneras, y muchos
modelos diferentes de circuitos para hacer esto.
Pueden usarse un tipo de integrado digital llamado “LATCH”, que básicamente es
una memoria en la que escribimos un valor, y lo mantiene en sus salidas hasta que
nosotros lo indiquemos. De esta manera, usando varios latches podríamos
encender los LEDs por turnos, rápidamente para que no se note el parpadeo, y de
esa manera formar una palabra en el cartel.
Otra forma es utilizar un registro de desplazamiento. Y de hecho, es de esta forma
cómo vamos a diseñar nuestro panel. Un registro de desplazamiento funciona de la
misma manera en que funciona una cola de gente que espera para entrar en un
cine. Por un extremo de la cola van ingresando las personas que llegan, y por el
otro van saliendo de la fila. En un registro de desplazamiento, en lugar de personas
tenemos “0” y “1”. Lo bueno de esto es que para “meter” datos (“0”s y “1”s) en el
registro de desplazamiento solo hacen falta tres pines del microcontrolador,
independientemente de lo largo que sea.
Estos pines se encargan de tres tareas: Uno de ellos, al que denominaremos
“DATA” es el encargado de decirle al registro de desplazamiento que lo que
introduciremos es un “0” o un “1”. El segundo se encarga de avisar al registro que el
dato ya está listo para ser ingresado, y lo llamaremos “CLOCK”. Y el ultimo, que no
es indispensable, es el “RESET”, que se encarga de “vaciar” la fila escribiendo “0”s
en todas las salidas del registro.
Para desarrollar nuestro ejemplo utilizaremos el circuito integrado 74HC164N, que
es un registro de desplazamiento de 8 bits. Es decir, con el se puede armar una
“fila” de 8 “personas”. Para construir un cartel de 80 columnas, necesitaríamos
utilizar 10 de estos integrados, uno a continuación del otro. Afortunadamente, este
integrado cuesta solo centavos.
En la figura 1 podemos ver la función de cada uno de los pines del 74HC164N y en
la figura 2 de que forma podemos conectar uno a continuación del otro para obtener
un registro de desplazamiento de cualquier longitud.
17
Figura 1.
Figura 2.
II. REGISTROS DE DESPLAZAMIENTO
A menudo debemos resolver situaciones en las que el número de salidas
disponibles en el microcontrolador que estamos usando es insuficiente. Una
18
manera de controlar varias salidas a partir de unos pocos pines consiste en la
utilización de los llamados registros de desplazamiento, pero ¿sabes que son y
como emplearlos?
Un registro de desplazamiento es una configuración circuítal muy utilizada,
generalmente para convertir un flujo de datos en forma serial a uno del tipo
paralelo, motivo por el cual a menudo los chips encargados de esta tarea son
llamados conversores serie-paralelo.
Por supuesto, es posible construir un registro de este tipo a partir de componentes
discretos, aunque en la practica resultan no solo inapropiado por cuestiones de
tamaño y velocidad, sino también económicas.
La mejor manera de entender conceptos nuevos es apoyándose en analogías con
temas que nos son familiares. En este caso no vamos a hacer una excepción, por lo
que utilizaremos como ejemplo el funcionamiento de una cola, como la de un
banco.
Supongamos que dos tipos de personas pueden formar parte de una cola. Estos
dos tipos de personas son las que se ven en la figura siguiente, y es imposible
confundir una con otra. Es decir, siempre estaremos seguros que en una posición
determinada de la fila se ubica una u otra persona. Las llamaremos “0” (el gordito) y
“1” (el mas flaco).
"0" y "1", nuestros personajes.
La cola que usaremos como ejemplo tiene 8 lugares, que hemos numerado del 0 al
7, pero nada impide trabajar con colas mas largas, por lo que todo lo que se vea
aquí, puede ser generalizado para colas de la longitud que se desee.
19
La cola utilizada como ejemplo tiene 8 posiciones.
Otra particularidad de nuestra hipotética cola es que nunca puede estar vacía.
Todas sus posiciones tienen que estar ocupadas, ya sea por gorditos o flacos. En el
estado inicial, la cola se encuentra completamente llena de gorditos, como se
observa en la figura 3.
El estado inicial de la cola es este: completa de "gorditos".
Nuestra cola funciona como cualquier cola de la vida real: cuando alguien nuevo
llega a la fila, se coloca en el lugar de mas atrás, que en este caso corresponde a la
“posición 0”. Como nuestra cola tiene una longitud máxima de 8 posiciones como
para hacer lugar al recién llegado, es necesario que todos los que estaban en la fila
“avancen” una posición. El que estaba en la posición 0 pasa a la 1, el que estaba en
la 1 pasa a la 2, y así hasta llegar al que estaba en posición 7, que “sale” por el
extremo opuesto.
Llega un nuevo integrante a la cola....
20
...y ocupa el ultimo lugar, desplazando a todos los demás una posición. El primero
"sale" de la fila.
Este es el estado final de nuestra fila, con el nuevo integrante en el último lugar.
Si continuaran ingresando personas en la fila, el proceso se repetiría con cada
nuevo integrante que llegue. Como el que entra primero es el primero en salir, a
este tipo de colas se las llama "FIFO", por First Input, First Output (Primero que
entra, primero que sale).
Con todas estas cuestiones en mente podemos seguir avanzando en la
comprensión del funcionamiento de los registros de desplazamiento. Supongamos
que queremos que en la cola haya dos flacos en los primeros lugares, luego un
gordo, otra vez dos flacos, luego otro gordo por ultimo dos flacos más (como
siempre, 8 personas en total). Sabiendo que cada personaje que ingresa en la cola
"empuja" a todos una posición a la derecha, si queremos que el que termine
ocupando el extremo derecho de la cola sea un flaco, ese será el que primero debe
entrar. Siguiendo el razonamiento anterior, los personajes deberían entrar en la fila
en el orden siguiente:
21
Los nuevos integrantes de la fila, esperando para ocupar su lugar.
Este es el estado final de nuestra fila, con los integrantes originales desplazados
hacia la derecha.
Poniendo fin a nuestra analogía, tendríamos que los integrantes de esta hipotética
cola son los "0"s y "1"s (o estados altos y bajos) de nuestros circuitos, es decir,
nuestros datos. La cola en si es el registro de desplazamiento. Cuando decíamos
que el estado inicial de la cola eran 8 gordos, estábamos queriendo decir que al
alimentar nuestro circuito, todas las salidas estarán en "0" o estado bajo.
USANDO EL CD4094
Siguiendo con el análisis comenzado en el artículo Registros de desplazamiento, se
estudiará el circuito integrado CD4094, de Fairchild semiconductor, que posee
prestaciones similares al 74HC164N.
III. EL CD4094
22
El CD4094 es un registro de desplazamiento de 8 bits, con salida tri-estado. Esto
significa que disponemos de un mecanismo para aislar sus 8 pines de salida del
resto del circuito. Los datos son desplazados serialmente con cada flanco de subida
del reloj (CLOCK) y cada bit es transmitido al latch correspondiente con cada flanco
de bajada del pin STROBE
Las características más destacables de este circuito integrado son:
Rango de voltaje: 3.0 V a 18.0 V
Compatibilidad con la familia TTL
Salida tri-estado
23
IV. DIAGRAMA DE TIEMPOS
Para establecer las señales de control en el CD4094, es necesario estudiar su
diagrama de tiempos:
Diagrama de tiempos
La primera señal de control es DATA, que es el dato que enviaremos serialmente.
Enviamos un flanco ascendente y luego un flanco descendente. En el instante que
el CLOCK esté subiendo, el estado del DATA será reconocido como un dato válido
por el CD4094
La señal de control STROBE se usa en caso de que queramos tener en los latch de
salida los bits enviados por el PIC a medida que se van recibiendo.
Como se usará un display 7 segmentos, lo mejor es ver el dato completo una vez
finalizada la transferencia. Entonces STROBE en un nivel alto mientras enviamos
los datos. Con ello garantizamos que el display no muestre valores “extraños” hasta
que no pongamos STROBE en bajo, instante que se transferirán los 8 bits
completos a los latches de salida.
Por último tenemos el pin OUTPUT ENABLE. Este pin cumple la función del tercer
estado del latch, el estado de alta impedancia. En este caso no lo usaremos.
Generalmente se emplea en sistemas de buses, donde se conectan varios
24
integrados a las mismas señales, permitiendo aislar un circuito de otro. Así que
mantendremos este pin en un nivel alto.
V. FILAS Y COLUMNAS
Bien, con el esquema explicado podemos encender los LEDs que queramos de una
fila de 80 bits de largo. Si en el registro de desplazamiento introducimos “11111…
111”, los 64 leds estarán encendidos. Si queremos encender uno por medio,
escribiremos “10101…01”. Por supuesto, cuando lleguemos a la parte de la
programación veremos cómo se ingresan uno a uno los “0” y “1” en el registro.
En este punto puede ser necesario analizar el tema de las filas. Si tenemos, por
ejemplo, un cartel con 8 filas, y lo explicado recién sirve para manejar solo una de
ellas ¿debemos utilizar un registro de desplazamiento para cada una de las filas
restantes? Afortunadamente, la respuesta es no.
Si bien podríamos utilizar 8 registros de este tipo, la cantidad de circuitos integrados
necesarios (64 de ellos), la complejidad del circuito impreso y el costo implicado lo
hacen poco aconsejable. Nosotros aprovecharemos un “defecto” del ojo humano,
que mantiene la imagen vista durante unos 20 o 30 milisegundos, para “dibujar” una
fila a la vez, pero muy rápidamente, de forma que todo el cartel parezca estar
encendido a la vez. Si, se trata de un sistema similar al empleado en el cine o en la
televisión.
Si seguimos pensando en un cartel de 8 filas y 64 columnas, sin utilizar registros de
desplazamiento necesitaríamos 512 pines de entrada/salida. Con el esquema
propuesto solo necesitamos 8 de ellos para seleccionar la fila a escribir, y tres para
manejar el registro de desplazamiento.
25
CAPITULO V
26
I. FUNCIONAMIENTO DE LA MATRIZ
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 “1” en la columna. Cuando se dan
estas condiciones, la electrónica de la placa se encarga del encendido del LED en
cuestión. La forma de generar un mensaje sobre el display es relativamente
sencilla, si nos atenemos al siguiente algoritmo:
1) Apagar todas las columnas.
2) Escribir los valores correspondientes a la primer columna en el registro de
desplazamiento, teniendo en cuenta que el primer digito binario colocado
corresponde al último LED de la columna, y el ultimo en poner al de la primera fila.
3) Encenderla primer columna, esperar un tiempo, y volver a apagarla.
4) Repetir los pasos 2 y 3 para las columnas restantes.
El tiempo de la demora debe ser tal que permita 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
27
será mayor, pero también aumentará el parpadeo. La forma de transformar este
algoritmo en un programa funcional depende de cada programador, y puede ser
más o menos complejo según se permitan diferentes tipos de caracteres,
animaciones, etc.
II. EL BRILLO DE LOS LEDS
Un punto a tener en cuenta es la intensidad del brillo que puede proporcionar el tipo
de LED que utilicemos. Un LED, utilizado en aplicaciones “normales”, se alimenta
con unos 3V y requiere unos 15mA (varia ligeramente de un modelo a otro) para
brillar con una buena intensidad. En caso de un típico panel de 8 filas, a pesar de
que las veremos encendidas al mismo tiempo, cada LED solo estará encendido la
octava parte del tiempo, por lo que su brillo será ocho veces inferior al normal, y
nuestro panel apenas será visible.
Afortunadamente esto también tiene solución: dado que los tiempos que
permanecerá encendido cada LED no superará los 20 o 30 milisegundos, podremos
hacerles circular una corriente mayor a la nominal sin que lleguen a dañarse, con lo
que brillarán mucho más intensamente, dando como resultado un cartel
perfectamente visible.
Respecto de los LEDs, podremos utilizar LEDs discretos o comprar “paneles” de
7x5 LEDs que tienen unos 14 o 16 terminales (según el modelo), estando ya
interconectados en forma de matriz. Quizás sea esta la mejor alternativa.
III. EL CIRCUITO CONTROLADOR
Este es el cerebro de nuestro panel. Será el encargado de gestionar el encendido
de cada LED mediante órdenes enviadas a las columnas mediante el registro de
desplazamiento y a las filas.
Como una columna tendrá muchos LEDs (8, por ejemplo) y existe la posibilidad que
en algún momento puedan estar todos encendidos, no podemos conectarlas
directamente a pines de E/S del PIC, porque la corriente que demandarían haría
que el puerto del microcontrolador pase a mejor vida. Para evitar esto, utilizaremos
en medio un transistor capaz de manejar la corriente requerida.
28
Controlador del cartel.
Analicemos el circuito de la figura anterior. El centro de todo es el microcontrolador
PIC16F873A, que tiene su pin de RESET conectado a un pulsador y un resistor de
10K. Este pulsador permite reiniciar el cartel cuando lo necesitemos. También se ha
implementado un circuito de reloj externo, basado en un cristal de 4 MHz y dos
condensadores de 27 pF. Esto le permite al PIC ejecutar un millón de instrucciones
por segundo, más que suficientes para este proyecto.
Todo el puerto B del PIC está dedicado a controlar las columnas del panel. Como
ya habrán notado, tenemos 8 salidas para 8 columnas, y nuestro panel tiene solo
64 columnas. Por lo que vamos a puentear las 8 salidas del puerto B a las 56
columnas restantes.
29
CAPITULO VI
30
I. EL RELOJ
En este diseño (panel) se podrá visualizar la hora (reloj) ya que es muy primordial
en nuestra vida, y a la vez este funcionara como cualquier otro, se podrá poner a la
hora (adelantar o retroceder) según convenga.
Por último, los pines 16,17 y 18, correspondientes a los terminales RC5 (encargado
de adelantar las horas, minutos y segundos), RC6 (encargado de retroceder las
horas, minutos y segundos) y RC7 (encargado de seleccionar si vamos a adelantar
o retroceder horas, minutos y segundos).
Las características más sobresalientes de este reloj son: dígitos formados por
diodos leds, de un tamaño aproximado a los 7 centímetros de alto, pero fácilmente
ampliables.
Como el corazón del proyecto es un microcontrolador, la posibilidad de ampliar las
funcionalidades del reloj son enormes, muchas veces solamente modificando el
software que lo controla.
El panel en si consta de 6 dígitos, con los que se pueden representar los dígitos del
“0” al “9” y algunos caracteres, con dos puntos entre cada par de dígitos.
Por si solo, el panel propiamente dicho es incapaz de mostrar ningún tipo de
información, dado que solo es una colección de leds conectados entre si.
Para que sea capaz de representar algún dato, tenemos que lograr controlar
individualmente cada Led que componen cada uno de los cuatro dígitos, y también
los dos leds centrales (los “:”). El lenguaje de programación que utilizaremos será
en el lenguaje “C”.
Este panel será el encargado de mostrar la hora en formato “HH:MM:SS”
No hemos incluido una fuente de alimentación. Cualquier fuente comercial (o
construida en casa) que sea capaz de entregar 5V y 1A será suficiente. Esos 5V
deben estar bien regulados, y por supuesto, el software deberá estar escrito
correctamente, es decir, no encender varias columnas al mismo tiempo, ya que el
consumo de todo el panel encendido sería de unos 512 x 20mA = 10.24 A, lo que
podría destruir la fuente en caso de que no cuente con protecciones adecuadas.
31
II. EL DISPLAY
Esta es la parte del proyecto que todo el mundo va a mirar, así que debemos ser
prolijos al montarlo. Como puede verse en el esquema eléctrico de la figura 4,
hemos utilizado un total de 8 circuitos integrados CD4094 para construir el registro
de desplazamiento de 64 bits de largo, uno para cada columna. Como explicamos,
si alguien quiere hacer un panel más largo o más corto, deberá poner más o menos
integrados.
De esta forma se conectan los LEDs en filas y columnas.
Si miramos el esquema del display, veremos que en la parte superior se muestra
como está conectado cada LED dentro de la matriz. Esto es importante tenerlo en
cuenta a la hora de comprar los módulos, ya que hay una gran cantidad de
modelos, y algunos de ellos tienen los LEDs conectados en el sentido inverso.
Cada display también difiere en la función de cada terminal, por lo que se debe
estar a atentos a la hoja de datos para diseñar el circuito impreso apropiado, y
conectarlos como corresponda.
En el dibujo del circuito no hemos representado los 16 módulos ni los 10 circuitos
integrados, por una cuestión de espacio, pero es fácil darse cuenta de qué forma se
conectan las filas y columnas de los demás displays a cada CD4094
32
Si por algún motivo se desea borrar la pantalla, basta con enviar “0”s al registro de
desplazamiento y listo. El tiempo empleado para esa tarea es despreciable, ya que
el microcontrolador estará ejecutando 1 millón de instrucciones por segundo.
Cada salida de los CD4094, como dijimos, se conecta a una columna de la serie de
displays. Esta conexión se efectúa mediante un resistor de 1/8 de Watt, que en el
esquema se ha dibujado con un valor de 330 ohm. Ese fue el valor adecuado para
el tipo de módulos que conseguimos para hacer el prototipo, pero su valor variará
de un modulo a otro. Se puede montar solo un display con resistores de 330 Ohms,
y ver como es el brillo de los LEDs. Si es escaso, se puede bajar el valor a 220 o
100 Ohms. Con eso debería ser suficiente.
33
CAPITULO VII
34
I. PIC 16F873A
Se denomina microcontrolador a un dispositivo programable capaz de realizar
diferentes actividades que requieran del procesamiento de datos digitales y del
control y comunicación digital de diferentes dispositivos.
Los microcontroladores poseen una memoria interna que almacena dos tipos de
datos; las instrucciones, que corresponden al programa que se ejecuta, y los
registros, es decir, los datos que el usuario maneja, así como registros especiales
para el control de las diferentes funciones del microcontrolador.
Los microcontroladores se programan en Assembler y cada microcontrolador varía
su conjunto de instrucciones de acuerdo a su fabricante y modelo. De acuerdo al
número de instrucciones que el microcontrolador maneja se le denomina de
arquitectura RISC (reducido) o CISC (complejo).
Los microcontroladores poseen principalmente una ALU (Unidad Lógico Aritmética),
memoria del programa, memoria de registros, y pines I/O (entrada y/0 salida). La
ALU es la encargada de procesar los datos dependiendo de las instrucciones que
se ejecuten (ADD, OR, AND), mientras que los pines son los que se encargan de
comunicar al microcontrolador con el medio externo; la función de los pines puede
ser de transmisión de datos, alimentación de corriente para l funcionamiento de
este o pines de control especifico.
En este proyecto se utilizo el PIC 16F873A. Este microcontrolador es fabricado por
MicroChip familia a la cual se le denomina PIC. El modelo 16F873A posee varias
características que hacen a este microcontrolador un dispositivo muy versátil,
eficiente y practico para ser empleado en la aplicación que posteriormente será
detallada.
Algunas de estas características se muestran a continuación:
Estos son sus datos más relevantes:
Ítem Valor
Memoria de programa 7.2 KBytes (8192 instrucciones)
Memoria SRAM 192 KBytes
Memoria EEPROM 128 KBytes
Número de E/S 22
Número de ADC 5 (10 Bits)
35
Número de PWM 2
SPI Si
I2C Si (Master)
USART Si
Timers 8 Bits 2
Timers16 Bits 1
Comparadores 2
Clock 0-20 MHz
Número de pines 28
Cápsula PDIP, SOIC, SSOP, QFN
En este proyecto utilizaremos el PIC16F873. Este microcontrolador forma parte de
la familia de los PIC16F87X.
1. PRINCIPALES CARACTERISTICAS
36
Set de instrucciones reducido (RISC). Sólo 35 instrucciones para aprender.
Las instrucciones se ejecutan en un sólo ciclo de máquina excepto los saltos
que requieren 2 ciclos.
Opera con una frecuencia de clock reloj de hasta 20 MHz (ciclo de máquina
de 200 ns)
Memoria de programa: 4096 posiciones de 14 bits.
Memoria de datos: Memoria RAM de 192 bytes (8 bits por registro).
Memoria EEPROM: 128 bytes (8 bits por registro).
Stack de 8 niveles.
22 Terminales de I/O que soportan corrientes de hasta 25 mA.
5 Entradas analógicas de 10 bits de resolución.
3 Timers.
Módulos de comunicación serie, comparadores, PWM.
1.1. CARACTERISTICAS ESPECIALES:
La memoria de programa se puede reescribir hasta 1000 veces.
La memoria EEPROM se puede reescribir hasta 1000000 de veces.
Los datos almacenados en la memoria EEPROM se retienen por 40 años y
no se borran al quitar la alimentación al circuito.
13 fuentes de interrupción:
o Señal externa (RB0).
o Desborde de TMR0
o Cambio en el estado de los terminales RB4, RB5, RB6 o RB7.
o Ciclo de escritura en la memoria EEPROM completado.
o Ciclo de conversión A/D finalizado
o etc.
2. DESCRIPCION DE LOS TERMINALES
37
2.1. TERMINALES DE ENTRADA-SALIDA (22 EN TOTAL)
2.1.1. PORTA: RA0-RA5:
Los terminales RA0-RA3 y RA5 son bidireccionales y manejan señales TTL.
Pueden configurarse como entradas analógicas
El terminal RA4 como entrada es Schmitt Trigger y cómo salida es colector
abierto. Este terminal puede configurarse como clock de entrada para el
contador TMR0.
2.1.2. PORTB: RB0-RB7:
Los terminales RB0-RB7 son bidireccionales y manejan señales TTL.
Por software se pueden activar las resistencias de pull-up internas, que
evitan el uso de resistencias externas en caso de que los terminales se
utilicen como entrada (esto permite, en algunos casos, reducir el número de
componentes externos necesarios).
RB0 se puede utilizar como entrada de pulsos para la interrupción externa.
RB4-RB7 se pueden utilizar para la interrupción por cambio de estado.
2.1.3. PORTC: RC0-RC7:
Los terminales RC0-RC7 son bidireccionales y manejan señales TTL.
Se utilizan en los módulos de PWM, comparadores y transmisión serial.
2.2. OTROS TERMINALES
VDD: Positivo de alimentación. 2-6 Vcc.
VSS: Negativo de alimentación.
MCLR: Master Clear (Reset). Mientras en este terminal haya un nivel bajo (0
Vcc), el microcontrolador permanece inactivo.
OSC1/CLKIN: Entrada del oscilador (cristal). Entrada de oscilador externo.
OSC2/CLKOUT: Salida del oscilador (cristal).
3. EL PIC16F873 POR DENTRO
38
3.1. DIAGRAMA DE BLOQUES
Como se observa en el esquema del diagrama de bloques del PIC, este consta de
un procesador con una ALU y un Decodificador de Instrucciones, una memoria de
programas tipo FLASH de 4K palabras de 14 bits, una memoria de datos SRAM on
192 posiciones de 8 bits. También existe una zona de 128 bytes de EEPROM para
datos no volátiles. Finalmente dispone de interrupciones, un temporizador, WDT
(perro guardián), los terminales de E/S (PORTA, PORTB y PORTC) configurables
por software y los módulos especiales (timers, comparadores, puerto serie).
39
3.2. EL PROCESADOR O CPU
El procesador responde a la arquitectura RISC, que se identifica porque el juego de
instrucciones se reduce a 35, donde la mayoría se ejecutan en un ciclo de reloj,
excepto las instrucciones de salto que necesitan dos ciclos.
La ALU (Unidad Aritmético Lógica), ubicada dentro del procesador realiza las
operaciones lógicas y aritméticas con dos operandos, uno que recibe desde el
registro W (registro de trabajo) y otro que puede provenir de cualquier registro
interno.
3.3. MEMORIA DE PROGRAMA
La memoria de programa es del tipo flash. La memoria flash es una memoria no
volátil, de bajo consumo que se puede escribir y borrar eléctricamente. Es
programable en el circuito como la EEPROM pero de mayor densidad y más rápida.
El PIC 16F873 posee una memoria de 4K palabras, es decir permite hasta 4096
instrucciones de 14 bits cada una.
3.4. MEMORIA DE DATOS
Se encuentra en dos zonas bien diferenciadas:
1- Memoria tipo RAM (SRAM): Se divide en 4 bancos o paginas de 128 registros
de 8 bits cada uno, aunque no todos los registros están implementados físicamente.
Los registros se dividen en:
Registros especiales: Cada uno tiene una función específica que se
analizará más adelante.
Registros de uso general: Son los registros que le permiten al usuario
almacenar valores temporalmente (variables) durante la ejecución del
programa.
2- Memoria de datos tipo EEPROM: esta compuesta de por 128 registros de 8 bits
cada uno. Este tipo de memoria es capaz de guardar la información más de 40
años.
40
3.5. CIRCUITO DE RELOJ
Para que el PIC 16F873 procese instrucciones, necesita un reloj cuyos impulsos
determinen la velocidad de trabajo. El oscilador que genera esos impulsos esta
implementado dentro del circuito integrado, pero para regular, seleccionar y
estabilizar la frecuencia de trabajo hay que colocar externamente cierta circuiteria
entre los pines OSC1/CLKIN y OSC2/CLKOUT.
La frecuencia de reloj principal determina el ciclo de instrucción (tiempo que tarda
una instrucción en ejecutarse). En los PICs, un ciclo de instrucción emplea cuatro
periodos de oscilación del reloj principal. Por ejemplo si la frecuencia del reloj
principal es de 4 MHz, un ciclo de instrucción tardara en realizarse:
T oscilación del reloj principal = 1/F del reloj principal = 1/4MHz = 250ns
Ciclo de instrucción = T oscilación x4 = 250ns x 4 = 1µs
Según los componentes externos que se coloquen se configuran cuatro tipos de
osciladores:
Tipo RC: Es un oscilador de bajo costo y poca estabilidad. Solo precisa una
resistencia y un capacitor externos.
Tipo HS: Es un oscilador de alta velocidad y muy estable funciona en
frecuencias comprendidas entre 4 y 20MHz. Utiliza un cristal de cuarzo o un
resonador cerámico.
Tipo XT: También emplea el cristal de cuarzo o el resonador cerámico.
Trabaja en frecuencias medias, comprendidas entre 100KHz y 4MHz.
Tipo LP: Empleado en aplicaciones de bajo consumo, lo que conlleva una
frecuencia pequeña. A mas velocidad, mas consumo. Usa cristal o
resonador, y las frecuencias de trabajo oscilan entre 35 y 200KHz.
3.6. ESTADO DE REPOSO:Cuando el microcontrolador funciona en modo reposo (sleep) la potencia necesaria
es menor de 3mA.
41
3.7. PERRO GUARDIÁN (WATCHDOG):
El temporizador perro guardián (watchdog) es independiente del reloj principal
(posee su propio oscilador), por lo tanto en el modo en bajo consumo puede seguir
funcionando. Cuando llegue al valor máximo FFh, se produce el desbordamiento
del perro guardián, se iniciara tomando el valor 00h y provocara un reset. El tiempo
típico es de 18ms, pero utilizando un divisor de frecuencia (programable por
software) se pueden alcanzar 2.3 segundos.
La utilización del perro guardián permite controlar los posibles cuelgues del
programa, esto es si durante el programa hemos previsto poner a cero el perro
guardián para evitar que se genere un reset, en el momento que por un fallo no
previsto el programa se quede en un bucle sin fin, al no poder poner a cero el perro
guardián, este generara un reset sacando al programa del bucle.
4. TEMPORIZADORES:
4.1. TEMPORIZADOR TMR0
Contador de 8 bits, similar al del PIC16F84.
4.2. TEMPORIZADOR TMR1
De los tres temporizadores disponibles en los PIC16F87X éste es el único que tiene
un tamaño de 16 bits y que actúa como un Temporizador/Contador. Para manejar
16 bits es preciso concatenar dos registros de 8 bits: TMR1H:TMR1L, que son los
encargados de guardar la cuenta en cada instante. Dicho valor evoluciona desde
0000H hasta FFFFH y al regresar nuevamente al valor 0000H se acciona la
señalización TMRlF, y si se desea se puede provocar la petición de una
interrupción. El valor existente en TMR1H:TMR1L puede ser leído o escrito y los
pulsos de reloj que originan la cuenta ascendente pueden provenir del exterior o de
la frecuencia de funcionamiento del microcontrolador (Fosc/4).
El TMR1 puede funcionar de tres maneras:
Como temporizador.
Como contador síncrono.
Como contador asíncrono.
42
En el modo temporizador el valor concatenado TMRII-l:TM1L se incrementa con
cada ciclo de instrucción (Fosc/4). En el modo contador, el incremento se puede
producir con los flancos ascendentes de un reloj, cuya entrada se aplica a las líneas
RCO y RCI de la puerta C, o por los impulsos aplicados en la línea RCO.
4.3. TEMPORIZADOR TMR2
El TMR2 es un temporizador ascendente de 8 bits y que también puede realizar
operaciones especiales para el Puerto Serie Síncrono (SSP) y para los módulos de
Captura y Comparación. La señal de reloj del TMR2 es la interna Fosc/4, y antes de
ser aplicada pasa por un pre-divisor de frecuencia con rangos 1:1, 1:4 y 1:16. La
salida del TMR2 atraviesa un post-divisor de frecuencia con rangos comprendidos
entre 1:1 hasta 1:16, pasando por los 16 valores posibles. Al entrar el
microcontrolador en modo de reposo, se detiene el oscilador interno y TMR2 deja
de funcionar.
43
CAPITULO VIII
44
I. EL SOFTWARE
1. PROGRAMACIÓN
Si bien la construcción de este proyecto es un poco más compleja, la parte del
software es la que seguramente nos costara mas trabajo, pero los resultados bien
valen la pena. Hemos adjuntado el listado correspondiente al programa que genera
el texto “EMERGENCIA” “12:00 (reloj)” para que sirva de ejemplo.
Como dijimos antes, la pantalla esta 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 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 columnas, escribiendo un 1 en PORTB.0 y PORTB.2 al 7
←2) Escribir los valores correspondientes a la primer columna en el registro de
desplazamiento, teniendo en cuenta que el primer digito binario colocado
corresponde al ultimo LED de la columna, y el ultimo en poner al de la primer
columna.
←3) Poner un “0” en la primer columna (PORTB.0 = 0), esperar un tiempo, y volver
a apagarla con PORTB.0 = 1.
←4) Repetir los pasos para las columnas 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
columna, 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 más compacto, buscando la claridad del programa.
45
2. 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 derecha a izquierda, es decir, el primer dato que introduzcamos será
“empujado” por los que vienen detrás hasta llegar a la última columna. En segundo
lugar, hay que saber (recomendamos la lectura de la hoja de datos del CD4094)
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
Una vez descrito todos los pasos a seguir para conseguir el correcto
funcionamiento de nuestro panel y con los conocimientos ya mencionados
pasaremos a la construcción del programa en si hecho en lenguaje “C”.
46
CAPITULO IX
47
D2
CLK
3
STB
1
OE
15
Q0
4
Q1
5
Q2
6
Q3
7
Q4
14
Q5
13
Q6
12
Q7
11
QS
9
QS
10
U1
D2
CLK
3
STB
1
OE
15
Q0
4
Q1
5
Q2
6
Q3
7
Q4
14
Q5
13
Q6
12
Q7
11
QS
9
QS
10
U2
D2
CLK
3
STB
1
OE
15
Q0
4
Q1
5
Q2
6
Q3
7
Q4
14
Q5
13
Q6
12
Q7
11
QS
9
QS
10
U3
D2
CLK
3
STB
1
OE
15
Q0
4
Q1
5
Q2
6
Q3
7
Q4
14
Q5
13
Q6
12
Q7
11
QS
9
QS
10
U4
D2
CLK
3
STB
1
OE
15
Q0
4
Q1
5
Q2
6
Q3
7
Q4
14
Q5
13
Q6
12
Q7
11
QS
9
QS
10
U5
D2
CLK
3
STB
1
OE
15
Q0
4
Q1
5
Q2
6
Q3
7
Q4
14
Q5
13
Q6
12
Q7
11
QS
9
QS
10
U64094
D2
CLK
3
STB
1
OE
15
Q0
4
Q1
5
Q2
6
Q3
7
Q4
14
Q5
13
Q6
12
Q7
11
QS
9
QS
10
U7
RA0/AN02
RA1/AN13
RA2/AN2/VREF-/CVREF4
RA4/T0CKI/C1OUT6
RA5/AN4/SS/C2OUT7
OSC1/CLKIN9
OSC2/CLKOUT10
RC1/T1OSI/CCP2 12
RC2/CCP1 13
RC3/SCK/SCL 14
RB7/PGD 28RB6/PGC 27RB5 26RB4 25RB3/PGM 24RB2 23RB1 22RB0/INT 21
RC7/RX/DT 18RC6/TX/CK 17RC5/SDO 16RC4/SDI/SDA 15
RA3/AN3/VREF+5
RC0/T1OSO/T1CKI 11
MCLR/Vpp/THV1
U8
PIC16F873APROGRAM=letrero.hex
1 2
U10:A
74S04
3 4
U10:B
74S04
5 6
U10:C
74S04
13 12
U10:D
74S04
11 10
U10:E
74S04
9 8
U10:F
74S04
1 2
U11:A
74S04
3 4
U11:B
74S04
ENTER
INC
DEC
D2
CLK
3
STB
1
OE
15
Q0
4
Q1
5
Q2
6
Q3
7
Q4
14
Q5
13
Q6
12
Q7
11
QS
9
QS
10
U9
X1
CRYSTAL
C127pF
C227pF
R1
10k
R2
10k
R3
10k
48
I. C
IRC
UIT
O F
INA
L D
ISEÑ
AD
O P
AR
A N
UES
TRO
PA
NEL
II. PROGRAMA PARA EL PANEL
//******************************************************************************#include <16F873A.h>#fuses XT, NOWDT, NOPROTECT, BROWNOUT, PUT, NOLVP #use delay (clock = 4000000)#byte PCL=0x02#byte PCLATH=0x0A//******************************************************************************int. conta=0,mas=0,mass=0;int mensaje=200,columnas=56,carga,dato,prueba;int a=0,b=0,c=0,d=0,e=0,f=0,g=0,h=0,i=0,j=0;long x=0;int seg=0,min=0,hor=0,contador=0;int segu,segd,minu,mind,horu,hord;int h_digit,m_digit,l_digit;int confi=0,aa=0,bb=0;int xx=0,yy=0,zz=0;//******************************************************************************void mensaje1(void);void mensaje(void);void recorrer_reloj(void);void recorrer_men(void);void segundos(void);void dos_puntos(void);void minutos(void);void horas(void);void blanco(void);void configuracion(void);void vizu(void);void fijo(void);void int2bcd(int valor);//******************************************************************************//INTERRUPCIONES//******************************************************************************#INT_TIMER1void interrupcion(){ #asm movwf conta #endasm ++contador; if(contador==2) { contador=0; ++seg; if(seg==60) { seg=0; ++min; if(min==60) { min=0;
49
++hor; if(hor==12) { hor=0; } } } } set_timer1(3036); //reset TMR1 #asm movf conta,0 #endasm}//******************************************************************************void main(void) { setup_adc_ports(NO_ANALOGS); setup_adc(ADC_OFF); enable_interrupts(INT_TIMER1); //interrupcion TIMER1 activada setup_timer_1(T1_INTERNAL|T1_DIV_BY_8); //configuracion TMR1 set_timer1(3036); //carga TMR1 enable_interrupts(GLOBAL); output_a(0); output_b(0); output_bit(PIN_A2,1); output_bit(PIN_A3,1); output_bit(PIN_A0,1); while(1) { fijo(); recorrer_men(); recorrer_reloj(); if(confi==1) { configuracion(); } }}//******************************************************************************void mensaje1(void) { #asm movf carga,0 call hola1 goto fin1hola1: addwf PCL,F retlw 0b00000000 ;-------------------------------------------------- retlw 0b00000000 ; '0' retlw 0b11111111 ; '1' retlw 0b11111111 ; '2' retlw 0b10001001 ; '3' retlw 0b10001001 ; '4'
50
retlw 0b10000001 ; '5' retlw 0b00000000 ; '6' retlw 0b11111111 ; '7' retlw 0b11111111 ; '8' retlw 0b00000010 ; '9' ;10
retlw 0b00000100 ; '0' retlw 0b00000010 ; '1' retlw 0b11111111 ; '2' retlw 0b00000000 ; '4' retlw 0b11111111 ; '5' retlw 0b11111111 ; '6' retlw 0b10001001 ; '7' retlw 0b10001001 ; '8' retlw 0b10000001 ; '9' 20
retlw 0b00000000 ; '0' retlw 0b11111111 ; '1' retlw 0b11111111 ; '2' retlw 0b00101001 ; '3' retlw 0b01001001 ; '4' retlw 0b10000110 ; '5' retlw 0b00000000 ; '6' retlw 0b01111110 ; '7' retlw 0b11111111 ; '8' retlw 0b10000001 ; '9' 30
retlw 0b10010001 ; '0' retlw 0b01110010 ; '1' retlw 0b00000000 ; '2' retlw 0b11111111 ; '3' retlw 0b11111111 ; '4' retlw 0b10001001 ; '5' retlw 0b10001001 ; '6' retlw 0b10000001 ; '7' retlw 0b00000000 ; '8' retlw 0b11111111 ; '9' 40
retlw 0b11111111 ; '0' retlw 0b00000100 ; '1' retlw 0b00010000 ; '2' retlw 0b11111111 ; '3' retlw 0b00000000 ; '4' retlw 0b01111110 ; '5' retlw 0b11111111 ; '6' retlw 0b10000001 ; '7' retlw 0b10000001 ; '8' retlw 0b11000011 ; '9' 50
retlw 0b00000000 ; '0' retlw 0b10000001 ; '1' retlw 0b11111111 ; '2' retlw 0b11111111 ; '3' retlw 0b10000001 ; '4' retlw 0b00000000 ; '5'
51
retlw 0b11111110 ; '6' retlw 0b11111111 ; '7' retlw 0b00001001 ; '8' retlw 0b00001001 ; '9' 60 retlw 0b11111110 ; '0' retlw 0b00000000 ; '1' retlw 0b00000000 ; '2' retlw 0b00000000 ; '3' retlw 0b00000000 ; '4' retlw 0b00000000 ; '5' retlw 0b00000000 ; '6' retlw 0b00000000 ; '7' retlw 0b00000000 ; '8' retlw 0b00000000 ; '9' 70 retlw 0b00000000 ; '0' retlw 0b00000000 ; '1' retlw 0b00000000 ; '2' retlw 0b00000000 ; '3' retlw 0b00000000 ; '4' retlw 0b00000000 ; '5' retlw 0b00000000 ; '6' retlw 0b00000000 ; '7' retlw 0b00000000 ; '8' retlw 0b00000000 ; '9' 80 retlw 0b00000000 ; '0' retlw 0b00000000 ; '1' retlw 0b00000000 ; '2' retlw 0b00000000 ; '3' retlw 0b00000000 ; '4' retlw 0b00000000 ; '5' retlw 0b00000000 ; '6' retlw 0b00000000 ; '7' retlw 0b00000000 ; '8' retlw 0b00000000 ; '9' 90 retlw 0b00000000 ; '0' retlw 0b00000000 ; '1' retlw 0b00000000 ; '2' retlw 0b00000000 ; '3' retlw 0b00000000 ; '4' retlw 0b00000000 ; '5' retlw 0b00000000 ; '6' retlw 0b00000000 ; '7' retlw 0b00000000 ; '8' retlw 0b00000000 ; '9' 100 retlw 0b00000000 ; '0' retlw 0b00000000 ; '1' retlw 0b00000000 ; '2' retlw 0b00000000 ; '3' retlw 0b00000000 ; '4'
52
retlw 0b00000000 ; '5' retlw 0b00000000 ; '6' retlw 0b00000000 ; '7' retlw 0b00000000 ; '8' retlw 0b00000000 ; '9' 110 retlw 0b00000000 ; '0' retlw 0b00000000 ; '1' retlw 0b00000000 ; '2' retlw 0b00000000 ; '3' retlw 0b00000000 ; '4' retlw 0b00000000 ; '5' retlw 0b00000000 ; '6' retlw 0b00000000 ; '7' retlw 0b00000000 ; '8' retlw 0b00000000 ; '9' 120 retlw 0b00000000 ; '0' retlw 0b00000000 ; '1' retlw 0b00000000 ; '2' retlw 0b00000000 ; '3' retlw 0b00000000 ; '4' retlw 0b00000000 ; '5' retlw 0b00000000 ; '6' retlw 0b00000000 ; '7' retlw 0b00000000 ; '8' retlw 0b00000000 ; '9' 120 retlw 0b00000000 ; '0' retlw 0b00000000 ; '1' retlw 0b00000000 ; '2' retlw 0b00000000 ; '3' retlw 0b00000000 ; '4' retlw 0b00000000 ; '5' retlw 0b00000000 ; '6' retlw 0b00000000 ; '7' retlw 0b00000000 ; '8' retlw 0b00000000 ; '9' 120 retlw 0b00000000 ; '0' retlw 0b00000000 ; '1' retlw 0b00000000 ; '2' retlw 0b00000000 ; '3' retlw 0b00000000 ; '4' retlw 0b00000000 ; '5' retlw 0b00000000 ; '6' retlw 0b00000000 ; '7' retlw 0b00000000 ; '8' retlw 0b00000000 ; '9' 120
fin1: movwf dato; #endasm }//******************************************************************************
53
void mensaje(void) { #asm movlw 2 movwf PCLATH movf carga,0; call hola; movwf dato; goto fin hola: addwf PCL,F ;35H 53DEC retlw 0b00000000 ;*******PORSIACA CASO;-------------------------------------------------- retlw 0b00000000 ; '0' retlw 0b00000000 ; '1' retlw 0b00000000 ; '2' retlw 0b00000000 ; '3' retlw 0b00000000 ; '4' retlw 0b00000000 ; '5' retlw 0b00000000 ; '6' retlw 0b00000000 ; '7' retlw 0b00000000 ; '8' retlw 0b00000000 ; '9' 90 retlw 0b00000000 ; '0' retlw 0b00000000 ; '1' retlw 0b00000000 ; '2' retlw 0b00000000 ; '3' retlw 0b00000000 ; '4' retlw 0b00000000 ; '5' retlw 0b00000000 ; '6' retlw 0b00000000 ; '7' retlw 0b00000000 ; '8' retlw 0b00000000 ; '9' 100 retlw 0b00000000 ; '0' retlw 0b00000000 ; '1' retlw 0b00000000 ; '2' retlw 0b00000000 ; '3' retlw 0b00000000 ; '4' retlw 0b00000000 ; '5' retlw 0b00000000 ; '6' retlw 0b00000000 ; '7' retlw 0b00000000 ; '8' retlw 0b00000000 ; '9' 110 retlw 0b00000000 ; '0' retlw 0b00000000 ; '1' retlw 0b00000000 ; '2' retlw 0b00000000 ; '3' retlw 0b00000000 ; '4' retlw 0b00000000 ; '5' retlw 0b00000000 ; '6'
54
retlw 0b00000000 ; '7' retlw 0b00000000 ; '8' retlw 0b00000000 ; '9' 120 retlw 0b00000000 ; '0' retlw 0b00000000 ; '1' retlw 0b00000000 ; '2' retlw 0b00000000 ; '3' retlw 0b00000000 ; '4' retlw 0b00000000 ; '5' retlw 0b00000000 ; '6' retlw 0b00000000 ; '7' retlw 0b00000000 ; '8' retlw 0b00000000 ; '9' 120 retlw 0b00000000 ; '0' retlw 0b00000000 ; '1' retlw 0b00000000 ; '2' retlw 0b00000000 ; '3' retlw 0b00000000 ; '4' retlw 0b00000000 ; '5' retlw 0b00000000 ; '6' retlw 0b00000000 ; '7' retlw 0b00000000 ; '8' retlw 0b00000000 ; '9' 120 retlw 0b00000000 ; '9' 120 retlw 0b01111100 ; '0' retlw 0b10100010 ; '1' retlw 0b10010010 ; '2' retlw 0b10001010 ; '3' retlw 0b01111100 ; '4' retlw 0b00000000 ; '5' retlw 0b10000100 ; '6' retlw 0b10000010 ; '7' retlw 0b11111110 ; '8' retlw 0b10000000 ; '9' ;10 retlw 0b10000000 ; '0' retlw 0b00000000 ; '1' retlw 0b10000100 ; '2' retlw 0b11000010 ; '4' retlw 0b10100010 ; '5' retlw 0b10010010 ; '6' retlw 0b10001100 ; '7' retlw 0b00000000 ; '8' retlw 0b01000010 ; '9' 20 retlw 0b10010010 ; '0' retlw 0b10011010 ; '1' retlw 0b10010110 ; '2' retlw 0b01100010 ; '3' retlw 0b00000000 ; '4'
55
retlw 0b00110000 ; '5' retlw 0b00101000 ; '6' retlw 0b00100100 ; '7' retlw 0b11111110 ; '8' retlw 0b00100000 ; '9' 30 retlw 0b00000000 ; '0' retlw 0b01001110 ; '1' retlw 0b10001010 ; '2' retlw 0b10001010 ; '3' retlw 0b10001010 ; '4' retlw 0b01110010 ; '5' retlw 0b00000000 ; '6' retlw 0b01110000 ; '7' retlw 0b10011000 ; '8' retlw 0b10010100 ; '9' 40 retlw 0b10010010 ; '0' retlw 0b01100010 ; '1' retlw 0b00000000 ; '2' retlw 0b11000010 ; '3' retlw 0b00100010 ; '4' retlw 0b00010010 ; '5' retlw 0b00001010 ; '6' retlw 0b00000110 ; '7' ;48 retlw 0b00000000 ; '8' retlw 0b01101100 ; '9' 50 retlw 0b10010010 ; '8' retlw 0b10010010 ; '9' 52 retlw 0b10010010 ; '8' retlw 0b01101100 ; '9' 54 retlw 0b00000000 ; '8' retlw 0b10001100 ; '9' 56 retlw 0b10010010 ; '9' 56 retlw 0b01010010 ; '9' 56 retlw 0b00110010 ; '9' 56 retlw 0b00011100 ; '9' 56 retlw 0b00000000 ; '9' 56
retlw 0b00000000 ; '9' 56 retlw 0b00000000 ; '9' 56 retlw 0b01101100 ; '9' 56 retlw 0b01101100 ; '9' 56 retlw 0b00000000 ; '9' 56 retlw 0b00000000 ; '9' 56 retlw 0b00000000 ; '9' 56 retlw 0b00000000 ; '9' 56 retlw 0b00000000 ; '9' 56 retlw 0b00000000 ; '9' 56 retlw 0b00000000 ; '9' 56
56
retlw 0b00000000 ; '9' 56fin: clrf PCLATH #endasm
}//******************************************************************************void configuracion(void) { xx=1; disable_interrupts(INT_TIMER1); while(xx) { if(!input(PIN_C5)) { ++seg; if(seg==60) { seg=0; } while(!input(PIN_C5)) { vizu(); } } if(!input(PIN_C6)) { --seg; if(seg==-1) { seg=0; } while(!input(PIN_C6)) { vizu(); } } if(!input(PIN_C7)) { xx=0; while(!input(PIN_C7)) {} }//------------------------------------------------------------------------------ vizu();//------------------------------------------------------------------------------ }//------------------------------------------------------------------------------ yy=1; while(yy) { if(!input(PIN_C5)) { ++min;
57
if(min==60) { min=0; } while(!input(PIN_C5)) { vizu(); } } if(!input(PIN_C6)) { --min; if(min==-1) { min=0; } while(!input(PIN_C6)) { vizu(); } } if(!input(PIN_C7)) { yy=0; while(!input(PIN_C7)) {} }//------------------------------------------------------------------------------ vizu();//------------------------------------------------------------------------------ }//------------------------------------------------------------------------------ zz=1; while(zz) { if(!input(PIN_C5)) { ++hor; if(hor==24) { hor=0; } while(!input(PIN_C5)) { vizu(); } } if(!input(PIN_C6)) { --hor; if(hor==-1) { hor=0; } while(!input(PIN_C6))
58
{ vizu(); } } if(!input(PIN_C7)) { zz=0; confi=0; enable_interrupts(INT_TIMER1); while(!input(PIN_C7)) {} }//------------------------------------------------------------------------------ vizu();//------------------------------------------------------------------------------ }//------------------------------------------------------------------------------ }//******************************************************************************void vizu(void) { int2bcd(seg); segu=l_digit; segd=m_digit; int2bcd(min); minu=l_digit; mind=m_digit; int2bcd(hor); horu=l_digit; hord=m_digit; blanco(); horas(); dos_puntos(); minutos(); dos_puntos(); segundos(); blanco(); output_bit(PIN_A0,1); }//******************************************************************************void recorrer_reloj(void) { prueba=0; c=1; b=0; output_bit(PIN_A0,1); while(c) { int2bcd(seg); segu=l_digit; segd=m_digit; int2bcd(min); minu=l_digit; mind=m_digit;
59
int2bcd(hor); horu=l_digit; hord=m_digit; blanco(); horas(); dos_puntos(); minutos(); dos_puntos(); segundos(); blanco(); output_bit(PIN_A0,1); ++x; if(x==800) { c=0; x=0; } if(!input(PIN_C7)) { confi=1; c=0; while(!input(PIN_C7)) {} } } }//******************************************************************************void blanco(void) { j=1; carga=11*6+61; while(j) { ++carga; mensaje(); output_bit(PIN_A1,1); output_b(dato); delay_us(5); output_bit(PIN_A1,0); output_bit(PIN_A0,0); delay_us(5); output_b(0); ++prueba; if(prueba==6) { prueba=0; j=0; } } }//******************************************************************************void horas(void) { h=1; carga=hord*6+61;
60
while(h) { ++carga; mensaje(); output_bit(PIN_A1,1); output_b(dato); delay_us(5); output_bit(PIN_A1,0); output_bit(PIN_A0,0); delay_us(5); output_b(0); ++prueba; if(prueba==6) { prueba=0; h=0; } }//------------------------------------------------------------------------------ i=1; carga=horu*6+61; while(i) { ++carga; mensaje(); output_bit(PIN_A1,1); output_b(dato); delay_us(5); output_bit(PIN_A1,0); output_bit(PIN_A0,0); delay_us(5); output_b(0); ++prueba; if(prueba==6) { prueba=0; i=0; } } }//******************************************************************************void minutos(void) { f=1; carga=mind*6+61; while(f) { ++carga; mensaje(); output_bit(PIN_A1,1); output_b(dato); delay_us(5); output_bit(PIN_A1,0); output_bit(PIN_A0,0); delay_us(5);
61
output_b(0); ++prueba; if(prueba==6) { prueba=0; f=0; } }//------------------------------------------------------------------------------ g=1; carga=minu*6+61; while(g) { ++carga; mensaje(); output_bit(PIN_A1,1); output_b(dato); delay_us(5); output_bit(PIN_A1,0); output_bit(PIN_A0,0); delay_us(5); output_b(0); ++prueba; if(prueba==6) { prueba=0; g=0; } } }//******************************************************************************void dos_puntos(void) { e=1; carga=10*6+61; while(e) { ++carga; mensaje(); output_bit(PIN_A1,1); output_b(dato); delay_us(5); output_bit(PIN_A1,0); output_bit(PIN_A0,0); delay_us(5); output_b(0); ++prueba; if(prueba==6) { prueba=0; e=0; } } }//******************************************************************************
62
void segundos(void) { d=1; carga=segd*6+61; while(d) { ++carga; mensaje(); output_bit(PIN_A1,1); output_b(dato); delay_us(5); output_bit(PIN_A1,0); output_bit(PIN_A0,0); delay_us(5); output_b(0); ++prueba; if(prueba==6) { prueba=0; d=0; } }//------------------------------------------------------------------------------ e=1; carga=segu*6+61; while(e) { ++carga; mensaje(); output_bit(PIN_A1,1); output_b(dato); delay_us(5); output_bit(PIN_A1,0); output_bit(PIN_A0,0); delay_us(5); output_b(0); ++prueba; if(prueba==6) { prueba=0; e=0; } } }//******************************************************************************void recorrer_men(void) { columnas=0; carga=0; mass=0; output_bit(PIN_A0,1); a=1; while(a) { ++mass;
63
++carga; mensaje1(); output_bit(PIN_A1,1); output_b(dato); delay_us(5); output_bit(PIN_A1,0); output_bit(PIN_A0,0); delay_us(5); output_b(0); //------------------------------------------------------------------------------ if(mass==72) { ++columnas;//------------------------------------------------------------------------------ mass=0; mas=0; carga=0; output_bit(PIN_A0,1); delay_ms(50); while(columnas!=mas) { ++mas; ++carga; }//------------------------------------------------------------------------------ }//------------------------------------------------------------------------------ if(columnas==60) { a=0; }//------------------------------------------------------------------------------ } }//******************************************************************************void fijo(void) { carga=0; output_bit(PIN_A0,1); aa=1; bb=0; while(aa) { ++carga; mensaje1(); output_bit(PIN_A1,1); output_b(dato); delay_us(5); output_bit(PIN_A1,0); output_bit(PIN_A0,0); delay_us(5); output_b(0); //------------------------------------------------------------------------------ if(carga==72) {
64
carga=0; ++bb; output_bit(PIN_A0,1); }//------------------------------------------------------------------------------ if(bb==500) { aa=0; }//------------------------------------------------------------------------------ } }//******************************************************************************/************************************************/// Funcion que convierte de Entero a 3 x BCD/************************************************/void int2bcd(int valor) { h_digit = (int) valor / 100; // 1er Dígito o Centenas valor -= h_digit * 100; // y se lo resto al valor m_digit = (int) valor / 10; // 2do Dígito o Decenas valor -= m_digit * 10; // y también se lo resto l_digit = valor; // y por último solo me quedan las unidades }//******************************************************************************
65
CAPITULO X
66
I. LISTA DE COMPONENTES COSTOS
1 PIC 16F873A…………………………………………….. S/.18.00
8 CD4094…………………………………………………… S/.10.00
8 transistores PNP TIP 42C………………………………. S/.4.00
64 resistencias de 220 ohms………………………………S/.3.60
3 resistencias de 10 k……………………………………… S/.0.20
1 porta fusible y fusible de 1 A……………………………. S/.1.00
1 transformador de 220V a 6V, 1 A………………………..S/.8.00
1 puente de diodos de 1 A…………………………………. S/.1.00
1 regulador LM7805………………………………………….S/.1.20
2 capacitores cerámicos de 100 Nf………………………...S/.0.50
2 capacitores cerámicos de 27 Pf…………………………..S/.0.50
capacitor electrolítico de 220uF/16V……………………….S/.0.20
1 cristal de 4 MHz…………………………………………….S/.2.00
512 leds rojos de 3mm……………………………………….S/.5.20
3 pulsadores digitales NA…………………………………… S/.1.50
67
II. CRONOGRAMA DE ACTIVIDADES
ACTIVIDADESMESES
MARZO ABRIL MAYO JUNIOSEMANAS SEMANAS SEMANAS SEMANAS
ETAPA 1
Decisión sobre el proyecto
Entrega de carta
Recopilación de información
ETAPA 2
Organización del trabajo
Presupuestos
Elaboración de planos
ETAPA 3
Calificación y visto bueno
Presentación del proyecto
III. CONCLUSIONES:
Con este proyecto tratamos de mejorar las señalizaciones de la empresa
con estos paneles digitales a fin de que las personas se puedan ubicar
mejor y mas rápidamente.
Este proyecto no solo se puede visualizar la palabra “EMERGENCIA” sino
que también podemos programarla con cualquier área del hospital y a la vez
servirá para poder observar la hora ya que en un hospital es muy importante
los horarios de atención, visitas, etc.
Como el panel esta hecho a base de diodos leds se obtendrá una mejor
visualización desde lugares mas alejados cosa la cual no obtenemos de un
cartel normal.
IV. WEBGRAFIA:
www.ucontrol.com
www.wikipedia.com
www.forosdeelectronica.com
www.neoteo.com
www.rincondelvago.com
www.monografias.com