DEPARTAMENTO DE ENGENHARIA DE CONTROLE E AUTOMAÇÃO

CURSO DE ENGENHARIA DE CONTROLE E AUTOMAÇÃO E

TELECOMUNICAÇÕES

PROJETO LABORATÓRIO DE SISTEMAS DIGITAIS

MARCOS FELIPE SOARES SANTOS

HARRY ANDERSON ANDRADE SANTOS
HERICLES FREIRE SOARES
ENGENHARIA DE CONTROLE E AUTOMAÇÃO E TELECOMUNIÇÃO

MONTES CLAROS, 14 DE DEZEMBRO DE 2019.

1
SUMÁRIO
PROJETO LABORATÓRIO DE SISTEMAS DIGITAIS ............................................................................................... 1
INTRODUÇÃO ................................................................................................................................................................ 3
OBJETIVO ....................................................................................................................................................................... 3
DESENVOLVIMENTO ................................................................................................................................................... 3
CÓDIGO ....................................................................................................................................................................... 6
CONCLUSÃO ................................................................................................................................................................ 12
ANEXO........................................................................................................................................................................... 13
REFERÊNCIAS .............................................................................................................................................................. 20

2
INTRODUÇÃO

O relógio ao longo dos anos evoluiu muito e passou por varias transformações desde o primeiro relógio
criado até os conhecidos relógios digitais que hoje em dia pode ser encontrado com frequência em vários
lugares.

OBJETIVO

O trabalho tem como objetivo apresentar um relógio digital utilizando a linguagem VHDL.

O relógio deve ser 24 horas, contem ajuste de horas e alarmes programáveis em quatro horários diferentes.
Deve conter também periféricos de entradas, botões ou chaves.

DESENVOLVIMENTO

Para realizar o desenvolvimento do trabalho, utilizamos KIT FPGA.

O Kit Didático com FPGA ALTERA DE2-115, produzido pela Terasic Technologies, permite o aprendizado
e o desenvolvimento de sistemas digitais baseados em lógica programável.

Com um dispositivo FPGA de alta capacidade, o kit possibilita a implementação de sistemas complexos em
um único chip, substituindo hardwares de alto custo. O kit possui ainda dispositivos periféricos na mesma
placa, conectados diretamente ao FPGA, auxiliando em projetos que envolvem sinais de áudio, visualização
em display ou vídeo, e comunicação via serial, USB ou Ethernet.

3
Principais características

 FPGA Altera Cyclone IV 4CE115.

 Memória de configuração Altera EPCS64.
 Interface de programação USB-Blaster.
 Memórias: SRAM 2MB, SDRAM 128MB, FLASH 8MB, EEPROM 32Kbit.
 Conector para cartão SD Card.
 Interruptores: 4 push-buttons e 18 chaves.
 18 LEDs vermelhos e 9 LEDs verdes.
 8 Displays de 7 segmentos.
 Display LCD 16x2.
 Oscilador de 50MHz para clock.
 Codec de áudio de 24 bits
 Principais características
 DAC VGA de 8 bits.
 Decodificador de TV.
 2 Interfaces de rede Gigabit Ethernet.
 Interface USB Host/Slave.
 Interface serial RS-232.
 Porta para mouse e teclado padrão PS/2.
 Receptor infravermelho.
 2 conectores SMA para entrada/saída de clock externo.
 Conector de expansão de 40 pinos.
 Conector HSMC para expansão via placas de expansão.

4
Para que possamos realizar a programação utilizamos o software QUARTUS, que oferece vários recursos e
dentre delas, a linguagem VHDL que foi utilizada para a realização do projeto.

5
A linguagem VHDL é uma linguagem usada para facilitar o design (projeto/concepção) de circuitos digitais
em CPLDs, FPGAs e ASICs.

CÓDIGO

Podemos dividir a realização do código em quatro partes, a primeira dela, o gerador de clock a segunda são a
contagem e ajuste, terceira a realização do decodificador e a quarta o alarme.

O código possui uma frequência de 1Hz, que representa um 1s. O código a seguir mostra o gerador de clock,
para ser utilizado na placa:

6
Caso queira aumentar o clock, pegamos a frequência total que vale 50MHz, dividimos pela frequência
desejada e por fim por dois.

Mas antes de configurar o clock, configuramos o que podíamos utilizar como saída e entrada.

Nesta parte configuramos os o clock, as chaves de enable, clear e ajustes como entrada e os segmentos do
decodificador como saídas junto com led de alarme.

Declaramos seis clocks com signal e seis contadores como signal todos com range de 0 a 9. Declaremos seis
clocks, pois realizamos um contador assíncrono, onde o próximo contador recebe o clock do contador
anterior.

O que representa bit, podemos dizer que vai ter nível lógico 0 ou 1.

7
Para realizar a contagem utilizamos os seguinte trecho de código:

Podemos observar que colocamos um clear assíncrono, ou seja, um clear fora do clock. O clear funciona da
seguinte maneira, ao colocar a chave configurada em nível alto, os contadores são zerados.

O contador só realiza a contagem caso o enable seja ativado, caso o enable esteja ativado, ocorre uma borda
de subida e contador da unidade de segundos é incrementado se o contador atingir o numero 10 ele e zerado
e o clock2 recebe nível lógico um, realizando a contagem do contador seguinte, que no caso será a de dezena
de segundos.

A lógica permanece a mesma para todos os contadores. O que mudará será o critério do contador ser zerado.
Em unidade dezena de segundo, minuto, os contadores são zerados ao atingir o numero 6. A dezena de
horas, realizamos uma lógica diferente, visto que o relógio tem que ser zerado em 23:59:59.

Para que isso ocorra, utilizamos o seguinte trecho de código:

Podemos observar que tivemos que garantir que o contador cinco chegue em 9, mas também criamos uma
condição que quando o contador cinco for 4 e o contador seis for 2, que no caso forma o numero 24, será
zerado nas duas situações.

8
Para que possamos ajustar o relógio, utilizamos o seguinte trecho de código:

O seguinte trecho representa a lógica utilizada para ser realizado o ajuste do relógio.

Para criar essa lógica, tivemos que criar uma lista de 0 a 15 configurada como entrada, utilizamos esse
numero, pois os números 8 e 9 possuem 4 dígitos em binário.

Para realizar o ajuste de horas colocamos o enable em nível lógico baixo, pois não realiza a configuração
com o relógio em andamento.

Após isso, configuramos as chaves no numero em binário que queremos ajustar as horas. Logo em seguida
pressionamos o botão em que o digito feito dever ser entrado, ou seja, na unidade e dezena de minutos,
unidade e dezena de horas.

Tivemos que garantir que não fosse feito nenhuma configuração anormal para um relógio, por exemplo:
Colocar número acima de nove em unidade de minutos.

Tivemos então que colocar uma condição que caso o numero feito nas chaves for maior que nove ou seis ou
dois o contador será zerado.

9
Para que os números possam parecer no display, utilizamos o seguinte trecho de código:

Passamos como parâmetro o contador a ser utilizado, no exemplo acima passamos como parâmetro o
contador um.

O trecho acima e um decodificador anôdo comum, ou seja, ativo em nível baixo.

Podemos observar que dentro do case, temos os números de 0 a 9, visto que é o contador de unidade de
segundos.

Cada combinação forma o número em nível baixo e em nível alto o display e apagado.

E por fim, realizamos o seguinte código para o alarme:

10
Configuramos as seguintes horas como alarme: 13:01, 21:10 e 09:01.

Caso os contadores seis, cinco quatro e três, chegarem em um, três, zero e um, formando o primeiro alarme,
o led configurado como alarme será ativado.

Mas antes disso, tivemos que garantir que o led fosse zero, e quando entrar na condição será ativado.

O led do alarme fica ativo por um minuto, porque não configuramos segundos.

11
CONCLUSÃO

O trabalho possibilitou um maior conhecimento sobre o kit FPGA e a linguagem VHDL, visto que
conseguimos realizar a montagem do relógio 24 horas proposto.

De modo geral, os resultados foram satisfatórios. Onde podemos ver que o relógio realiza suas principais
características, ajuste e um alarme programado no código.

Tivemos dificuldades em realizar o ajuste do relógio, onde queríamos utilizar um push Button para realizar a
passagem de horas, porém ao ser pressionado no display apareciam números aleatórios ou combinações que
não existem no display.

O software QUARTUS II e o trabalho em grupo possibilitaram para que realizassem este trabalho.

Contudo, utilizando os conhecimentos adquiridos durante a disciplina, nas realizações das praticas, puderam
contribuir para a realização do projeto.

12
ANEXO

entity relogio_marilio is
port(clock_50MHz :in bit;
clear, enable,ajuste1,ajuste2,ajuste3,ajuste4 :in bit;
a,b,c,d,e,f,g :out bit;
a1,b1,c1,d1,e1,f1,g1 :out bit;
a2,b2,c2,d2,e2,f2,g2 :out bit;
a3,b3,c3,d3,e3,f3,g3 :out bit;
a4,b4,c4,d4,e4,f4,g4 :out bit;
a5,b5,c5,d5,e5,f5,g5 :out bit;
ajustes :in integer range 0 TO 15;
led_alamer :out bit
);

end relogio_marilio;

architecture relogio of relogio_marilio is

signal clock_1:bit;
signal clock_2:bit;
signal clock_3:bit;
signal clock_4:bit;
signal clock_5:bit;
signal clock_6:bit;

--signal comparador:integer;

signal count1 :integer range 0 to 9;

signal count2 :integer range 0 to 9;
signal count3 :integer range 0 to 9;
signal count4 :integer range 0 to 9;
signal count5 :integer range 0 to 9;
signal count6 :integer range 0 to 9;

begin
---------------------------GERADOR DE CLOCK------------------------------------------------------------

divisor: PROCESS(clock_50MHz)
VARIABLE k: INTEGER RANGE 0 TO 50000000;
BEGIN
IF (clock_50MHz = '1' AND clock_50MHz'EVENT) THEN
IF k > 25000000 THEN
clock_1 <= '1';
k := k + 1;
IF k = 50000000 THEN
k := 0;
END IF;

13
 ELSE
k := k + 1;
clock_1 <= '0';
END IF;
END IF;
END PROCESS divisor;
-----------------------------segundos1--------------------------------------------------------------
segundos1:process(clock_1,clear,enable,clock_2,clock_3,clock_4,clock_5,clock_6)
begin
led_alamer <= '0';
if(clear = '1') then
count1<=0;
count2<=0;
count3<=0;
count4<=0;
count5<=0;
count6<=0;
else
--#########################################---
if(enable = '1')then
-----ENABLE ATIVO--------
------segundos1-----------
if(clock_1'event and clock_1 = '1') then
count1<=count1+1;
clock_2<='0';
end if;
if(count1 = 10) then
count1 <= 0;
clock_2 <='1';
end if;
------segundos1 fim-----------
------segundos2-----------
if(clock_2'event and clock_2 = '1') then
count2<=count2 + 1;
clock_3<='0';
end if;
if(count2 = 6) then
count2 <= 0;
clock_3 <='1';
end if;
------segundos2 fim-----------
------minutos1-----------
if(clock_3'event and clock_3 = '1') then
count3<=count3 + 1;
clock_4<='0';
end if;
if(count3 = 10) then
count3 <= 0;
clock_4 <='1';
end if;

14
------minutos1 fim-----------
------minutos2 -----------
if(clock_4'event and clock_4 = '1') then
count4<=count4 + 1;
clock_5<='0';
end if;
if(count4 = 6) then
count4 <= 0;
clock_5 <='1';
end if;
------minutos2 fim-----------
------horas1-----------
if(clock_5'event and clock_5 = '1') then
count5<=count5 + 1;
clock_6<='0';
end if;
if(count5 = 10) or (count5 = 4 and count6 = 2)then
count5<=0;
clock_6<='1';
end if;
------horas1 fim-----------
------horas2-----------
if(clock_6'event and clock_6 = '1') then
count6<=count6 + 1;
end if;
if(count6 = 3)then
count6<=0;
end if;

------horas2 fim-----------

------------- ALARME -------------------------

if(count6 = 1 and count5 = 3 and count4 = 0 and count3 = 1) then

led_alamer <= '1';
end if;
if(count6 = 2 and count5 = 1 and count4 = 1 and count3 = 0) then
led_alamer <= '1';
end if;
if(count6 = 0 and count5 = 9 and count4 = 0 and count3 = 1) then
led_alamer <= '1';
end if;

------------FIM ALARME -----------------

-----ENABLE ATIVO FIM--------

else

15
 -----ENABLE zero--------
---min1
if(ajuste1 = '0') then
if(ajustes > 9) then
count3<=0;
else
count3<=ajustes;
end if;
end if;
if(ajuste2 = '0') then
if(ajustes > 5) then
count4<=0;
else
count4<=ajustes;
end if;
end if;
if(ajuste3 = '0') then
if(ajustes > 9 ) OR (ajustes>4 and count6 =2) then
count5<=0;
else
count5<=ajustes;
end if;
end if;
if(ajuste4 = '0') then
if(ajustes > 2) then
count6<=0;
else
count6<=ajustes;
end if;
end if;
-----ENABLE zero FIM--------
end if;
--#################################################################
end if;

end process segundos1;

decodificador1:process(count1)
variable segments:bit_vector(0 to 6);
begin
case count1 is
when 0 => segments:= "0000001";
when 1 => segments:= "1001111";
when 2 => segments:= "0010010";
when 3 => segments:= "0000110";
when 4 => segments:= "1001100";
when 5 => segments:= "0100100";
when 6 => segments:= "1100000";
when 7 => segments:= "0001111";
when 8 => segments:= "0000000";

16
 when 9 => segments:= "0001100";
when others => segments:= "1111111";

end case;
a <= segments(0);
b <= segments(1);
c <= segments(2);
d <= segments(3);
e <= segments(4);
f <= segments(5);
g <= segments(6);
end process decodificador1;
----------------------------segundos2----------------------------------------------------------------

decodificador2:process(count2)
variable segments2:bit_vector(0 to 6);
begin
case count2 is
when 0 => segments2:= "0000001";
when 1 => segments2:= "1001111";
when 2 => segments2:= "0010010";
when 3 => segments2:= "0000110";
when 4 => segments2:= "1001100";
when 5 => segments2:= "0100100";
when others => segments2:= "1111111";

end case;
a1 <= segments2(0);
b1 <= segments2(1);
c1 <= segments2(2);
d1 <= segments2(3);
e1 <= segments2(4);
f1 <= segments2(5);
g1 <= segments2(6);
end process decodificador2;

----------------------minutos1------------------------------------------

decodificador3:process(count3)
variable segments3:bit_vector(0 to 6);
begin
case count3 is
when 0 => segments3:= "0000001";
when 1 => segments3:= "1001111";
when 2 => segments3:= "0010010";
when 3 => segments3:= "0000110";
when 4 => segments3:= "1001100";

17
 when 5 => segments3:= "0100100";
when 6 => segments3:= "1100000";
when 7 => segments3:= "0001111";
when 8 => segments3:= "0000000";
when 9 => segments3:= "0001100";
when others => segments3:= "1111111";

end case;
a2 <= segments3(0);
b2 <= segments3(1);
c2 <= segments3(2);
d2 <= segments3(3);
e2 <= segments3(4);
f2 <= segments3(5);
g2 <= segments3(6);
end process decodificador3;
---------------------------------minutos2------------------------------------

decodificador4:process(count4)

variable segments4:bit_vector(0 to 6);

begin
case count4 is
when 0 => segments4:= "0000001";
when 1 => segments4:= "1001111";
when 2 => segments4:= "0010010";
when 3 => segments4:= "0000110";
when 4 => segments4:= "1001100";
when 5 => segments4:= "0100100";
-- when 6 => segments4:= "1100000";
when others => segments4:= "1111111";

end case;
a3 <= segments4(0);
b3 <= segments4(1);
c3 <= segments4(2);
d3 <= segments4(3);
e3 <= segments4(4);
f3 <= segments4(5);
g3 <= segments4(6);
end process decodificador4;

------------------------------------------horas1-------------------------------------------

decodificador5:process(count5)

18
variable segments5:bit_vector(0 to 6);
begin
case count5 is
when 0 => segments5:= "0000001";
when 1 => segments5:= "1001111";
when 2 => segments5:= "0010010";
when 3 => segments5:= "0000110";
when 4 => segments5:= "1001100";
when 5 => segments5:= "0100100";
when 6 => segments5:= "1100000";
when 7 => segments5:= "0001111";
when 8 => segments5:= "0000000";
when 9 => segments5:= "0001100";
when others => segments5:= "1111111";

end case;
a4 <= segments5(0);
b4 <= segments5(1);
c4 <= segments5(2);
d4 <= segments5(3);
e4 <= segments5(4);
f4 <= segments5(5);
g4 <= segments5(6);
end process decodificador5;
---------------------------------------horas2-----------------------------------------

decodificador6:process(count6)

variable segments6:bit_vector(0 to 6);

begin
case count6 is
when 0 => segments6:= "0000001";
when 1 => segments6:= "1001111";
when 2 => segments6:= "0010010";
when others => segments6:= "1111111";

end case;
a5 <= segments6(0);
b5 <= segments6(1);
c5 <= segments6(2);
d5 <= segments6(3);
e5 <= segments6(4);
f5 <= segments6(5);
g5 <= segments6(6);
end process decodificador6;
end relogio;

19
REFERÊNCIAS

COMO FUNCIONA UM RELOGIO DIGITAL. < https://www.newtoncbraga.com.br/index.php/como-

funciona/3901-art532>Acesso em 14 de dezembro de 2019.

VHDL. <https://pt.wikipedia.org/wiki/VHDL>Acesso em 14 de dezembro de 2019.

NOTAS DE AULAS

20