Reloj

Proyecto de D.A.S.
Reloj Digital
Rebeca Abejón Arribas

Mª Lourdes Ballestero Frutos
Raquel Ventas Olmedo
0
Proyecto de D.A.S. Reloj Digital
Índice
1. Descripción del proyecto........................................................................................ 2

2. Máquina de estados................................................................................................ 4
2.1. Descripción de las señales............................................................................ 4
2.2. Diagrama de transición de estados del controlador...................................... 5
3. Diseño RT................................................................................................................ 6
3.1. Módulo de la hora.........................................................................................6
3.2. Módulo de la alarma..................................................................................... 7
3.3. Módulo del sonido de la alarma................................................................... 8
3.4. Módulo del cronómetro................................................................................ 9
3.5. Módulo controlador del banco de displays...................................................10
4. Incidencias...............................................................................................................15
APÉNDICE: Código VHDL del circuito.................................................................. 16
1
1. Descripción del proyecto.
Este proyecto consiste en la implementación de un reloj digital similar a los existentes en el

mercado.
El reloj contiene tres botones (modo, set y adjust), los cuales permiten realizar toda la
funcionalidad necesaria.
A continuación haremos una breve descripción del funcionamiento general del sistema:
Al cargar el código en la placa lo primero que hacemos es resetear el programa para que
todos los valores comiencen de cero, y el reloj empiece a contar desde el valor inicial de la hora
(00:00:00).
A partir de este momento podemos empezar a utilizar toda la funcionalidad que ofrecen los
botones.
Estando en este estado, en el que el reloj muestra la hora, pulsando el botón set, podemos
establecer la hora actual, ajustando primero los minutos y posteriormente las horas, mediante el
botón adjust. Una vez establecidos los minutos, pasamos a establecer las horas mediante el
botón set. Cuando hemos fijado el valor deseado volvemos a mostrar la hora actual con el botón
modo.
A partir de este mismo estado podemos visualizar la hora que tiene fijada el reloj para que
suene la alarma en caso de estar activada. Al igual que en el caso anterior podemos cambiar la
hora de la alarma a través del botón set. Este proceso es idéntico al descrito en el apartado
anterior, utilizando los botones adjust (cambiar el valor de los dígitos), set (pasar de minutos a
horas o viceversa) y modo (volver a mostrar la hora fijada para la alarma).
Cuando nos encontramos en este estado, en el que visualizamos la alarma, podemos pasar a
mostrar el valor del cronómetro a través del botón modo. La primera vez que visualizamos el
cronómetro, éste estará parado y con valor cero. El resto de las veces su estado dependerá de el
último uso que se hizo del cronómetro, es decir, si lo dejamos contando o parado en un
determinado instante (puede ser el valor que hubiera contado o puesto a cero).
Cuando el cronómetro está parado, para que empiece a contar utilizamos el botón adjust, de
igual forma si estamos contando podemos parar el cronómetro con este mismo botón. Para
iniciar una nueva cuenta, reseteamos el cronómetro con el botón set.
Podemos abandonar la visualización del cronómetro en cualquiera de sus estados mediante
el botón modo, y volver a mostrar la hora actual.
Cuando se está mostrando la hora actual, podemos activar la alarma, para que suene cuando
la hora actual coincida con la establecida para la alarma, mediante el botón adjust. Como
comprobamos que coincidan las horas y los minutos, la alarma estará sonando durante un
minuto, a no ser que se desactive antes pulsando este mismo botón.
Para representar que la alarma está activa, iluminamos el punto decimal en todas las
posiciones del banco de displays.
2
Una visión general de los módulos que componen nuestro sistema es la siguiente:
Alarma Hora Cronómetro
Controlador
Botones Banco de displays Altavoz
3
2. Máquina de estados.
2.1. Descripción de las señales.
Las señales que utilizaremos en el diseño del diagrama de transición de estados y en el

diseño del controlador son las siguientes:
- set, mod y adj: estas señales se activan cuando se pulsa el botón correspondiente, son
las que producen las transiciones de un estado a otro, de la forma que se ha descrito en
el funcionamiento del sistema.
- modo: esta señal es una salida de Moore del diagrama de estados, y nos indica el
módulo que estamos utlizando. Tanto cuando nos encontramos mostrando la hora, como
estableciendo su valor, la señal modo tendrá el valor “00”. Igualmente para la alarma
tendrá en todo momento el valor “01” y para el cronómetro “10”.
- ponerMin: esta señal es una salida de Moore que se activa cuando estamos fijando el
valor de los minutos de la hora del reloj.
- ponerHora: esta señal es una salida de Moore que se activa cuando estamos fijando el
valor de las horas de la hora del reloj.
- ponerAlarmM: esta señal es una salida de Moore que se activa cuando estamos fijando
el valor de los minutos de la alarma del reloj.
- ponerAlarmH: esta señal es una salida de Moore que se activa cuando estamos fijando
el valor de las horas de la alarma del reloj.
- cuentaCronometro: esta señal es una salida de Moore que se activa cuando el
cronómetro está contando.
- cargaFlagAlarm: esta señal es una salida de Mealy que nos indica si hay que activar o
desactivar la alarma, es decir, si estamos mostrando la hora actual y pulsamos el botón
adjust, tenemos que modificar el estado de la alarma (activa o no), por lo tanto debemos
activar el flag de carga.
- valorFlagAlarm: esta señal es una salida de Mealy que nos indica si la alarma está
activada (en este caso el valor es uno) o no (valor cero). Como hemos mencionado
anteriormente podemos comprobar si la alarma está activada o no mediante el punto
decimal del banco de displays.
- cargaFlagCronometro: esta señal es una salida de Mealy que nos indica si hay que
modificar el valor del estado del cronómetro, es decir, contando o parado.
- valorFlagCronometro: esta señal es una salida de Mealy que nos indica el valor del
estado del cronómetro, si su valor es uno el cronómetro está contando y si es cero el
cronómetro está parado.
- reset: esta señal es una salida de Mealy que se activa cuando ponemos el cronómetro a
cero. Hay que aclarar que esta señal sólo resetea el valor del cronómetro, y es
independiente de la señal rst que resetea todo el sistema.
4
2.2. Diagrama de transición de estados del controlador.
adj / cargaFlagAlarm = 1
valorFlagAlarm = ¬valorFlagAlarm
adj adj
set Poner Hora set Poner Hora

Hora Normal Minutos Horas
modo = “00” modo = “00” modo = “00”

mod ponerMin = 1 set ponerHora = 1
mod
mod
adj
adj
set Poner Alarma set Poner Alarma

Minutos Horas
Mostrar Alarma
ponerAlarmM=1 ponerAlarmH=1
modo = “01” modo = “01” modo = “01”
mod set
mod
mod ∧ ¬valorFlagCronometro
mod ∧ valorFlagCronometro
mod
adj / valorFlagCronometro = 1
Cronómetro cargaFlagCronometro = 1
Parado Cronómetro
Contando
modo = “10” cuentaCronometro=1

adj / valorFlagCronometro = 0 modo = “10”
cargaFlagCronometro = 1
adj/ valorFlagCronometro = 1
set / reset = 1 cargaFlagCronometro = 1
set / reset = 1
Cronómetro a
Cero
mod modo = “10”
mod
5
3. Diseño RT.
3.1. Módulo de la hora
Este módulo se utiliza para generar la hora del reloj. Consiste en varios contadores
encadenados por la señal de fin de cuenta del contador anterior, que se corresponden con los
cuatrocientoavos de segundo (utilizamos un temporizador de 0.0025 segundos para aprovechar
el mismo temporizador en otros módulos), segundos, minutos y horas. La cadena que une estos
contadores se rompe cuando estamos actualizando manualmente la hora del reloj, para esto se
colocará una puerta OR a la entrada de los contadores de las horas y los minutos.
*ponerHora
Contador de Contador de
0a2 0a9
Cont5 Cont4 ponerHora

adj
ContOut53 ContOut43
ContOut50 ContOut40
ContOut52 ContOut42
ContOut51 ContOut41
*ponerMin
Contador de Contador de
0a5 0a9
Cont3 Cont2 ponerMin

adj
ContOut33 ContOut23
ContOut30 ContOut20
ContOut32 ContOut22
ContOut31 ContOut21
Contador de Contador de Contador Mod Temporizador

0a5 0a9 400
A todas las entradas síncronas va la señal clk.
6
3.2. Módulo de la alarma
Este módulo se utiliza para introducir la hora de la alarma del reloj. Consiste en cuatro
contadores encadenados de dos en dos que se corresponden con los minutos y las horas. La
entrada de los contares del dígito menos significativo de las horas y los minutos, valdrá uno en
el caso de que estemos introduciendo las horas o minutos, según el caso, de la alarma y
pulsemos el botón adjust.
Contador de Contador de ponerAlarmH

0a2 0a9 adj
ContAl21 ContAl20
Contador de Contador de ponerAlarmM

0a5 0a9 adj
ContAl11 ContAl10
clk
7
3.3. Módulo del sonido de la alarma
En este módulo se genera el sonido cuando la alarma del reloj tiene que sonar (la hora
de la alarma debe coincidir con la hora actual y la alarma debe estar activada). Para ello se
recibirá como entrada las salidas de los contadores de las horas y minutos respectivos y se
comprobará si son iguales.
El oscilador cuenta el semiperiodo de la nota que vamos a generar. Por otro lado
tenemos dos contadores, uno de segundos y otro de cuartos de segundo. El solapamiento de las
salidas de fin de cuenta nos produce una señal que sonará dos veces durante un segundo y luego
deja pasar otro segundo. La OR de todas estas señales nos da el sonido de la alarma en el
momento adecuado.
Salidas de los contadores Salidas de los contadores

Cont5, Cont4, Cont3 y Cont2 ContAl3, ContAl2, ContAl1 y
de la hora ContAl0 de la alarma
Oscilador T Q
sound
valorFlagAlarm
clk
Contador cuartos de
segundo T Q
Contador de
segundos T Q
8
3.4. Módulo del cronómetro
Este módulo sirve para llevar la cuenta del cronómetro en el cual se mostrará las
centésimas de segundo, los segundos y los minutos. Para ello, enlazaremos varios contadores
que irán contando hasta un número determinado (dependiendo del valor que represente). La
salida de cada contador se enviará al controlador para que la muestre en el banco de displays.
Para que el cronómetro empiece a contar, la señal de CuentaCronómetro debe estar a uno,
así como la salida del temporizador que nos indica que ha transcurrido una centésima de
segundo.
Es importante aclarar que la entrada reset de los contadores viene del controlador y es
distinta del reset general del sistema. Esta entrada es asíncrona y resetea el cronómetro cuando
el usuario pulsa el botón de set (y el reloj se encuentra en cualquiera de los otros dos estados del
cronómetro).
Contador Contador Contador

mod 2 mod 9 mod 5
ContC5 ContC4 ContC3
clk
reset
Contador Contador Contador

mod 9 mod 5 mod 9
ContC2 ContC1 ContC0
CuentaCronómetro
Temporizador
9
3.5. Módulo controlador del banco de displays
ContOut ContAlOut ContCOut
modo
BANCO DE
REGISTROS
sel
CONVERSOR DE
SIETE SEGMENTOS
SieteSegs
Hemos realizado una simplificación para que el diseño se vea más claro. En realidad, las
señales contOut y contCOut están compuestas cada una de seis vectores de cuatro bits cada uno
que se corresponden con cada una de las salidas de los contadores BCD. La salida contAlOut
está compuesta por cuatro vectores también de cuatro bits. Además añadimos a cada señal los
bits que representarán las dos rayas que separan las horas de los minutos o bien aquellos bits
que representan las letras A y L. Es decir, cuando estamos en modo “00” y tenemos que mostrar
la hora, pasamos al multiplexor los ocho bits que componen la hora seguido de “1010” (que se
corresponde según nuestra elección con dos rayas horizontales) y a continuación pasamos los
ocho bits que componen los minutos que también van seguidos de “1010”. Por último los ocho
bits que componen los segundos. En el caso del cronómetro ocurre algo similar solo que
representamos centésimas de segundos, segundos y minutos. Cuando lo que tenemos que
mostrar es la alarma aparecerán las horas y los minutos seguidos de un espacio en blanco y de
las letras A y L (hemos elegido los vectores “1011” y “1100”).
10
La salida del banco de registros son ocho vectores de cuatro bits que van al multiplexor
donde se selecciona una de estas salidas dependiendo del display que se esté refrescando en ese
momento. Por último esta salida pasa al conversor de siete segmentos.
Para producir el efecto del parpadeo de los dígitos cuando estamos poniendo en reloj en hora
o cuando ponemos la alarma pensamos un módulo que, bajo ciertas condiciones, pusiera una
salida cero en el banco de displays en lugar de la salida sieteSegs correspondiente. De este
modo conseguimos que no se muestre nada en ciertas posiciones durante cierto tiempo (hemos
elegido medio segundo) y de esta forma los números parpadeen. El diseño RT es el siguiente:
SalidaInversor
PonerHora
DisplaySelAux(2)
Aux1
DisplaySelAux(1)
PonerHora
DisplaySelAux(2)
DisplaySelAux(1) Aux2
DisplaySelAux(2)
PonerHora
PonerMin
SalidaInversor
Aux3
DisplaySelAux(2)
DisplaySelAux(1)
DisplaySelAux(0)
PonerMin
DisplaySelAux(2)
DisplaySelAux(1)
DisplaySelAux(0)
DisplaySelAux(2)
DisplaySelAux(0)
DisplaySelAux(0)
DisplaySelAux(2)
DisplaySelAux(1) PonerMin
11
La idea que se encuentra detrás de todas estas señales es que tenemos que mostrar la salida
del conversor de siete segmentos en las siguientes ocasiones:
- Cuando no estemos poniendo el reloj en hora.
- Cuando estemos poniendo el reloj en hora pero no toca refrescar los displays
correspondientes a los dígitos de la hora.
- Cuando estemos poniendo el reloj en hora y tengamos que refrescar los displays
correspondientes a los dígitos de la hora y además haya pasado medio segundo.
El último punto surge de la necesidad de que aparezcan los dígitos de la hora cada cierto
tiempo (porque sino no veríamos nada). Lo conseguimos con un contador que cuenta medio
segundo y que va a la entrada de un biestable T (que hemos llamado inversor). De esta forma,
salidaInversor vale uno cada medio segundo y los dígitos correspondientes a la hora aparecen.
Todo esto es aplicable al caso en el que estamos poniendo los minutos. Además es necesario
hacer lo mismo en el caso de que estemos poniendo la alarma, por lo que son necesarias cuatro
señales más:
SalidaInversor
PonerAlarmH
DisplaySelAux(2)
Aux1
DisplaySelAux(1)
PonerAlarmH
DisplaySelAux(2)
DisplaySelAux(2)
PonerAlarmH
SalidaInversor
PonerMin
Aux3
DisplaySelAux(2)
DisplaySelAux(1)
DisplaySelAux(0)
PonerAlarmM
DisplaySelAux(2)
DisplaySelAux(1)
DisplaySelAux(0)
DisplaySelAux(2)
DisplaySelAux(0)
DisplaySelAux(0)
DisplaySelAux(2)
DisplaySelAux(1) PonerAlarmM
12
Al final juntamos todo y nos queda el siguiente diseño para la señal sieteSegs:
Aux1
Aux2
Aux3
Aux4
Modo(1)
Modo(0)
Aux5
Aux6
Aux7
Aux8
Modo(1)
Modo(0)
Modo(1)
Modo(0)
CargaFlagAlarm
ValorFlagAlarm
BANCO DE DISPLAYS
clk
El valor que sale del flag que usamos para saber si la alarma está o no activada va
directamente al decimal point del banco de displays de forma que si la alarma está activada se
iluminará.
13
De esta parte del diseño sólo nos queda el contador de medio segundo y el inversor:
TEMPORIZADOR
CONTADOR DE
0 - 199
INVERSOR
SalidaInversor
El refresco de displays se hace de forma periódica como es habitual con un contador que nos
indica la persistencia.
14
4. Incidencias.
En un principio nuestro diagrama de estados era muy complejo debido a que duplicamos el
número de estados para diferenciar si la alarma estaba activada o no y si el cronómetro estaba
contando o parado. Para simplificar el diagrama de estados introdujimos dos flags, uno para
indicar si la alarma está activa y otro para indicar si el cronómetro está contando o parado. De
esta forma, cargamos los valores de los flags cuando es necesario mediante señales que
obtenemos del controlador y mediante una comprobación del valor del flag podemos averiguar
si la alarma está conectada o si el cronómetro está contando.
Una segunda modificación sobre el diseño inicial fue la de sustituir el banco de pulsadores
que íbamos a utilizar en un principio para implementar el comportamiento de los botones del
reloj, por el teclado PS2. Esto es debido a que tuvimos un pequeño problema que no fuimos
capaces de depurar, el cual consistía en que al activar la alarma los pulsadores dejaban de
comportarse de la forma adecuada.
15
APÉNDICE: Código VHDL del circuito.
- Fichero Hora.vhd:
library IEEE;
use IEEE.std_logic_1164.all;
use IEEE.std_logic_unsigned.all;
entity hora is
port (
clk: in STD_LOGIC;
rst: in STD_LOGIC;
tc: in STD_LOGIC;
PonerHora: in STD_LOGIC;
PonerMin: in STD_LOGIC;
adj: in STD_LOGIC;
ContOut5: out STD_LOGIC_VECTOR (3 downto 0);
ContOut0: out STD_LOGIC_VECTOR (3 downto 0)
);
end hora;
architecture horaArch of hora is
signal tcCuarentavos: std_logic;

signal tcCont0: std_logic;
signal count: std_logic_vector (8 downto 0);
signal count0: std_logic_vector (3 downto 0);
begin
contadorCuarentavos: process (clk, rst, tc, count)

constant timeOut: std_logic_vector (8 DOWNTO 0) := "110010000";
variable finCuenta: std_logic;
begin
if (count=timeOut) then
finCuenta := '1';
else
finCuenta := '0';
end if;
if (rst='0') then
count <= (OTHERS=>'0');
elsif (clk'EVENT AND clk='1') THEN
16
if (finCuenta='1') THEN
else
if (tc = '1') then
count <= count + 1;
end if;
end if;
end if;
tcCuarentavos <= finCuenta;
end process;
cont0: process (clk, rst, tcCuarentavos, count0)

begin
if (count0=timeOut) then
finCuenta := '1';
else
finCuenta := '0';
end if;
if (rst='0') then
count0 <= (OTHERS=>'0');
else
if (tcCuarentavos = '1') then
count0 <= count0 + 1;
end if;
end if;
end if;
tcCont0 <= finCuenta;
end process;
contOut0 <= count0;
cont1: process (clk, rst, tcCont0, count1)

begin
finCuenta := '1';
else
finCuenta := '0';
end if;
if (rst='0') then
else
if (tcCont0 = '1') then
end if;
end if;
17
end if;
end process;
contOut1 <= count1;
cont2: process (clk, rst, tcCont1, count2, adj, ponerMin)

begin
finCuenta := '1';
else
finCuenta := '0';
end if;
if (rst='0') then
else
if ((tcCont1 = '1' and ponerMin = '0') or (adj = '1' and ponerMin = '1')) then
end if;
end if;
end if;
end process;
contOut2 <= count2;
cont3: process (clk, rst, tcCont2, count3)

begin
finCuenta := '1';
else
finCuenta := '0';
end if;
if (rst='0') then
else
end if;
end if;
end if;
end process;
contOut3 <= count3;
18
cont4: process (clk, rst, tcCont3, count4, count5, ponerHora, adj, ponerMin)
begin
finCuenta := '1';
else
finCuenta := '0';
end if;
if (rst='0') then
elsif (count5="0010") and (count4="0100") then
elsif ((tcCont3 = '1' and ponerHora = '0' and ponerMin='0') or
(ponerHora ='1' and adj = '1')) then
end if;
end if;
end process;
contOut4 <= count4;
cont5: process (clk, rst, tcCont4, count5, count4)

begin
if (rst='0') then
if (count4="0100") and (count5="0010") then
elsif (tcCont4 = '1') then
end if;
end if;
end process;
contOut5 <= count5;
end horaArch;
19
- Fichero Alarma.vhd:
library IEEE;
entity alarma is
port (
clk: in STD_LOGIC;
rst: in STD_LOGIC;
ponerAlarmH: in STD_LOGIC;
ponerAlarmM: in STD_LOGIC;
adj: in STD_LOGIC;
ContOutAl3: out STD_LOGIC_VECTOR (3 downto 0);
ContOutAl0: out STD_LOGIC_VECTOR (3 downto 0)
);
end alarma;
architecture alarmaArch of alarma is

begin
contAl0: process (clk, rst, count0, adj, ponerAlarmM)

begin
finCuenta := '1';
else
finCuenta := '0';
end if;
if (rst='0') then
else
if (adj = '1' and ponerAlarmM = '1') then
end if;
end if;
end if;
end process;
contOutAl0 <= count0;
20
contAl1: process (clk, rst, tcCont0, count1)

begin
finCuenta := '1';
else
finCuenta := '0';
end if;
if (rst='0') then
else
end if;
end if;
end if;
end process;
contAl2: process (clk, rst, count2, count3, ponerAlarmH, adj)

begin
finCuenta := '1';
else
finCuenta := '0';
end if;
if (rst='0') then
else
elsif (adj = '1' and ponerAlarmH = '1') then
end if;
end if;
end if;
end process;
contAl3: process (clk, rst, tcCont2, count3, count2)

begin
if (rst='0') then
21

end if;
end if;
end process;
end alarmaArch;
- Fichero Sonido.vhd:
library IEEE;
entity sonido is
port (
clk: in STD_LOGIC;
rst: in STD_LOGIC;
hora5: in STD_LOGIC_VECTOR (3 downto 0);
alarma3: in STD_LOGIC_VECTOR (3 downto 0);
alarmaOn: in STD_LOGIC;
tcTemp: in STD_LOGIC;
sound: out STD_LOGIC
);
end sonido;
architecture sonidoArch of sonido is
signal comparadorOut: std_logic;

signal tc: std_logic;
signal biestableOut: std_logic;
signal biestable2Out: std_logic;
signal biestable3Out: std_logic;
signal salidaComparador: std_logic;
signal tcCuartos: std_logic;
signal tcSegundos: std_logic;
signal periodica: std_logic;
begin
oscilador: process (rst, clk)

constant numCiclos: std_logic_vector(11 downto 0) := "100010111101";
variable cuenta: std_logic_vector (11 downto 0);
22
begin
if (cuenta = numCiclos) then
tc <= '1';
else
tc <= '0';
end if;
if (rst='0') then
cuenta := (others => '0');
elsif (clk'EVENT and clk='1') then
if (tc='0') then
cuenta := cuenta + 1;
else
cuenta := (others => '0');
end if;
end if;
end process oscilador;
biestable: process (rst, clk, tc)

begin
if (rst='0') then
biestableOut <= '1';
if (tc='1') then
biestableOut <= not biestableOut;
end if;
end if;
end process biestable;
salidaComparador <= '0' when (hora5=alarma3 and hora4=alarma2 and hora3=alarma1 and
hora2=alarma0) else '1';
contadorCuartos: process (clk, rst, tcTemp)

variable cuentaCuartos: std_logic_vector (7 DOWNTO 0);
begin
if (cuentaCuartos=timeOut) then
finCuenta := '1';
else
finCuenta := '0';
end if;
if (rst='0') then
cuentaCuartos := (OTHERS=>'0');
elsif (clk'EVENT AND clk='1') then
if (finCuenta='1') then
cuentaCuartos := (OTHERS=>'0');
else
if (tcTemp = '1') then
cuentaCuartos := cuentaCuartos + 1;
end if;
end if;
end if;
tcCuartos <= finCuenta;
end process;
23
contadorSegundos: process (clk, rst, tcTemp)

variable cuentaSegundos: std_logic_vector (8 DOWNTO 0);
begin
if (cuentaSegundos=timeOut) then
finCuenta := '1';
else
finCuenta := '0';
end if;
if (rst='0') then
cuentaSegundos := (OTHERS=>'0');
elsif (clk'EVENT AND clk='1') then
if (finCuenta='1') then
cuentaSegundos := (OTHERS=>'0');
else
if (tcTemp = '1') then
cuentaSegundos := cuentaSegundos + 1;
end if;
end if;
end if;
tcSegundos <= finCuenta;
end process;
biestable2: process (rst, clk, tcCuartos)

begin
if (rst='0') then
biestable2Out <= '1';
if (tcCuartos='1') then
biestable2Out <= not biestable2Out;
end if;
end if;
end process biestable2;
biestable3: process (rst, clk, tcSegundos)

begin
if (rst='0') then
biestable3Out <= '1';
if (tcSegundos='1') then
biestable3Out <= not biestable3Out;
end if;
end if;
end process biestable3;
periodica <= not (biestable2Out and biestable3Out);

sound <= biestableOut or salidaComparador or alarmaOn or periodica;
end sonidoArch;
24
- Fichero Cronometro.vhd:
library IEEE;
entity cronometro is
port (
clk: in STD_LOGIC;
rst: in STD_LOGIC;
reset: in STD_LOGIC;
tc: in STD_LOGIC;
cuentaCronometro: in STD_LOGIC;
ContOutC5: out STD_LOGIC_VECTOR (3 downto 0);
ContOutC0: out STD_LOGIC_VECTOR (3 downto 0)
);
end cronometro;
architecture cronometroArch of cronometro is
signal tcCuartos: std_logic;

signal count: std_logic_vector (2 downto 0);
begin
contadorCuartos: process (clk, rst, tc, count)

begin
if (count=timeOut) then
finCuenta := '1';
else
finCuenta := '0';
end if;
if (rst='0' or reset='1') then
else
25
if (tc = '1') then

count <= count + 1;
end if;
end if;
end if;
tcCuartos <= finCuenta;
end process;
contC0: process (clk, rst, tcCuartos, count0, cuentaCronometro)

begin
finCuenta := '1';
else
finCuenta := '0';
end if;
if (rst='0') then
if (reset = '1') then
elsif (finCuenta='1') THEN
else
if (tcCuartos = '1' and cuentaCronometro = '1') then
end if;
end if;
end if;
end process;
contOutC0 <= count0;
contC1: process (clk, rst, tcCont0, count1)

begin
finCuenta := '1';
else
finCuenta := '0';
end if;
if (rst='0') then
else
end if;
26
end if;
end if;
end process;

begin
finCuenta := '1';
else
finCuenta := '0';
end if;
if (rst='0') then
else
end if;
end if;
end if;
end process;

begin
finCuenta := '1';
else
finCuenta := '0';
end if;
if (rst='0') then
else
end if;
end if;
27
end if;
end process;
contC4: process (clk, rst, tcCont3, count4, count5)

begin
finCuenta := '1';
else
finCuenta := '0';
end if;
if (rst='0') then
end if;
end if;
end process;
contC5: process (clk, rst, tcCont4, count5, count4)

begin
finCuenta := '1';
else
finCuenta := '0';
end if;
if (rst='0') then
end if;
end if;
end process;
end cronometroArch;
28
- Fichero ps2keyboardinterface.vhd:
LIBRARY IEEE;
USE IEEE.std_logic_1164.ALL;
ENTITY ps2KeyboardInterface IS
PORT (
clk: IN std_logic;
rst: IN std_logic;
ps2Clk: IN std_logic;
ps2Data: IN std_logic;
data: OUT std_logic_vector (7 DOWNTO 0);
newData: OUT std_logic;
newDataAck: IN std_logic
);
END ps2KeyboardInterface;
ARCHITECTURE ps2KeyboardInterfaceArch OF ps2KeyboardInterface IS
SIGNAL ldData, validData, lastBitRcv, ps2ClkSync, ps2ClkFallingEdge: std_logic;

SIGNAL ps2DataRegOut: std_logic_vector(10 DOWNTO 0);
SIGNAL goodParity: std_logic;
BEGIN
synchronizer: PROCESS (rst, clk)

VARIABLE aux1: std_logic;
BEGIN
IF (rst='0') THEN
aux1 := '1';
ps2ClkSync <= '1';
ELSIF (clk'EVENT AND clk='1') THEN
ps2ClkSync <= aux1;
aux1 := ps2Clk;
END IF;
END PROCESS synchronizer;
edgeDetector: PROCESS (rst, clk)

VARIABLE aux1, aux2: std_logic;
BEGIN
ps2ClkFallingEdge <= (NOT aux1) AND aux2;
IF (rst='0') THEN
aux1 := '1';
aux2 := '1';
aux2 := aux1;
aux1 := ps2ClkSync;
END IF;
END PROCESS edgeDetector;
ps2DataReg: PROCESS (rst, clk)

BEGIN
IF (rst='0') THEN
ps2DataRegOut <= (OTHERS =>'1');
29
IF (lastBitRcv='1') THEN
ps2DataRegOut <= (OTHERS=>'1');
ELSIF (ps2ClkFallingEdge='1') THEN
ps2DataRegOut <= ps2Data & ps2DataRegOut(10 downto 1);
END IF;
END IF;
END PROCESS ps2DataReg;
oddParityCheker:
goodParity <= ((ps2DataRegOut(9) XOR ps2DataRegOut(8)) XOR

(ps2DataRegOut(7) XOR ps2DataRegOut(6)))
XOR ((ps2DataRegOut(5) XOR ps2DataRegOut(4)) XOR
(ps2DataRegOut(3) XOR ps2DataRegOut(2))) XOR ps2DataRegOut(1);
lastBitRcv <= NOT ps2DataRegOut(0);
validData <= lastBitRcv AND goodParity;
dataReg: PROCESS (rst, clk)

BEGIN
IF (rst='0') THEN
data <= (OTHERS=>'0');
IF (ldData='1') THEN
data <= ps2DataRegOut(8 downto 1);
END IF;
END IF;
END PROCESS dataReg;
controller: PROCESS (validData, rst, clk)

TYPE states IS (waitingData, waitingNewDataAck);
VARIABLE state: states;
BEGIN
ldData <= '0';
newData <= '0';
CASE state IS
WHEN waitingData =>
IF (validData='1') THEN
ldData <= '1';
END IF;
WHEN waitingNewDataAck =>
newData <= '1';
WHEN OTHERS => NULL;
END CASE;
IF (rst='0') THEN
state := waitingData;
CASE state IS
WHEN waitingData =>
IF (validData='1') THEN
state := waitingNewDataAck;
END IF;
WHEN waitingNewDataAck =>
IF (newDataAck='1') THEN
30
state := waitingData;
END IF;
END CASE;
END IF;
END PROCESS controller;
END ps2KeyboardInterfaceArch;
- Fichero Keyboard.vhd:
LIBRARY IEEE;
USE IEEE.std_logic_1164.ALL;
ENTITY keyboard IS
PORT (
rst: IN std_logic;
clk: IN std_logic;
nuevaTecla: OUT std_logic;
dataAux: OUT std_logic_vector(7 DOWNTO 0)
);
END keyboard;
ARCHITECTURE keyboardArch OF keyboard IS
COMPONENT ps2KeyboardInterface
PORT (
clk: IN std_logic;
rst: IN std_logic;
data: OUT std_logic_vector (7 DOWNTO 0);
newData: OUT std_logic;
newDataAck: IN std_logic
);
END COMPONENT;
SIGNAL data: std_logic_vector (7 DOWNTO 0);

SIGNAL newData, newDataAck: std_logic;
BEGIN
ps2Interface: ps2KeyboardInterface
PORT MAP (clk, rst, ps2Clk, ps2Data, data, newData, newDataAck);
controller: PROCESS (rst, clk)

TYPE states IS (waitingNewData, checkF0, waitingNewData2, acknowledgeNewData);
VARIABLE state: states;
BEGIN
nuevaTecla <= '0';
31
IF (state = waitingNewData) THEN

IF (newData = '1') AND ((data (7 downto 4) = "0001" AND data (2 downto 0) = "110")
OR (data (7 downto 4) = "0010" AND (data (2 downto 0) = "110" OR
data(3 downto 0)= "0101")) OR (data (7 downto 4) = "0011" AND
(data (2 downto 0) = "110" OR data(3 downto 0)= "1101"))
data(3 downto 0)= "0101"))) THEN
nuevaTecla <= '1';
END IF;
END IF;
IF (rst='0') THEN
state := waitingNewData;
CASE state IS
WHEN waitingNewData =>
IF (newData = '1') AND ((data (7 downto 4) = "0001" AND data (2 downto 0) = "110")
data(3 downto 0)= "0101")) OR (data (7 downto 4) = "0011"
AND (data (2 downto 0) = "110" OR data(3 downto 0)= "1101"))
OR (data (7 downto 4) = "0100" AND (data (3 downto 0) = "0110"
OR data(3 downto 0)= "0101"))) THEN
state := acknowledgeNewData;
ELSIF (data="11110000") THEN
state := checkF0;
END IF;
WHEN checkF0 =>
IF (newData = '1') THEN
END IF;
WHEN acknowledgeNewData =>
END CASE;
END IF;
END PROCESS;
newDataAck <= newData;

dataAux <= data;
END keyboardArch;
- Fichero Temporizador.vhd:
LIBRARY IEEE;
USE IEEE.std_logic_1164.all;
USE IEEE.std_logic_unsigned.all;
entity Temporizador is
port (
clk: in STD_LOGIC;
rst: in STD_LOGIC;
tc: out STD_LOGIC
);
end Temporizador;
32
architecture TemporizadorArch of Temporizador is
BEGIN
temporizador:PROCESS (clk,rst)
CONSTANT timeOut: std_logic_vector (19 DOWNTO 0) := "00000111101000010010";
VARIABLE count: std_logic_vector (19 DOWNTO 0);
VARIABLE finCuenta: std_logic;
BEGIN
IF (count=timeOut) THEN
finCuenta := '1';
ELSE
finCuenta := '0';
END IF;
IF (rst='0') THEN
count := timeOut;
IF (finCuenta='1') THEN
count := (OTHERS=>'0');
ELSE
count := count + 1;
END IF;
END IF;
tc <= finCuenta;
END PROCESS;
END TemporizadorArch;
- Fichero Relojprincipal.vhd:
library IEEE;
entity relojPrincipal is
port (
rst: in STD_LOGIC;
clk: in STD_LOGIC;
sel: out STD_LOGIC_VECTOR (2 downto 0);
sieteSegs: out STD_LOGIC_VECTOR (6 downto 0);
alarmaOn: out STD_LOGIC;
);
end relojPrincipal;
architecture relojPrincipal_arch of relojPrincipal is

component temporizador
port (
clk: in STD_LOGIC;
rst: in STD_LOGIC;
tc: out STD_LOGIC
);
end component;
33
component hora
port (
clk: in STD_LOGIC;
rst: in STD_LOGIC;
tc: in STD_LOGIC;
PonerHora: in STD_LOGIC;
PonerMin: in STD_LOGIC;
adj: in STD_LOGIC;
ContOut0: out STD_LOGIC_VECTOR (3 downto 0)
);
end component;
component keyboard
port (
rst: IN std_logic;
clk: IN std_logic;
nuevaTecla: OUT std_logic;
dataAux: OUT std_logic_vector(7 DOWNTO 0)
);
end component;
component alarma
port (
clk: in STD_LOGIC;
rst: in STD_LOGIC;
ponerAlarmH: in STD_LOGIC;
ponerAlarmM: in STD_LOGIC;
adj: in STD_LOGIC;
ContOutAl0: out STD_LOGIC_VECTOR (3 downto 0)
);
end component;
component cronometro
port (
clk: in STD_LOGIC;
rst: in STD_LOGIC;
reset: in STD_LOGIC;
tc: in STD_LOGIC;
cuentaCronometro: in STD_LOGIC;
34
ContOutC0: out STD_LOGIC_VECTOR (3 downto 0)

);
end component;
component sonido
port (
clk: in STD_LOGIC;
rst: in STD_LOGIC;
alarmaOn: in STD_LOGIC;
tcTemp: in STD_LOGIC;
);
end component;
TYPE states IS (HoraNormal, PonerHoraMinutos, PonerHoraHoras, MostrarAlarma,

PonerAlarmaMinutos,
PonerAlarmaHoras, CronometroParado, CronometroContando, CronometroACero);
SIGNAL estado: states;
SIGNAL tcAux: std_logic;
SIGNAL tcDoscientosavos: std_logic;
SIGNAL ponerHora: std_logic;
SIGNAL ponerMin: std_logic;
SIGNAL ponerAlarmH: std_logic;
SIGNAL ponerAlarmM: std_logic;
SIGNAL cuentaCronometro: std_logic;
SIGNAL modo: std_logic_vector (1 downto 0);
SIGNAL adjAux: std_logic;
SIGNAL setAux: std_logic;
SIGNAL modAux: std_logic;
SIGNAL contOut5Aux: std_logic_vector (3 downto 0);
SIGNAL contOutAl3Aux: std_logic_vector(3 downto 0);
SIGNAL contOutC5Aux: std_logic_vector (3 downto 0);
SIGNAL displaySelAux: std_logic_vector (2 downto 0);
SIGNAL regOut0: std_logic_vector (3 downto 0);
35

SIGNAL cuenta: std_logic_vector (2 downto 0);
SIGNAL salMux: std_logic_vector (3 downto 0);
SIGNAL sieteSegsAux: std_logic_vector (6 downto 0);
SIGNAL dataAux:std_logic_vector(7 downto 0);
SIGNAL nuevaTeclaAux:std_logic;
SIGNAL salidaInversor:std_logic;
SIGNAL cuenta200:std_logic_vector (7 downto 0);
SIGNAL aux1:std_logic;
SIGNAL valorFlagAlarm:std_logic;
SIGNAL cargaFlagAlarm:std_logic;
SIGNAL valorFlagAlarmNegado:std_logic;
SIGNAL cargaFlagCronometro:std_logic;
SIGNAL valorFlagCronometroIn:std_logic;
SIGNAL valorFlagCronometroOut:std_logic;
SIGNAL resetAux: std_logic;
BEGIN
temp: temporizador PORT MAP (clk, rst, tcAux);

horaC: hora PORT MAP (clk, rst, tcAux, ponerHora, ponerMin, adjAux, contOut5Aux,
contOut4Aux, contOut3Aux, contOut2Aux, contOut1Aux, contOut0Aux);
keyboardC: keyboard PORT MAP (rst, clk, ps2Clk, ps2Data, nuevaTeclaAux, dataAux);
alarmaC: alarma PORT MAP (clk, rst, ponerAlarmH, ponerAlarmM, adjAux, contOutAl3Aux,
contOutAl2Aux, contOutAl1Aux, contOutAl0Aux);
cronometroC: cronometro PORT MAP (clk, rst, resetAux, tcAux, cuentaCronometro,
contOutC5Aux, contOutC4Aux, contOutC3Aux, contOutC2Aux,
contOutC1Aux, contOutC0Aux);
sonidoC: sonido PORT MAP (clk, rst, contOut5Aux, contOut4Aux, contOut3Aux,
contOut2Aux, contOutAl3Aux, contOutAl2Aux, contOutAl1Aux,
contOutAl0Aux, valorFlagAlarmNegado, tcAux, sound);
valorFlagAlarmNegado <= not valorFlagAlarm;
displayCnt: PROCESS (clk,rst,tcAux)

BEGIN
IF (rst='0') THEN
cuenta <= (OTHERS=>'0');
ELSIF(clk'event AND clk='1') THEN
IF (tcAux='1') THEN
cuenta <= cuenta+1;
END IF;
36
END IF;
END PROCESS;
DisplaySelAux <= cuenta;

sel <= DisplaySelAux;
regArray: PROCESS (rst,clk)

BEGIN
IF (rst='0') THEN
regOut0 <= "0000";
regOut1 <= "0000";
regOut2 <= "0000";
regOut3 <= "0000";
regOut4 <= "0000";
regOut5 <= "0000";
regOut6 <= "0000";
regOut7 <= "0000";
ELSIF (clk'event AND clk='1') THEN
CASE modo IS
WHEN "00" =>
regOut0 <= contOut0Aux;
regOut2 <= "1010";
regOut5 <= "1010";
WHEN "01" =>
regOut0 <= "1100"; --mostramos L
regOut1 <= "1011"; --mostramos A
regOut2 <= "1101"; --no mostramos nada
regOut3 <= contOutAl0Aux;
regOut5 <= "1010";
WHEN "10" =>
regOut0 <= contOutC0Aux;
regOut2 <= "1010";
regOut5 <= "1010";
END CASE;
END IF;
END PROCESS;
37
mux:PROCESS (regOut0,regOut1,regOut2,regOut3,regOut4,regOut5,regOut6,regOut7,
displaySelAux)
BEGIN
CASE displaySelAux IS
WHEN "000" => salMux <= regOut0;
END CASE;
END PROCESS;
conv7segs: PROCESS (salMux)

BEGIN
CASE salMux IS
WHEN "0000" => sieteSegsAux <= "0111111";
WHEN OTHERS => sieteSegsAux <= "0000000";
END CASE;
END PROCESS;
contadorDoscientosavos: PROCESS(clk, rst, tcAux)

CONSTANT timeOut: std_logic_vector (7 DOWNTO 0) := "11001000";
VARIABLE finCuenta: std_logic;
BEGIN
IF (cuenta200=timeOut) THEN
finCuenta := '1';
ELSE
finCuenta := '0';
END IF;
IF (rst='0') THEN
cuenta200 <= (OTHERS=>'0');
IF (finCuenta='1') THEN
cuenta200 <= (OTHERS=>'0');
ELSE
IF (tcAux = '1') THEN
cuenta200 <= cuenta200 + 1;
END IF;
38
END IF;
end if;
tcDoscientosavos <= finCuenta;
END PROCESS;
inversor: PROCESS (clk,rst,tcDoscientosavos)

BEGIN
IF (rst='0') THEN
salidaInversor <= '0';
ELSIF (clk'EVENT and clk='1') THEN
IF (tcDoscientosavos = '1') THEN
salidaInversor <= not salidaInversor;
END IF;
END IF;
END PROCESS;
aux1 <= '1' WHEN ponerHora='0' or (displaySelAux(2 downto 1)="11" and (ponerHora='1'
and salidaInversor='1'))
ELSE '0';
aux2 <= '1' WHEN ponerHora='1' and (displaySelAux(2)='0' or
displaySelAux(2 downto 1)="10")
ELSE '0';
aux3 <= '1' WHEN ponerMin='0' or ((displaySelAux="100" or displaySelAux="011") and
(ponerMin='1' and salidaInversor='1'))
ELSE '0';
aux4 <= '1' WHEN ponerMin='1' and (displaySelAux(2 downto 1)="00" or
displaySelAux(1 downto 0)="10" or
(displaySelAux(2)='1' and displaySelAux(0)='1'))
ELSE '0';
aux5 <= '1' WHEN ponerAlarmH='0' or (displaySelAux(2 downto 1)="11" and
(ponerAlarmH='1' and salidaInversor='1'))
ELSE '0';
aux6 <= '1' WHEN ponerAlarmH='1' and (displaySelAux(2)='0' or
displaySelAux(2 downto 1)="10")
ELSE '0';
aux7 <= '1' WHEN ponerAlarmM='0' or ((displaySelAux="100" or displaySelAux="011")
and (ponerAlarmM='1' and salidaInversor='1'))
ELSE '0';
aux8 <= '1' WHEN ponerAlarmM='1' and (displaySelAux(2 downto 1)="00" or
displaySelAux(1 downto 0)="10" or (displaySelAux(2)='1' and
displaySelAux(0)='1'))
ELSE '0';
sieteSegs <= sieteSegsAux WHEN ((aux1='1' or aux2='1') and (aux3='1' or aux4='1') and
modo="00") or ((aux5='1' or aux6='1') and
(aux7='1' or aux8='1') and modo="01") or modo= "10"
ELSE "0000000";
teclaPulsada: PROCESS (nuevaTeclaAux,dataAux,clk,rst)

BEGIN
IF (rst='0') THEN
adjAux <= '0';
setAux <= '0';
modAux <= '0';
39
IF (nuevaTeclaAux='1') THEN
CASE dataAux IS
WHEN "00010110" =>
modAux <='1';
setAux <='0';
adjAux <='0';
WHEN "00011110" =>
setAux <='1';
modAux <= '0';
adjAux <= '0';
WHEN "00100110" =>
adjAux <='1';
modAux <='0';
setAux <='0';
END CASE;
ELSE
setAux <= '0';
modAux <= '0';
adjAux <= '0';
END IF;
END IF;
END PROCESS;
flagAlarm: PROCESS (rst, clk, valorFlagAlarm, cargaFlagAlarm)

BEGIN
IF (rst = '0') THEN
valorFlagAlarm <= '0';
IF (cargaFlagAlarm = '1') THEN
valorFlagAlarm <= not valorFlagAlarm;
END IF;
END IF;
END PROCESS;
alarmaOn <= valorFlagAlarm;
flagCronometro: PROCESS (rst, clk, cargaFlagCronometro, valorFlagCronometroIn)

BEGIN
IF (rst = '0') THEN
valorFlagCronometroOut <= '0';
IF (cargaFlagCronometro = '1') THEN
valorFlagCronometroOut <= valorFlagCronometroIn;
END IF;
END IF;
END PROCESS;
salida: PROCESS (estado, valorFlagCronometroOut, adjAux)

BEGIN
modo <= "00";
PonerMin <= '0';
PonerHora <= '0';
PonerAlarmH <= '0';
PonerAlarmM <= '0';
40
cargaFlagAlarm <= '0';

cargaFlagCronometro <= '0';
cuentaCronometro <= valorFlagCronometroOut;
resetAux <= '0';
valorFlagCronometroIn <= '0';
CASE estado IS
WHEN HoraNormal =>
IF (adjAux='1') THEN
cargaFlagAlarm <= '1';
END IF;
WHEN PonerHoraMinutos =>
PonerMin <= '1';
WHEN PonerHoraHoras =>
PonerHora <= '1';
WHEN MostrarAlarma =>
modo <= "01";
WHEN PonerAlarmaMinutos =>
modo <= "01";
ponerAlarmM <= '1';
WHEN PonerAlarmaHoras =>
modo <= "01";
ponerAlarmH <= '1';
WHEN CronometroParado =>
modo <= "10";
IF (adjAux = '1') THEN
END IF;
WHEN CronometroContando =>
modo <= "10";
IF (adjAux = '1' or setAux = '1') THEN
END IF;
WHEN CronometroACero =>
modo <= "10";
resetAux <= '1';
END IF;
END CASE;
END PROCESS;
siguienteEstado: PROCESS (rst,clk,estado,setAux,modAux,adjAux,valorFlagCronometroOut)

BEGIN
IF (rst = '0') THEN
estado <= HoraNormal;
ELSIF (clk'EVENT and clk ='1') THEN
CASE estado IS
WHEN HoraNormal =>
IF (setAux = '1') THEN
estado <= PonerHoraMinutos;
ELSIF (modAux = '1') THEN
41
estado <= MostrarAlarma;

END IF;
WHEN PonerHoraMinutos =>
estado <= PonerHoraHoras;
END IF;
WHEN PonerHoraHoras =>
estado <= PonerHoraMinutos;
END IF;
WHEN MostrarAlarma =>
estado <= PonerAlarmaMinutos;
IF (valorFlagCronometroOut='0') THEN
estado <= CronometroParado;
ELSE
estado <= CronometroContando;
END IF;
END IF;
WHEN PonerAlarmaMinutos =>
estado <= PonerAlarmaHoras;
estado <= MostrarAlarma;
END IF;
WHEN PonerAlarmaHoras =>
estado <= PonerAlarmaMinutos;
estado <= mostrarAlarma;
END IF;
WHEN CronometroParado =>
ELSIF (setAux = '1') THEN
estado <= CronometroACero;
END IF;
WHEN CronometroContando =>
estado <= CronometroParado;
ELSIF (setAux = '1') THEN
estado <= CronometroACero;
END IF;
WHEN CronometroACero =>
42

END IF;
END CASE;
END IF;
END PROCESS;
END relojPrincipal_arch;
43

Reloj

Cargado por

Copyright:

Formatos disponibles

Reloj

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Reloj

Cargado por

Copyright:

Formatos disponibles

Proyecto de D.A.S.

Rebeca Abejón Arribas

1. Descripción del proyecto........................................................................................ 2

1. Descripción del proyecto.

Este proyecto consiste en la implementación de un reloj digital similar a los existentes en el

Alarma Hora Cronómetro

Botones Banco de displays Altavoz

2.1. Descripción de las señales.

Las señales que utilizaremos en el diseño del diagrama de transición de estados y en el

2.2. Diagrama de transición de estados del controlador.

set Poner Hora set Poner Hora

modo = “00” modo = “00” modo = “00”

set Poner Alarma set Poner Alarma

modo = “10” cuentaCronometro=1

mod modo = “10”

3.1. Módulo de la hora

Cont5 Cont4 ponerHora

Cont3 Cont2 ponerMin

Contador de Contador de Contador Mod Temporizador

A todas las entradas síncronas va la señal clk.

3.2. Módulo de la alarma

Contador de Contador de ponerAlarmH

Contador de Contador de ponerAlarmM

3.3. Módulo del sonido de la alarma

Salidas de los contadores Salidas de los contadores

3.4. Módulo del cronómetro

Contador Contador Contador

Contador Contador Contador

3.5. Módulo controlador del banco de displays

ContOut ContAlOut ContCOut

APÉNDICE: Código VHDL del circuito.

architecture horaArch of hora is

signal tcCuarentavos: std_logic;

contadorCuarentavos: process (clk, rst, tc, count)

cont0: process (clk, rst, tcCuarentavos, count0)

contOut0 <= count0;

cont1: process (clk, rst, tcCont0, count1)

contOut1 <= count1;

cont2: process (clk, rst, tcCont1, count2, adj, ponerMin)

contOut2 <= count2;

cont3: process (clk, rst, tcCont2, count3)

contOut3 <= count3;

contOut4 <= count4;

cont5: process (clk, rst, tcCont4, count5, count4)

contOut5 <= count5;

architecture alarmaArch of alarma is

signal tcCont0: std_logic;

contAl0: process (clk, rst, count0, adj, ponerAlarmM)

contOutAl0 <= count0;

contAl1: process (clk, rst, tcCont0, count1)

contOutAl1 <= count1;

contAl2: process (clk, rst, count2, count3, ponerAlarmH, adj)

contOutAl2 <= count2;

contAl3: process (clk, rst, tcCont2, count3, count2)

count3 <= (OTHERS=>'0');

contOutAl3 <= count3;

architecture sonidoArch of sonido is

signal comparadorOut: std_logic;

oscilador: process (rst, clk)