1

TEMPORIZADOR
- DISPLAY 7 SEGMENT0S
- LCD CON PIC.

Autor:
Miguel ngel Moreno Montaner





Resumen:
En este trabajo se muestra la forma de hacer un temporizador con tecnologa digital
contadores-descontadores, buffers triestado, registros de desplazamientoetc. Y tambin lo
mismo pero con un microcontrolador, en este trabajo se utiliza el PIC16F873A.
En el temporizador podremos introducir la temporizacin con un teclado , la temporizacin
se realiza descontando y cuando llega a cero salta una alarma , con el rel que se activa
cuando salta la alarma podremos conectar o desconectar lo que queramos, tenemos
tambin la opcin de PAUSE-PLAY por si utilizamos el temporizador para alguna cosa que
requiera tener que para el temporizador algn tiempo, tenemos la cuatro displays 7
segmentos y un pulsador con el que podremos seleccionar si queremos que la
temporizacin sea, de minutos-segundos o de horas-minutos.
En el temporizador con LCD no tendremos que seleccionar la temporizacin ya que
directamente temporiza horas-minutos-segundos, los pasos los ir indicando el LCD, como
el temporizador de 7 segmentos tambin ir descontando y se podr hacer pause-play.


2



NDICE:
1- Temporizador display 7 segmentos pg. 4
1.1-Circuito divisor de frecuencia pg. 6
1.2-Antirrebote de teclado de pulsadores pg. 7
1.3-Introduccin del nmero seleccionado pg. 9
1.4-Contadores de dcadas descendente pg. 10
1.5-Deteccion de paso por cero, Pause y Play pg. 11
1.6-Circuito de carga por buffers triestado pg. 12
1.7-Controles pg. 13

2- Temporizador LCD con PIC16F873A pg. 14
2.1- Introduccin de tiempo pg. 15
2.2 Simulacin pg. 17
2.3- Programacin en C con el programa CCS pg. 20

3- Prototipo pg. 36
4- Conclusiones pg. 37
5- Bibliografa pg. 37












3


En este trabajo se muestra la forma de hacer un temporizador con tecnologa digital
contadores-descontadores, buffers triestado, decodificadoresetc. y se muestra tambin la
forma de hacer lo mismo pero con un microcontrolador, el Pic 16F873A programado en C,
pudiendo as aprovechar las libreras que estn disponibles en este lenguaje.
Ambas simulaciones estn llevadas a cabo con el simulador PROTEUS 7 ya que este
programa permite las simulaciones a tiempo real, teniendo a su vez componentes animados,
por este motivo se ha utilizado en este trabajo el PROTEUS 7 ya que de otra manera habra
sido muy difcil poder ver como cambia el display y todo el circuito en su conjunto.
Para el antirrebote de los pulsadores se ha utilizado el ORCAD 16.0 por lo completo que es
su programa PSPICE para visualizar las formas de ondas.

















4


1- Temporizador display 7 segmentos
Introduccin:
El cto esta dividido en 7 partes:

1.1-Circuito Divisor de frecuencia
1.2-Antirrebote del teclado de pulsadores
1.3-Introduccion de nmero seleccionado
1.4-Contadores de dcadas descendentes
1.5-Deteccion de paso por cero, Pause y Play
1.6-Circuito de carga por buffers triestado
1.7-Controles


































5


El circuito divisor de frecuencia tiene una entrada de 32768Hz, esta frecuencia
esta dividida en este circuito pudiendo obtener de esta etapa un pulso cada segundo
o un pulso cada minuto, dependiendo de la seleccin que hayamos hecho por
mediacin de un pulsador.
La temporizacin que queremos introducir la haremos por medio del cto de
Antirrebote del teclado de pulsadores para que cuando apretemos un botn, solo
lo reconozca como un pulso. Para cargar este nmero actuar el cto Introduccin
de nmero seleccionado introduciendo el nmero en el descontador
correspondiente del cto Contadores de dcadas descendentes.
Una vez tengamos el numero cargado pulsaremos play, actuar el cto Deteccin de
paso por cero, Pause y Play y empezar a descontar, cuando el digito de las
decenas de segundos llegue a 0, tendr que precargarse el 5, ya que los 74190 son
contadores-descontadores de dcadas. Al tener que cargar primero el numero,
tambin que tenga en cuenta lo de las decenas de segundo, y que cuando
apretemos clear se borren todos los nmeros ponindose a cero, como o se puede
pecargar todo por la misma lnea, ya que haramos cortocircuito entre las salidas, se
ha tenido que poner buffers triestado haciendo un pequeo bus, este circuito sera el
Circuito de carga por buffers triestado.
La carga de la temporizacin, la visualizacin del display, la seleccin de la
temporizacin, la seleccin de pause-play y de borrado la haremos con el circuito de
Controles, que en realidad es una llamada al resto de los ctos, pero que el autor de
este trabajo ha credo oportuno diferenciarlo, por tener una visualizacin mejor de lo
que en realidad vera el usuario final.


























6

1.1-Circuito divisor de frecuencia

Para obtener la frecuencia de 1Hz se ha recurrido a la tecnologa CMOS, ya que el
CI 4060 es un contador que puede llegar a contar hasta 16384(2
14
). El cristal de
cuarzo utilizado es de 32768Hz, de esta forma a travs del pin 13 del 4060 podemos
obtener dos pulsos cada segundo.
Despus pasa por U24 que es un 74107 que est conectado de forma que de cada
dos pulsos, genera uno, de esta forma ya tenemos el generador de pulsos de 1
segundo. La salida de U24 va a la AND U25:B y tambin a U22, entre U22 y U23
harn un divisor de 60 , para generar un pulso cada minuto, la salida de U23 ir a la
otra AND U25:A.
Mediante seleccin de temporizador , que es otro J-K , el cual por cada vez que
pulsemos el botn de seleccin pondr un uno en la AND que seleccionemos y un
cero en la otra , de esta forma solo dejar pasar los pulsos de 1 segundo, o de 1
minuto , dependiendo del momento que estuviera anteriormente.
Q negada y Q del J-K U24:B alimentan las bases de 2 transistores, de forma que
hacen de interruptores para los leds de indicacin del modo de temporizacin
(HORAS_MINUTOS) (MINUTOS_SEGUNDOS).
























Nota: Como se puede observar el cto con cristal no est conectado, ya que el PROTEUS no
puede simularlo, y si se hace otro circuito oscilador como por ej. Un NE555 utiliza casi al
100% los recursos de la CPU y no funciona correctamente, por eso se ha utilizado el reloj del
propio programa.



7

1.2-Antirrebote de teclado de pulsadores

En este primer ejercicio el teclado no es matricial, ya que resultaba demasiado
engorroso hacerlo de esta manera, hay un antirrebote por cada digito. Al principio el
autor de este trabajo no pensaba introducir una puerta trigger-smith, por lo que el
condensador iba a masa, con el PROTEUS funcionaba correctamente y no marcaba
ningn fallo, cuando se hizo la simulacin con PSPICE haban momentos de
incertidumbre, ya que se descargaba el condensador a masa a travs del pulsador,
en ese momento haba un cero, despus, al soltar el pulsador, el condensador se iba
cargando y cuando pasaba de 0,8V empezaba la incertidumbre hasta los 2,8V.
Al introducir la puerta trigger-smith se acabaron los momentos de incertidumbre, ya
que funciona como muestra la figura.















Como no el PROTEUS no dispona de buffer no inversor trigger-smith, se tuvo que
optar por poner uno inversor y poner el condensador a Vcc.
Los resultados de la simulacin estn abajo, STM1:OUT sera el pulso del botn
cuando lo oprimimos, se pueden observar los rebotes. U1:Y sera la salida del
74133, se puede observar como solo da un pulso. La grafica de abajo sera la carga-
descarga del condensador, con una descarga muy rpida por mediacin de R2 y una
carga mucho ms lenta por mediacin de R1. Esta simulacin es un tanto peculiar,
ya que el archivo del Editor de Estmulos , si est dentro de la carpeta del proyecto,
el Orcad no es capaz de encontrarlo, se puede resolver copindolo y pegndolo
directamente en C: y dndole la nueva direccin como muestra la siguiente figura












8

Time
0s 10ms 20ms 30ms 40ms 50ms 60ms 70ms 80ms 90ms 100ms
V(R2:1) V(R2:2)
0V
1.0V
2.0V
3.0V
4.0V
0s 10ms 20ms 30ms 40ms 50ms 60ms 70ms 80ms 90ms 100ms
U1A:G
U3:Y
U1A
74126
2 3
1
V1
5Vdc
C1
4.7u
R1
1k
R2
20
U2A
74HC14
1 2
U3
74HC133
1
2
3
4
5
6
7
10
11
12
13
14
9
15
0
0
VCC
VCC
VCC
VCC
S1
DSTM1
R
V
V
V
V
V-
V+
CTO DE SIMULACION CON PSPICE
























CTO DE SIMULACION CON PROTEUS.
























9

1.3-Introduccin del nmero seleccionado

Cada vez que pulsemos un botn daremos un pulso a travs de U34 al reloj de U16.
U16 es un contador-descontador, que en esta ocasin funciona como contador por
estar el pin u/d a masa, por cada pulso recibido en clk contar y el dato lo recibe U10
que es un decodificador, por lo que en cada pulso solo estar activa una salida del
decodificador, que ser la que habilite la carga a cada descontador del cto de
CONTADORES DE DECADAS DESCENDENTE. El dato se cargar a travs de los
codificadores de prioridad 74LS147, sirviendo U5 tan solo para el segundo digito
empezando por la derecha (dcadas de segundo) y U6 para el resto.







































10

1.4-Contadores de dcadas descendentes

Esta es la etapa que se encarga de descontar, el pulso de reloj, de 1seg de 1
minuto, entrar por U20 y saldr de RCO al prximo CLK, estn en modo descontar
ya que el pin D/U est a Vcc., las patillas Enable estn todas a masa, excepto la de
U20 que har que cuando est en pause no deje pasar la seal de reloj a los
descontadores, ya que el primer 74190 estar deshabilitado.
La codificacin de los 74190 estar en BCD por lo que los 74LS47 se encargarn de
pasar este dato a la codificacin que necesitan los displays de 7 segmentos, los
74LS47 pueden excitar directamente a los displays. Se han puesto unas puertas Or
en la patillas Bi/RBO de forma que cuando se vaya a pulsar un botn, el dgito que
se vaya a insertar parpadear.





































11

1.5-Deteccion de paso por cero, Pause y Play

Cuando termine la temporizacin ser cuando todos los dgitos estn a cero, lo que
se ha hecho es que se han cogido todos los dgitos de las salida de los 74190 del cto
de CONTADORES DE DECADAS DESCENDENTES y se han llevado a las entradas
de U37 y U35 que son puertas NOR, cuando todo sea cero la AND U25:D tendr dos
unos a sus entradas y sacar un 1 que habilitar el enable para que los
descontadores no sigan descontando y para habilitar la alarma.
Tambin est el cto Pause-play que har que cuando pulsemos paremos la alarma y
paremos el descontador y cuando volvamos a pulsar vuelva a su estado anterior






































12

1.6-Circuito de carga por buffers triestado

Cuando introduzcamos un numero estar habilitado el pause, por lo que U9:A ser la
que decida que es lo que se carga, si el numero o si se hace un borrado general para
volver a introducir un numero. Con U33 y U28 haramos el borrado general, y con
U32 y U27 la carga del nmero.
Como lo lgico es que cuando se quiera introducir un nmero, se borre
automticamente el display y te deje todo a cero para que sea ms visual, para hacer
esto se ha tenido que introducir un generador de 2 pulsos, esto se ha conseguido
utilizando una puerta XOR realimentada con la salida del J-K U9:A, de esta forma
cuando pulsemos el botn clear-carga numero se borrar automticamente el
numero y podremos introducir el numero habiendo apretado solo una vez el
pulsador.
Cuando oprimamos el pulsador pause-play el circuito explicado anteriormente
quedar desactivado por mediacin de los buffers triestado U19:D y U30:A, que
pondrn a estado de alta impedancia a los buffers triestado 74LS373 (U32,U33,U27
y U28). Empezar la temporizacin y solo se cargar en los 74190 del circuito de
contadores de dcadas descendente. Cuando las dcadas de segundo pasen de
cero el 74190 tender a poner un 9, pero como los minutos solo llega a los 59
segundos, tendremos que cargarle un 5 por medio de este circuito.





























13

1.7-CONTROLES

Este es la parte del circuito que ver el usuario.














































14

2- Temporizador con teclado matricial y LCD
con PIC16F873A


INTRODUCCION:


Como se puede ver rpidamente es la disminucin considerable de componentes y
tambin la esttica conseguida al poder integrar un LCD.
El circuito es bsicamente igual al anterior, salvo que en esta ocasin la pantalla te
va diciendo lo que debes de hacer.
Los datos se introducen por el teclado matricial, el botn * ser el que se utilice para
pause-play, el pulsador de reset estar conectado al pin 1 del Pic.
El puerto B se ha usado para el teclado matricial, aprobechando as sus resistencias
de pull-up, y el puerto c para el LCD.

































15

2.1- INTRODUCCION DE TIEMPO


Nada ms oprimamos el pulsador *(PLAY) saldr esta pantalla, si en dcadas de
minutos o dcadas de segundos ponemos mas de 5, directamente nos pondr el 5,
si apretamos # * nos pondr cero.








Una vez seleccionado el nmero a temporizar, nos pide que apretemos play para continuar.

















16

Comienza a temporizar, siempre descontando.








Si apretamos pause podemos parar la temporizacin momentneamente.







Cuando llega al final de la temporizacin nos pide que pulsemos reset para volver a temporizar.











17


2.2 -SIMULACION

Para hacer esta simulacin hemos utilizado como anteriormente el PROTEUS 7,
veamos como es el entorno.
Para acceder a las libreras tendremos que pulsar sobre el icono de la 1 flecha que
es un buffer, para hacer las pistas de conexin pulsaremos el icono de la 2 flecha ,
para introducir GND ,VCC y puertos entradas y salidas pulsaremos el icono de la 3
flecha, para introducir fuentes de DC o AC o pulsos de diversos tipos pulsaremos el
icono de la 4 flecha, para introducir osciloscopios, contadores de tiempo ,
ampermetro voltmetros... pulsaremos la 5 flecha , y para introducir tecto
pulsaremos sobre el icono de la 6 flecha.




































18

Un punto a favor del simulador PROTEUS es el poder incorporar al modelo del PIC
el archivo .hex de la programacin de este. As podremos saber como si hubiramos
montado el circuito realmente, si el circuito funciona.
Para ello seleccionamos el PIC con el botn izq. del ratn y seguidamente le damos
al botn derecho. Seleccionamos Edit Propierties.






















Nos saldr la siguiente pantalla. En Program File seleccionamos el archivo .hex que
hemos generado con el programa que hayamos utilizado para hacer el programa, en
este caso se ha utilizado el programa CCS.




















19


Una vez ya tenemos hecho el circuito y cargado el programa en el Pic, solo nos
queda que apretar el botn de run que esta en la esquina inferior izquierda.




























20


2.3- Programacin en C con el programa CCS

Lo primero que tendremos que hacer es seleccionar el PIC que queremos utilizar, para ello iremos a
OPTIONS / Project Options

























21

En File seleccionaremos el Pic a utilizar.













Y en Include Files la direccin de los archivos de las libreras que queremos utilizar, si modificamos
alguna librera podemos ponerla en la misma carpeta donde guardamos nuestro programa y
modificarla all, y no tendremos que tenerla seleccionada en este apartado, directamente el
programa lo ve. Para ello tendremos que quitar Include Files los Drivers, si no lo hicieramos seguira
cogiendo los drivers de esta carpeta.












22


Quedando de la siguiente forma.












Una hayamos hecho esto es mejor guardar y cerrar el programa, despus lo abriremos desde la
carpeta donde lo hayamos guardado y miraremos si las selecciones que acabamos de hacer estn
grabadas. Para guardar nos iremos al icono de la izquierda superior que es como una carpeta abierta.













23


Cuando ya tengamos nuestro programa, lo compilaremos, si todo est correcto tendr que aparecer
una pantalla como esta.













El cdigo en C del programa sera el siguiente:


/////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
//
// TRABAJO PRACTICO DE DISEO
//
// REALIZADO POR : MIGUEL ANGEL MORENO MONTANER
//
// CURSO 2007-2008
//
// TEMPORIZADOR DE HORAS , MINUTOS , SEGUNDOS


24

// ACTIVADO POR TECLADO MATRICIAL
// CON LCD
//
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
#include<16F873A.h> // incluimos los ficheros del Pic que vamos a usar
#fuses XT,NOWDT,NOPROTECT,NOLVP //XT es el tipo de reloj,NOWDT no perro guardian
#use delay(clock =4000000) // usamos un reloj de 4MHz
#define use_portc_lcd TRUE // Muy importante lcd hay que modificar el fichero
#define use_portb_kbd TRUE // Muy importante teclado
#include <LCDDAVIS.c> // Incluye drivers lcd
#include <kbd.c> // Inluye drivers teclado
#use standard_io(a) // al poner standard si ponemos en el programa

// input o output le asigna directamente si es
//entrada o salida
//**********VARIABLES QUE SE VAN A USAR*******************
int SEGUNDOSd=0;
int MINUTOSd=0;
int HORASd=0;
int SEGUNDOSu=0;
int MINUTOSu=0;
int HORASu=0;
int i=0; //se usa en PARA INRODUCIR DATO A TEMPORIZAR
int cont=0;// variable que se usa para que haga un ciclo de 1seg
int x; // definimos variables x es un numero solo puede tener 2 valores
int v=0;// variable que se usa para hacer el doble pulsado de PAUSE_PLAY
int c=0;// variable que se usa en main para cuando te pide que pulses el play
int k;//variable q se usa para q te de el valor dela tecla pulsada en el teclado
int z=0;//variable que se usa en pulse play para temporizar
int o =0;//variable q se usa en *LO QUE PONE EN EL DISPLAY ABAJO O SEA EL RELOJ*
//*********PULSO DE 1 SEGUNDO *******************


25

temp1s()
{
cont = 0;
output_toggle(PIN_A1);// sacamos 1 pulso de 1seg por el pin A1
SEGUNDOSu--; // conseguimos al pulso de 1 segundo
WHILE (cont < 2)
{
// cuenta hasta 2, as hacemos un pulso cada segundo
set_timer1 (3134); // con el numero modificamos el tiempo,
// bajando el numero sube el tiempo

DO
{
// Hace que por lo menos se ejecute una vez

IF (v == 1)
{
//nada mas empezar no se ejecuta porque v = 0
lcd_putc ('\f'); //Limpio aqui la pantalla porque el printf me borra el gotoxy
lcd_gotoXY (4, 2);
printf (lcd_putc, " PAUSE"); //cuando se aprieta pause se entra en estE IF
WHILE (v == 1)
{
//No sirve mas que para que el "PAUSE"no parpadee
k = kbd_getc () ;

IF (k != 0)
{
// si se pulsa una tecla
IF (k == 35)
{
// y resulta que es #
v = 0; // V a cero y no se repite el bucle sale de PAUSE


26

o = 0; // se pne o cero, de esta forma al finalizar el pause,
} // se vuelve a escribir temporizacin en el lcd
}
}
}


ELSE
{
// si est temporizando
k = kbd_getc () ;

IF (k != 0)
{
// y se pulsa una tecla del teclado
IF (k == 35)
{
// y resulta que es #
v = 1; // pone v a uno para que entre en el IF de arriba
}

ELSE // si resulta que se a tocado cualquier otra tecla
v = 0; // no hace nada
}
}
}


WHILE (get_timer1 () >= 3134); // mientras el TIMER1 es mayor que 3370 ejecuta
cont++; // el do cuando da la vuelta finaliza el WHILE y suma uno a cont

}
}


27



//*****************************************************
//**********EMPEZAMOS EL PROGRAMA**********************
//*****************************************************
void main()
{
//empezamos el programa
// *INICIALIZACION*
INT dato[6]; // matriz de 6
CHAR k; // variable del taclado, es char porque usaremos tambin * y #
lcd_init(); // inicializamos el lcd
kbd_init(); // inicializamos el teclado
port_b_pullups(TRUE); // Activamos los pullups del puerto b
setup_adc(ADC_OFF); //Dejo todo el puerto A como digital.Desactivo los AD
setup_adc_ports(NO_ANALOGS); //Dejo el puerto A como digital. Desactivo la posibilidad de que sea analgico.
setup_timer_1(T1_internal|T1_DIV_BY_8);// divide el reloj entre 8
// esto es lo del pulso tambin
// *COMIENZO DEL BUCLE*
SEGUNDOSu=0;
x=0; // esta variable no es nada , solo sirve para hacer un divisor por 2,para que corra el programa 2 veces
WHILE (1)
{
//BUCLE INFINITO
//**** LE DECIMOS COMO TIENE QUE CONTAR****
IF (SEGUNDOSu == 255)
{
//cuenta los segundos
SEGUNDOSu = 9; //cuenta los minutos
SEGUNDOSd--; //pone a cero los segundos
}

IF (SEGUNDOSd == 255)


28

{
//cuenta los segundos
MINUTOSu--; //cuenta los minutos
SEGUNDOSd = 5; //pone a cero los segundos
}

IF (MINUTOSu == 255)
{
//cuenta los minutos
MINUTOSu = 9; //cuenta los minutos
MINUTOSd--; //pone a cero los segundos
}

IF (MINUTOSd == 255)
{
//cuenta los minutos
HORASu--; //cuenta los minutos
MINUTOSd = 5; //pone a cero los segundos
}

IF (HORASu == 255)
{
//cuenta las horas
HORASu = 9; //cuenta los minutos
HORASd--; //pone a cero los segundos
}

IF (HORASd == 255)
{
//cuenta las horas
HORASd = 0;
}



29

IF (z < 1)
{
// este IF solo sirve para que no parpadeen los letreros
lcd_gotoXY (4, 1) ;
printf(lcd_putc" TEMPORIZADOR \n" );
lcd_gotoXY (2, 2) ;
printf(lcd_putc"M.A.MORENO MONTANER\n" );
lcd_gotoXY (4, 3) ;
printf(lcd_putc"PULSA PLAY PARA \n" );
lcd_gotoXY(2,4);
printf(lcd_putc" INTRODUCIR DATOS \n" );

WHILE (z < 1)
{
//esto hace que se espere hasta que apretamos el # para play
k = kbd_getc () ;

IF (k != 0)
{
IF (k == 35)
{
z++;
}

}
}


//***PARA INTRODUCIR DATO A TEMPORIZAR*****
k = kbd_getc () ;

IF (i < 6)
{


30

lcd_gotoXY (4, 1) ;
printf (lcd_putc, "\f INTRODUCE TIEMPO\n");
lcd_gotoXY (4, 2) ;
printf (lcd_putc, " HH:MM:SS\n");
}

WHILE (i < 6)
{
k = kbd_getc ();
x = k - 48; //Conversin numrica
lcd_gotoXY (4, 3) ;

IF (k != 0)
{
SWITCH (i)
{

CASE 0:
lcd_gotoxy (7, 3); // Pone en display Horas unidades
IF (k < 48)
{
// este IF es para que si aprietas el * o el # cuando
x = 0; // te pide la temporizacin no salga el 250 o 243
}

printf (lcd_putc" % u"x);
dato[0] = x;
BREAK;

CASE 1: // Pone en display Horas decenas
lcd_gotoxy (8, 3) ;

IF (k < 48)


31

{
// este IF es para que si aprietas el * o el # cuando
x = 0; // te pide la temporizacin no salga el 250 o 243
}

printf (lcd_putc" % u"x) ;
dato[1] = x;
BREAK;

CASE 2: // Pone en display Minutos unidades
lcd_gotoxy (9, 3) ;

IF (x > 5)
{
// con este IF hacemos que para las decenas de minuto
x = 5; // si se aprieta mas de 5 directamente ponga 5
}

IF (k < 48)
{
x = 0;
}

printf (lcd_putc": % u"x) ;
dato[2] = x;
BREAK;

CASE 3: // Pone en display Minutos decenas
lcd_gotoxy (11, 3);

IF (k < 48)
{
// este IF es para que si aprietas el * o el # cuando


32

x = 0; // te pide la temporizacin no salga el 250 o 243
}

printf (lcd_putc" % u"x) ;
dato[3] = x;
BREAK;

CASE 4: // Pone en display segundos unidades
lcd_gotoxy (12, 3) ;

IF (x > 5)
{
// con este IF hacemos que para las decenas de minuto
x = 5; // si se aprieta mas de 5 directamente ponga 5
}

IF (k < 48)
{
x = 0;
}

printf (lcd_putc": % u"x) ;
dato[4] = x;
BREAK;

CASE 5: // Pone en display segundos decenas
lcd_gotoxy (14, 3) ;

IF (k < 48)
{
// este IF es para que si aprietas el * o el # cuando
x = 0; // te pide la temporizacion no salga el 250 o 243
}


33


printf (lcd_putc" % u"x) ;
dato[5] = x;
BREAK;
}

i++;
}

//******ASIGNAMOS VARIABLES A POSICIONES DE MATRIZ******
HORASd = dato[0];
HORASu = dato[1];
MINUTOSd = dato[2];
MINUTOSu = dato[3];
SEGUNDOSd = dato[4];
SEGUNDOSu = dato[5];
}

lcd_putc('\f');// borramos la pantalla
}

IF (c < 1)
{
// este IF sirve para que una vez te pida el play por primera vez, no se
// ejecute ms lo de abajo.
//******DEJAMOS EN LA PANTALLA FIJO PULSE PLAY Y LA HORA
lcd_gotoXY(1,1);
printf(lcd_putc" PULSE PLAY PARA" );
lcd_gotoXY(1,2);
printf(lcd_putc"EMPEZAR A TEMPORIZAR" );
lcd_gotoXY(7,3);// Hace que salga en la 2 fila (X,Y) 5 linea
printf(lcd_putc"%01u"HORASd ); // escribe en pantalla las horas,minutos y seg
printf(lcd_putc"%01u"HORASu); // lo mismo que abajo en temporizacion


34

printf(lcd_putc":%01u"MINUTOSd );// solo que de esta forma paramos el programa
printf(lcd_putc"%01u"MINUTOSu);// hasta apretar play y se pueden ver los valores
printf(lcd_putc,":%01u",SEGUNDOSd );// que hemos seleccionado
printf(lcd_putc,"%01u",SEGUNDOSu );
}

//*****ENTRAMOS EN BUCLE HASTA OPRIMIR # PARA PLAY
WHILE (c < 1)
{
//esto hace que se espere hasta que apretamos el # para play
k = kbd_getc (); // llama a la funcion de teclado
IF (k != 0)
{
// si se oprime alguna tecla
IF (k == 35)
{
// y resulta que es #
c++; // suma 1 a c, o sea c = 1, por lo que sale del bucle
} // y no se repita, ya que se queda para siempre c = 1
} // a no ser que le demos al reset.
}

// * LO QUE PONE EN EL DISPLAY ABAJO O SEA EL RELOJ *
IF (o < 1)
{
lcd_putc ('\f'); //Limpio aqui la pantalla porque el printf me borra el gotoxy
lcd_gotoXY (4, 2); // este IF es para que escriba la primera vez el printf y se quede
printf (lcd_putc" TEMPORIZANDO"); //grabado en ellcd, de esta forma no habran
} // parpadeos, ya que como tiene que limpiar la pantalla, cada ciclo lo

o++; //borraria y volveria a escribir lo mismo.La primera vez o = 0 pero al correr
// el programa le hacemos que la segunda vez valga 1, la tercera vez 2
// y asi asi


35

lcd_gotoXY(7,3);// Hace que salga en la 2 fila (X,Y) 5 linea
printf(lcd_putc"%01u"HORASd );// escribimos en pantalla las horas
printf(lcd_putc"%01u"HORASu);
printf(lcd_putc":%01u"MINUTOSd );// minutos
printf(lcd_putc"%01u"MINUTOSu);
printf(lcd_putc,":%01u",SEGUNDOSd );//segundos
printf(lcd_putc,"%01u",SEGUNDOSu );

///////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////
// //
// SALTO DE LA ALARMA //
// //
//////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////
IF ( (HORASd|HORASu|MINUTOSd|MINUTOSu|SEGUNDOSd|SEGUNDOSd|SEGUNDOSu) == 0)
{
lcd_putc('\f');//Limpio aqui la pantalla porque el printf me borra el gotoxy
lcd_gotoXY(4,1);
printf(lcd_putc" TEMPORIZACION \n" );// estp "|" es una or, entonces si la suma
lcd_gotoXY(4,2);
printf(lcd_putc" FINALIZADA \n" );
lcd_gotoXY(4,4);
printf(lcd_putc" PULSE RESET \n" );// de todos los digitos es igual a cero
output_high(PIN_A5);//pone en alto el pin A5 y escribe una sola vez Alarma conectada
WHILE (1)
{
// de esta forma no har parpadeos y entrar en el bucle infinito
} // para siempre, la unica forma de salir de aqui es haciendo un reset.
}

ELSE
{


36

// si la suma de todos no es cero se ejecuta con normalidad la temporizacion
temp1s();// LLAMANDO A LA FUNCION DE TEMPORIZACION temp1s()
}
}
}
En el programa se ha tenido que modificar la librera del LCD ya que estaba hecha para el puerto B
D, tambien se ha modificado porque el LCD que se ha utilizado DV20400 no es igual que el estndar
que tiene el CCS LCD420, nuestro archivo le hemos puesto el nombre LCDDAVIS y se incluye al
principio del programa. En la opinin del autor de este trabajo est bastante claro el programa, ya
que tiene bastantes anotaciones, por lo que no se explicar.

3-Prototipo
Este es el aspecto del prototipo, el teclado matricial es de 4*4 quedando inutilizada la
columna de la derecha, la alimentacin es a 5vdc y se ha utilizado un DC-DC de
entrada 6v a16v y salida a 5v, tiene un rendimiento del 95% por lo que
aprovechamos mejor la batera que si lo hubiramos hecho con un regulador de
tensin lineal tipo 7805, el cual disipara la diferencial de potencial por la intensidad
que pasa por l. De esta forma le damos ms autnoma al circuito.

















37










4-Conclusiones
Las conclusiones de estas simulaciones son que el programa PROTEUSS tiene una
gran potencia a la hora de poder ver grandes diseos en su conjunto, pudiendo tambien
incorporar al diseo PICs. Es realmente sencillo poder depurar los programas en C con
este programa ya que cada cambio importante lo puedes compilar y ver lo que sucede
con el simulador.
El programa ORCAD PSPICE es muy potente por sus algoritmos matemticos y se
pueden simular partes del circuito por separado, e incluso generar pulsos como el
usuario quiera con el STIMULUS EDITOR del programa, teniendo este programa un
potente visualizador de ondas para ello.

5- Bibliografa

-Circuitos integrales digitales parte 1 Editorial : PARANINFO
-Circuitos integrales digitales parte 2 Editorial : PARANINFO
-Compilador C CCS y Simulador
PROTEUS para Microcontroladores PIC Editorial : MARCOMBO S.A



- Microcontroladores Pic (la clave del diseo) Editorial: THOMSON