Universidade Federal de Campina Grande - UFCG

Centro de Engenharia Elétrica e Informática - CEEI

Departamento de Engenharia Elétrica - DEE

Nome: Gabriel Nazario Gonçalves

Email: gabriel.goncalves@ee.ufcg.edu.br

Disciplina: Laboratório de Circuitos Lógicos

Professores: Fernanda Cecília Correia Lima Loureiro e Adolfo Hebster

Experimento 1 - Verilog: Apresentação dos

recursos da placa DE2 e do
software de Síntese Quartus II

Objetivo Geral
Este experimento tem por objetivo familiarizar o aluno com a técnica HDL
de projeto de sistemas digitais e com suas ferramentas de projeto: a linguagem
de descrição de hardware Verilog, a placa DE2 e o software de síntese Quartus
II.

Após a criação de arquivos e familiaridade com o Quartus II, podemos dar

inicio às tarefas.

Objetivo Específico – Conexão de chaves e botões a LED’s e Displays

de 7 segmentos.
Apresentar a forma de descrever a conexão de portas de entradas e portas de
saída de um módulo, a partir dos recursos da placa DE2.

Tarefa 1:
O display de 7 segmentos possibilita escrever números decimais de 0 a 9 e
alguns outros símbolos que podem ser letras ou sinais. A Figura 13 representa uma
unidade do display genérica, com a numeração de identificação dos segmentos.
Figura 1 - Representação display de 7 segmentos

Fonte: Material visto em aula

A placa DE2 é constituída de 8 displays de 7 segmentos do tipo anodo comum.

Um nível lógico alto representa um segmento apagado e um nível lógico baixo
representa um segmento aceso.
O trecho de descrição a seguir indica uma conexão entre a chave 0 e o led
verde (Green) 0 da placa DE2. Observe que os botões, chaves, led’s e display’s são
definidos como vetores, onde SW[0] corresponde a chave 0, KEY[0] corresponde ao
botão 0, LEDR[0] corresponde ao LED vermelho 0 e LEDG[0], corresponde ao LED
Verde 0. Note que são oito displays de sete segmentos numerados de HEX0 a HEX7.
Para ter acesso aos segmentos do primeiro display utilizamos os índices de HEX0[0] a
HEX0[6]. De modo semelhante para o último display utilizamos os índices de HEX7[0]
a HEX7[6].

Botões de 0 a 3 conectados aos Led’s verdes de 0 a 3. Os botões são

referenciados no Quartus II pela palavra KEY; portanto a primeira linha será:
assign LEDG[0] = KEY[0]. As outras 3 linhas serão semelhantes, mudando
apenas o índice do LEDG e do KEY;
assing LEDG[0] = KEY[0];
assing LEDG[1] = KEY[1];
assing LEDG[2] = KEY[2];
assing LEDG[3] = KEY[3];

b) Chaves de 0 a 10, conectadas aos Led’s vermelhos (Red) de 0 a 10. As chaves

são referenciadas com SW, portanto a primeira linha será: assign LEDR[0] =
SW[0]. As outras 10 linhas mudarão apenas os índices do LEDR e do SW;
assing LEDR[0] = SW[0];
assing LEDR[1] = SW[1];
assing LEDR[2] = SW[2];
assing LEDR[3] = SW[3];
assing LEDR[4] = SW[4];
assing LEDR[5] = SW[5];
assing LEDR[6] = SW[6];
assing LEDR[7] = SW[7];
assing LEDR[8] = SW[8];
assing LEDR[9] = SW[9];
assing LEDR[10] = SW[10];

c) Chaves de 11 a 17 conectadas aos segmentos do Display de 7 segmentos 0

(referenciado pelo HEX0), na seguinte sequência: HEX0[0] = SW[11], HEX0[1] =
SW[12] e sucessivamente
assing HEX0[0] = SW[11];
assing HEX0[1] = SW[12];
assing HEX0[2] = SW[13];
assing HEX0[3] = SW[14];
assing HEX0[4] = SW[15];
assing HEX0[5] = SW[16];
assing HEX0[6] = SW[17];
Tarefa 2:
Objetivo específico
Implementação das funções lógicas AND e NOR de 2 variáveis usando
expressão lógica, NAND e OR de 2 variáveis usando tabela-verdade.
A AND de 2 variáveis implementa a função S = f(A, B), tem a saída S, e
entradas A e B a serem comparadas. Para os valores de entrada apresentados na
Tabela 1, a saída S será igual a 1 (um) sempre que as 2 variáveis de entrada sejam
iguais a 1 (um).
AND : 𝑆 = 𝐴. 𝐵
NOR: 𝑆 = ̅̅̅̅̅̅̅̅
𝐴+𝐵

Figura 2 - Tabela verdade da porta AND

Fonte: Material visto em aula

Figura 3 - tabela verdade Porta OR

Fonte: Material visto em aula

Verifica-se que a saída S vale 1 quando o valor das entradas forem iguais a 1,
e por sua vez, ao valor binário 0, quando forem os outros valores da tabea. A partir
desse fato, podemos deduzir a expressão lógica de (S = A . B).

Implementar o arquivo Mod_Teste para a AND

// --------------------------------------------------------------------------
// Trecho para instanciação de módulos e interligação entre os mesmos
// Esta parte será modificada para cada um dos experimentos realizados
// --------------------------------------------------------------------------
// Defina os dados para realização do COMPARADOR
wire A, B;
wire S;
assign A = SW[0];
assign B = SW[1];
Porta_AND M1(S, A, B);
assign LEDG[0] = S;
// ---------------------------------------------------------------------------
// Fim do trecho para instanciação de módulos e interligação entre os mesmos
 // ---------------------------------------------------------------------------
endmodule // fim do modulo

Gerar arquivo Porta_AND.V

module Porta_AND(S, A, B);
input A, B;
output S;
assign S = A&B;
endmodule

A NOR de 2 variáveis implementa a função S = f(A, B), tem a saída S, e

entradas A e B a serem comparadas. Para os valores de entrada apresentados na
Tabela 2, a saída S será igual a 1 (um) sempre que as 2 variáveis de entrada sejam
iguais a 0 (zero).
Figura 4 - Tabela verdade porta NOR

Figura 5 Fonte: Material visto em aula

Verifica-se que a saída S vale 1 quando o valor das entradas forem iguais a 1, e por
sua vez, ao valor binário 0, quando forem os outros valores da tabela. A partir desse fato,
podemos deduzir a expressão lógica de: 𝑆 = ̅̅̅̅̅̅̅̅
𝐴+𝐵

Implementar o arquivo Mod_Teste para a NOR.

// --------------------------------------------------------------------------
// Trecho para instanciação de módulos e interligação entre os mesmos
// Esta parte será modificada para cada um dos experimentos realizados
// --------------------------------------------------------------------------
// Defina os dados para realização do COMPARADOR
wire A, B;
wire S;
assign A = SW[0];
assign B = SW[1];
Porta_NOR M1(S, A, B);
assign LEDG[0] = S;
// ---------------------------------------------------------------------------
// Fim do trecho para instanciação de módulos e interligação entre os mesmos
// ---------------------------------------------------------------------------
endmodule // fim do modulo

Criar arquivo Porta_NOR.v:

module Porta_NOR(S, A, B);
input A, B;
output S;
assign S = ~(A|B);
endmodule

QUESTÃO 1: Sabendo que os operadores lógicos para a porta AND é o &, OR é o |, e

para inverter o resultado da operação é utilizado ~, como mostrado nos itens anteriores.
Elabore os módulos para as portas NAND e OR por tabela-verdade.
 (AND)
module Porta_NAND(S, A, B);
input A, B;
output S;
assing S = ~(A&B);
endmodule
(OR)
module Porta_OR(S, A, B);
input A,B;
output S;
assing S = A|B;

Tarefa 3
Objetivo Específico
Utilização de um Conversor CBP4 – Mostrador de 7 Segmentos Hexadecimal.
Utilizar o Conversor de Código Binário Puro de quatro bits para o Código do
Mostrador de 7 Segmentos Hexadecimal NBA, implementado no módulo
SEG7_LUT.v.
Implementar o código a seguir em uma pasta copiada a anterior, abrir o projeto
em substituição à descrição de hardware anterir:
// --------------------------------------------------------------------------
// Trecho para instanciação de módulos e interligação entre os mesmos
// Esta parte será modificada para cada um dos experimentos realizados
// --------------------------------------------------------------------------
// Defina os dados para realização do conversosr de 7 segmentos
wire [3:0] entradaHEXA;
wire [6:0] saida7segmentos;
assign entradaHEXA[3:0] = SW[13:10];
assign HEX3[6:0] = saida7segmentos[6:0];
SEG7_LUT(saida7segmentos,entradaHEXA);
// ---------------------------------------------------------------------------
// Fim do trecho para instanciação de módulos e interligação entre os mesmos
// ---------------------------------------------------------------------------
endmodule // fim do modulo

Em seguida crie um novo módulo (em um novo arquivo) e associe ao projeto.

Complete os valores a serem utilizados na estrutura case, tendo como exemplo o
caso 4'h1. Utilize como referência a Figura 17. Calcule os demais valores e complete
a tabela do modo indicado. Verifique que na primeira linha da tabela (onde tem 4'h0:
oSEG)os valores são definidos de forma direta, levando em consideração o nível
baixo dos segmentos. Ou seja, com a definição 7’b1000000; temos o segmento 7
apagado e os demais acesos formando um ‘zero’. Na segunda linha da tabela temos
um ‘~’ antes do valor a ser atribuído, invertendo assim os bits. Então os 1s
representam os segmentos acesos. Portanto para o segundo valor na tabela, o
segundo e terceiro bit estão acesos e os demais apagados, formando assim um ‘um’.
O restante da tabela poderá ser preenchido utilizando ou não o ‘~’ conforme queira.

Arquivo SEG7_LUT.v:
module SEG7_LUT (oSEG, iDIG);
input [3:0] iDIG;
output [6:0] oSEG;
reg [6:0] oSEG;
always @(iDIG)
begin
case(iDIG)
4'h0: oSEG = 7'b1000000 ;
4'h1: oSEG = ~7'b0000110 ;
4'h2: oSEG = 7'b0100100;
4'h3: oSEG = ~7'b1001111;
4'h4: oSEG = 7'b0011001;
4'h5: oSEG = ~7'b1101101;
4'h6: oSEG = 7'b0000010;
4'h7: oSEG = ~7'b0000111;
4'h8: oSEG = 7'b0000000;
4'h9: oSEG = ~7'b1101111;
4'ha: oSEG = 7'b0001000;
4'hb: oSEG = ~7'b1111100;
4'hc: oSEG = 7'b1000110;
4'hd: oSEG = ~7'b1011110;
4'he: oSEG = 7'b0000110;
4'hf: oSEG = ~7'b1110001;
endcase
end
endmodule

Aplicações
Tendo em vista a complexidade dos processadores atuais, linguagens de
programação como o Verilog/SystemVerilog, são amplamente aplicadas visto a
dimenção e o trabalho para o teste em meio eletronico físico. Com isso, a escrita da
linguaguem lígica por meio de software se faz necessária para a criação de
processadores complexos. As aplicações portanto tendem ao infinito, podendo ser
implementadas em sistemas de automação industrial ou até mesmo residencial.

Com hierarquia, visto em sala, foi feita a implementação em Verilog de um circuito

lógico com 2 variáveis de entrada que terá saída igual 1 sempre que a quantidade de
indivíduos no ambiente seja menor que 2, essa saída será comparada com uma
outra entrada e terão saídas iguais a 1 sempre os valores de entrada não forem
iguais a 0.

Diagrama lógico
 Figura 6 - Diagrama lógico de hierarquia

Figura 7 Fonte: Material visto em aula

Questionamentos
Implementação de:
module circuito_Hierarquia (S, A, B, C)
input A, B, C;
output S;
assing S = ~(A & B) | C;