Universidade Federal de Campina Grande

Centro de Engenharia Elétrica e Informática

Departamento de Engenharia Elétrica

Laboratório de Circuitos Lógicos – 2018.1

Guia do Experimento 01-Verilog: Apresentação dos recursos da placa DE2 e do

software de Síntese Quartus II

OBJETIVO

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.

INTRODUÇÃO

A complexidade crescente dos sistemas digitais levou os projetistas a buscar alternativas

para o processo de desenvolvimento destes sistemas uma vez que projetos no nível de
portas lógicas tornaram-se inviáveis. Dentre as causas para a inviabilidade encontram-se: o
atraso global introduzido pelas portas, o tamanho do layout físico, o elevado consumo do
sistema e a necessidade de construir protótipos para testes. A solução encontrada foi a
utilização da lógica programável. Esta é uma técnica que consiste em programar um
dispositivo de caráter geral, que contém, internamente, milhares de portas lógicas, de modo
a implementar uma funcionalidade. Existem vários tipos de dispositivos lógicos
programáveis (PLD): PLA, PAL, CPLD e FPGA.

Placa de desenvolvimento DE2:

Para a realização dos experimentos será utilizada a placa de desenvolvimento DE2 –

Development and Education Board – fabricada pela Altera® (www.altera.com). Esta placa
foi desenvolvida com o propósito de apoiar a capacitação de estudantes universitários e/ou
de cursos técnicos no desenvolvimento de circuitos digitais. A placa DE2 é utilizada em
diversos países, em cursos de Arquitetura de Computadores e Projeto de Circuitos Lógicos
Digitais. A Figura 1 ilustra uma foto da placa de desenvolvimento.

A placa DE2 é equipada com os seguintes dispositivos:

 FPGA Altera Cyclone® II 2C35;

 Dispositivo de configuração serial Altera – EPCS16;
 USB Blaster (on board) – usada para a programação da placa;
 Memórias: SRAM 512-Kbyte, SDRAM 8-Mbyte, Flash 4-Mbyte;
 Interface para SD Card;
 8 displays de 7 segmentos;
 Display LCD 16x2;
 4 botões seletores;
  18 chaves bipolares;
 18 leds vermelhos;
 9 leds verdes;
 Osciladores de 50 e 27-MHz, que podem ser usados como clock;
 CODEC de áudio de 24-bits, com qualidade de CD;
 Entrada e saída de som e microfone;
 Interface VGA – conversor digital-analógico (10-bit high-speed);
 TV Decoder (NTSC/PAL) e entrada para TV;
 Barramento 10/100 Ethernet;
 Interfaces USB Host/Slave, tipo A e B;
 Interface serial RS-232 (DB-9);
 Interface PS/2 para mouse/teclado;
 Interface infravermelho IrDA;
 Dois barramentos de expansão com 40 pinos.

Figura 1 – Placa de Desenvolvimento Altera DE2.

Software de síntese lógica Quartus II:

Para utilizar a placa DE2, é necessário programá-la utilizando a ferramenta de síntese

lógica fornecida pelo fabricante do dispositivo escolhido para o projeto. Neste experimento
a ferramenta é o Quartus II da Altera. Essa ferramenta além de programar a placa, permite a
depuração de erros na descrição Verilog, a simulação do projeto, entre outras
funcionalidades. No site do fabricante (http://www.altera.com) existe versão paga bem
como versão gratuita da ferramenta de programação da placa, tanto para o SO Windows
quanto para o Linux.
PROCEDIMENTO EXPERIMENTAL

Experimento 01 – Implementação do módulo Mod_Teste

Objetivo: Ilustrar o uso do software Quartus II e da placa DE2, familiarizando o aluno com
o uso dos recursos de chaves, botões, leds e display de 7 segmentos disponíveis na placa.

Procedimento para edição, compilação e reconfiguração de FPGA utilizando o Quartus II:

1. Todos os programas do aluno deverão ser armazenados em uma pasta (diretório) criada
para tal finalidade. Portanto, utilizando o Windows Explorer (ou outro programa
similar), procure a pasta da disciplina (D:\LaboratoriodeCircuitosLogicos) e dentro
desta pasta crie uma pasta com o nome do aluno e sua turma (Aluno_T0X). Dentro da
pasta do aluno crie uma nova pasta com o nome de Mod_Teste. Esta pasta será utilizada
em breve.

2. Inicie o aplicativo Quartus II que aparece no Desktop do seu PC. Ao ser executado, a
tela mostrada na Figura 2 é apresentada. Feche a janela “Getting Started”, clicando no
“X” no canto superior direito da mesma.

Figura 2 – Tela de inicialização do Quartus II.

3. Na tela inicial do Quartus II (Figura 3) clique na opção File > New Project Wizard para
criar o seu novo projeto e começar a criar os arquivos deste projeto.

4. Ao selecionar File > New Project Wizard uma nova janela surgirá (Figura 04). Para
continuar, clique no botão “NEXT”.
 Figura 3 – Tela inicial do Quartus II.

Figura 4 – Tela inicial do Wizard de criação de novo projeto.

5. Na janela apresentada na Figura 5, deve ser selecionado o diretório onde o projeto será
gravado, o nome do mesmo, bem como o nome do módulo que será criado no arquivo.v
(arquivo Verilog). Para escolha da pasta (diretório) onde o projeto deve ser armazenado,
clique nos três pontinhos do lado direito e navegue até a pasta criada no item 1
(LaboratoriodeCircuitosLogicos\Aluno_T0X\Mod_Teste). Observe que o nome
indicado no terceiro campo da janela (campo inferior) deverá coincidir com o nome do
módulo mais externo criado no arquivo de descrição Verilog. Por exemplo, no
experimento estaremos criando o módulo Mod_Teste, então observe que tanto o nome
do projeto (segundo campo) quanto o nome do módulo “top-level” (terceiro campo)
foram assim denominados.
6. Para seguir, clique no botão “NEXT”.

Crie um diretório com seu

nome e turma

Figura 5 – Seleção de diretório, nome do novo projeto e nome do módulo verilog.

7. Na tela seguinte (Figura 6) não é necessário nenhum preenchimento, apenas prossiga

clicando no botão “NEXT”.

Figura 6 – Janela para adição de arquivos ao projeto.

8. Na janela seguinte, selecione a família de dispositivos “Cyclone II” e o dispositivo

“EP2C35F672C6”, como indicado na Figura 7. O programa Quartus II pode ser
utilizado para programar diversos dispositivos com características diferentes. Portanto é
muito importante escolher o dispositivo correto (EP2C35F672C6), caso contrário o
programa não conseguirá programar o dispositivo corretamente. Para finalizar clique no
botão “NEXT”.
 Figura 7 – Seleção de família de dispositivo e dispositivo.

9. Na janela seguinte, apenas clique no botão NEXT para seguir para a janela de
finalização. Na janela de finalização clique no botão “FINISH”.

10. Na janela aberta após a conclusão do Wizard de criação do projeto, mostrada na Figura
8, percebe-se o sucesso na criação, como observado na indicação pelo círculo vermelho
na figura. O nome deverá corresponder àquele indicado no passo 4, que em nosso caso
corresponde a “Mod_Teste”. Veja no navegador de projetos que o projeto identifica a
placa Cyclone II, EP2C35F672C6, e vincula o nome Mod_Teste na hierarquia.
 Figura 8 – Tela do projeto Mod_Teste.

11. Selecione no menu a opção “File > New”. Será apresentada a janela mostrada na
Figura 9.

12. Selecione a opção “Design Files > Verilog HDL File”. Ao selecionar esta opção você
estará adicionando ao projeto um arquivo de descrição, no qual você editará, usando a
linguagem Verilog, a descrição do hardware que será implementada pelo FPGA. Após
selecionar a opção, clique no botão “OK”.

13. Na tela do Quartus II será aberta uma janela de edição, conforme indicado na Figura 10.
Nesta janela digite a descrição de hardware do módulo “Mod_Teste”(descrição após a
Figura 10). Este módulo não apresenta nenhuma funcionalidade, apenas disponibiliza
acesso aos recursos de entrada e saída da placa DE2. As denominações utilizadas nesse
módulo (como por exemplo: SW) estão definidas em uma planilha Excel, onde nesta, é
realizada a correlação entre o nome da chave e os respectivos pinos do dispositivo
FPGA, aos quais estão ligados os botões, chaves, led’s, e display’s, fisicamente.
Figura 9 – Janela para seleção do tipo de arquivo que será acrescentado ao projeto.

Figura 10 – Janela de edição da descrição Verilog.

// --------------------------------------------------------------------
// Módulo de entradas e saídas para a placa ALTERA DE2
// Esta primeira parte será utilizada em todos os experimentos realizados
// --------------------------------------------------------------------
module Mod_Teste (
//////////////////// Fonte de Clock ////////////////////
CLOCK_27, // 27 MHz
CLOCK_50, // 50 MHz
//////////////////// Push Button ////////////////////
KEY, // Pushbutton(botoes)[3:0]
//////////////////// Chaves DPDT ////////////////////
SW, // Toggle Switches(chaves)[17:0]
//////////////////// Display de 7-SEG ////////////////////
HEX0, // Display 0
HEX1, // Display 1
HEX2, // Display 2
HEX3, // Display 3
HEX4, // Display 4
HEX5, // Display 5
HEX6, // Display 6
HEX7, // Display 7
//////////////////// LEDS ////////////////////////
LEDG, // LED Green(verde)[8:0]
LEDR // LED Red(vermelho)[17:0]
);

input CLOCK_27;
input CLOCK_50;

input [3:0] KEY;

input [17:0] SW;

output [6:0] HEX0;

output [6:0] HEX1;
output [6:0] HEX2;
output [6:0] HEX3;
output [6:0] HEX4;
output [6:0] HEX5;
output [6:0] HEX6;
output [6:0] HEX7;

output [8:0] LEDG;

output [17:0] LEDR;

// --------------------------------------------------------------------------
// Trecho para instanciação de módulos e interligação entre os mesmos
// Esta parte será modificada para cada um dos experimentos realizados
// --------------------------------------------------------------------------
// Liga todos os segmentos dos Displays de 7-segmentos

assign HEX0 = 7'h00;

assign HEX1 = 7'h00;
assign HEX2 = 7'h00;
assign HEX3 = 7'h00;
assign HEX4 = 7'h00;
assign HEX5 = 7'h00;
assign HEX6 = 7'h00;
assign HEX7 = 7'h00;

// Ativa todos os leds verdes e vermelhos

assign LEDG = 9'h1FF;
assign LEDR = 18'h3FFFF;

// ---------------------------------------------------------------------------
// Fim do trecho para instanciação de módulos e interligação entre os mesmos
// ---------------------------------------------------------------------------
endmodule // fim do modulo
 Observe que estamos definindo um módulo (Mod_Teste) e seus parâmetros, portanto,
após o último parâmetro, e antes do parêntesis que fecha a chamada do módulo, não
existe ‘virgula’.
14. Salve o arquivo que foi criado clicando no botão de salvar ou selecionando a opção
“File > Save”. Ao solicitar o salvamento do arquivo, será apresentada a tela mostrada
na Figura 11. Certifique-se de que o diretório onde o arquivo está sendo salvo é o do
projeto (....\Aluno_T0X\Mod_Teste) e que o nome do arquivo corresponde ao nome do
módulo “top-level”, da descrição editada. Neste exemplo o nome do arquivo será
“Mod_Teste.v”;

Figura 11 – Janela para salvamento de arquivo .v.

15. Copie o arquivo DE2_pin_assignments.csv da Origem para o destino abaixo:

OrigemD:\LabCircuitosLogicos\DE2\DE2_lab_exercises\DE2_pin_assignments.csv

Destino: D:\ LabCircuitosLogicos \ Aluno_Turma \ Mod_Teste

Em seguida clique na opção Assignments e depois em Import Assignments para associar

os dispositivos aos pinos da placa, indicando o seguinte caminho:
D:\ LabCircuitosLogicos \ aluno_T0X \ Mod_Teste \ DE2_pin_assignments.csv
Para finalizar clique em OK.
16. Após ter sido salvo, o projeto pode ser compilado, usando o botão , ou selecionando
a opção “Processing > Start Compilation”. Caso nenhum erro tenha sido cometido,
após a compilação terá sido criado o arquivo “Mod_Teste.sof”, que contém a descrição
no formato para gravação no dispositivo FPGA. Observe que provavelmente terá uns
400 e poucos “warnings”, mas não terá “errors”;
17. Para realizar a gravação, ligar a placa e clicar no botão ou selecionar a opção
“Tools > Programmer”. Será apresentada a tela mostrada na Figura 12, onde pode-se
observar a indicação do arquivo a ser gravado “Mod_Teste.sof” e a interface de
gravação “USB-Blaster (USB-0)”, no Modo JTAG. Note que a interface só será
indicada na tela de gravação se a placa DE2 estiver conectada à porta USB e ligada.
Clique no botão Start.

Figura 12 – Janela de gravação de descrição no dispositivo FPGA.

18. Feche o projeto Mod_Teste através da opção “File > Close Project”. No Windows
Explorer, copie e cole a pasta Mod_Teste. O Windows irá criar uma nova pasta com
nome tipo pasta Mod_Teste (Cópia). Renomeie esta nova pasta com o nome
ChavesLeds para a próxima tarefa. Agora, dentro da pasta do aluno (Aluno_T0X)
deverá ter duas pastas (Mod_Teste e ChaveLeds). A partir de agora, novos projetos
devem sempre ser baseados no Mod_Teste, que tem todas as configurações iniciais.
Abra o projeto no Quartus II utilizando a opção “File > Open Project” e escolha o
projeto na pasta recém-criada (ChavesLeds). Caso não seja seguido rigorosamente o
processo descrito acima, poderão não ser mantidas as informações quanto ao modelo da
placa e a configuração das chaves. Caso isso ocorra, será necessário definí-los
novamente.

Tarefa 1 – Conexão de chaves e botões a LED’s e Displays de 7 segmentos.

Objetivo: 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.

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 13 – Representação de um display de 7 segmentos

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].

/*----- interligação Botão 0 Led Verde 0 ------*/

assign LEDG[0] = KEY[0];

A partir do exemplo acima, elabore uma descrição que realize as seguintes conexões:

a) 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;

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;

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.

Tarefa 2 – Implementação de uma função COMPARADOR de 2 variáveis usando

hierarquia.

O COMPARADOR que implementa a função S = f(A, B), tem a saída S, e entradas A e B a

serem comparadas. Para cada valor da entrada A=B, a saída S será igual a 1 (hum) . Caso
A seja diferente de B, a saída será 0 (zero), como apresentado na Tabela 1.
 A B S
0 0 1
0 1 0
1 0 0
1 1 1
Tabela 1 – Tabela-verdade do
COMPARADOR.

Verifica-se que a saída S vale 1 quando o valor das entradas forem iguais, e por sua vez, ao
valor binário 0, quando forem diferentes. A partir desse fato, podemos deduzir a expressão
lógica de S:
__
S = AB + A B

Copie e cole a pasta Mod_Teste renomeando-o para COMPARADOR. Abra o novo

projeto. No arquivo Mod_Teste.v (dentro da pasta COMPARADOR), digite o trecho a
seguir, no espaço reservado, em substituição à descrição de hardware anterior:

// --------------------------------------------------------------------------
// 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];
comparador 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

Em seguida crie três novos módulos (em três novos arquivos, dentro da mesma pasta
COMPARADOR) e associe-os ao projeto. Tenha o cuidado de criá-los corretamente File >
new (ver Itens 12 e 13), pois estes mesmos arquivos serão utilizados nos próximos
experimentos.

//Arquivo comparador.v:

module comparador(S, A, B);

input A, B;
output S;
wire x, y;
porta_and2 U1(x, A, B);
porta_and2 U2(y,~A,~B);
porta_or2 U3(S, x, y);
endmodule
//Arquivo porta_and2.v:

module porta_and2(y, a, b);

input a, b;
output y;
assign y = a & b;
endmodule

//Arquivo porta_or2.v:

module porta_or2(z, c, d);

input c, d;
output z;
assign z = c | d;
endmodule

Agora realize os testes com o COMPARADOR de 2 variáveis.

A B S
0 0
0 1
1 0
1 1

Verifique os diagramas RTL gerados pelo Quartus II para vários níveis de hierarquia
acessando o menu: Tools \ Netlist Viewers \ RTL Viewer

Tarefa 3 – Utilização de um Conversor CBP4 – Mostrador de 7 Segmentos Hexadecimal.

Utilize 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.
Copie e cole a pasta Mod_Teste renomeando-o para SEG7_LUT. Abra o novo projeto. No
arquivo Mod_Teste.v (dentro da pasta SEG7_LUT), digite o trecho a seguir, no espaço
reservado, em substituição à descrição de hardware anterior:

// --------------------------------------------------------------------------
// 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 Conversor 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 ; // ---[0]---
4'h2: oSEG = ; // | |
4'h3: oSEG = ; //[5] [1]
4'h4: oSEG = ; // | |
4'h5: oSEG = ; // ---[6]---
4'h6: oSEG = ; // | |
4'h7: oSEG = ; //[4] [2]
4'h8: oSEG = ; // | |
4'h9: oSEG = ; // ---[3]---
4'ha: oSEG = ;
4'hb: oSEG = ;
4'hc: oSEG = ;
4'hd: oSEG = ;
4'he: oSEG = ;
4'hf: oSEG = ;

endcase
end

endmodule

Preparação:
Preencha a tabela do case(iDIG) do arquivo SEG7_LUT.v com os valores necessários para
acendimento dos segmentos corretos para a formação dos dígitos conforme o padrão de
segmentos da Figura 17.

Figura 17 – Padrões de segmentos.

Questão:

Como você faria um Conversor do Código ASCII para Mostrador de 7 Segmentos?

Sugira uma nova tabela do case(iDIG) e um novo arquivo ASCII_SEG7.v com os valores
necessários para acendimento dos segmentos corretos para a formação dos dígitos
correspondentes às letras do alfabeto ( A,B,C..U,Z), na forma maiúscula ou minúscula,
exceto as letras M, V, W, X e Y.

REFERÊNCIAS BIBLIOGRAFICAS
 Tutorial: Quartus II Introduction Using Verilog Design – Altera ®.
 Elementos de Eletrônica Digital – I.V. Idoeta, F.C. Capuano – Editora Érica, 2003.
 Verilog HDL Synthesis – J. Bhasker – Star Galaxy Publishing, 1998.
 Altera Website – http://www.altera.com
 Apostila: Projeto de Sistemas Digitais na Atualidade – UFPB/CCT/DEE - A.
Scaico, 2000.