LAB01 – Introdução ao Altera Quartus II: LEDs, lógica ... · PDF fileLAB01 – Introdução ao Altera Quartus II: LEDs, ... VHDL). Síntese – O projecto é sintetizado num circuito,

Laboratório de Sistemas Digitais

DEP. DE ENG.ª ELECTROTÉCNICA E DE COMPUTADORES FACULDADE DE CIÊNCIAS E TECNOLOGIA

UNIVERSIDADE DE COIMBRA

MiEEC, 1.º ano, 1.º semestre DEEC-FCTUC

LAB01 – Introdução ao Altera Quartus II: LEDs, lógica combinacional, e contador com visor de 7

segmentos utilizando a placa FPGA DE2 i

1. Introdução ...................................................................................................................... 2

2. Quartus II da Altera ........................................................................................................ 3

2.1 Introdução ........................................................................................................................... 3

2.2 Ligar um interruptor a dois LEDs ............................................................................................ 4

2.2.1 Actividades a realizar........................................................................................................................ 4

2.2.1.1 Criação de um novo projecto no Quartus II ................................................................................. 4

2.2.1.2 Desenho do esquemático ............................................................................................................ 7

2.2.1.3 Compilação do circuito ............................................................................................................. 11

2.2.1.4 Simulação funcional ................................................................................................................. 13

2.2.1.5 Atribuição de pinos................................................................................................................... 17

2.2.1.6 Programação e configuração da FPGA ....................................................................................... 19

3. Controlar a luz do pátio com circuito de lógica combinacional ...........................................20

3.1 Introdução ......................................................................................................................... 20

3.2 Actividades......................................................................................................................... 21

3.2.1 Projectar circuito e criação de um novo projecto no Quartus II ......................................................... 21

3.2.2 Desenho do esquemático e compilação do circuito ........................................................................... 21

3.2.3 Simulação ...................................................................................................................................... 22

3.2.4 Atribuição dos pinos, programação da FPGA e teste ........................................................................ 23

4. Contador binário com visor de 7 segmentos .....................................................................23

4.1 Visor de 7 segmentos com descodificador ............................................................................. 23

4.1.1 Introdução .................................................................................................................................... 23

4.1.2 Enunciado ..................................................................................................................................... 25

4.2 Contador síncrono com visor de 7 segmentos ........................................................................ 26

4.2.1 Introdução .................................................................................................................................... 26

4.2.2 Enunciado ..................................................................................................................................... 27

5. Lista de verificação .........................................................................................................29

6. Referências ....................................................................................................................29

LAB01 – Introdução ao Altera Quartus II Laboratório de Sistemas Digitais

MiEEC, 1.º ano, 1.º semestre Pág. 2/29 DEEC-FCTUC

1. Introdução

O desenvolvimento de um circuito integrado (CI) para uma aplicação específica (ASIC

– application specific integrated circuit) requer algumas semanas ou meses até ser fabricado

e tem um custo inicial elevado. Este custo apenas se justifica se o CI for produzido em

grande escala (ex. milhões de unidades), de forma a ser rapidamente amortizado [1].

A tecnologia de CI programáveis (FPGA – field-programmable gate array) permite

implementar circuitos de grande dimensão e complexidade com tempos de desenvolvimento

bastante mais curtos [1]. As FPGAs são circuitos lógicos programáveis de grande

capacidade1 que podem ser programados (e re-programados) para implementarem

virtualmente qualquer sistema digital, desde que a dimensão do circuito não ultrapasse as

suas limitações físicas (número de elementos lógicos). Apesar dos circuitos serem um pouco

mais lentos e consumirem mais potência do que se fossem implementados num ASIC, têm

tempos e custos de desenvolvimento muito reduzidos2.

Fig. 1. Placas de desenvolvimento com FPGA da Altera: à esquerda a UP2 (University

Program Education Kit 2) e à direita a DE2 (Development and Education Board 2).

Pretende-se neste trabalho possibilitar um primeiro contacto com FPGAs. Será utilizada

uma placa de desenvolvimento com FPGA DE2 da Altera (ver Fig. 1) e far-se-á uma

introdução à utilização do software de CAD Quartus II da Altera3. O objectivo será

1 É possível hoje em dia programar numa FPGA sistemas digitais de dimensão e complexidade comparáveis a um microprocessador Pentium da Intel! 2 Depois de se projectar um sistema digital com recurso a ferramentas de CAD apropriadas, a programação de uma FPGA pode demorar apenas alguns segundos. 3 Altera Quartus II Web Edition Software v9.0 SP2 está disponível gratuitamente em: http://www2.deec.uc.pt/~jlobo/altera/91sp2_quartus_free.exe (link recomendado; cópia local; 1.9 GB) Também disponível em: http://www.altera.com/products/software/quartus-ii/web-edition/qts-we-index.html

http://www2.deec.uc.pt/~jlobo/altera/91sp2_quartus_free.exe

http://www.altera.com/products/software/quartus-ii/web-edition/qts-we-index.html



experimentar alguns circuitos lógicos simples com LEDs4, lógica combinacional e um

contador, usando uma ferramenta integrada de desenho, simulação e programação

(software Quartus II) e uma placa com uma FPGA Altera DE2. No trabalho seguinte, LAB2,

estes mesmos circuitos vão ser implementados com circuitos integrados (CIs) mais simples

que implementam funções lógicas standard da família TTL (Transistor Transistor Logic

74xxx). A implementação na placa DE2 é mais simples pois não temos que nos preocupar

com a ligação física de cada componente e a correcta alimentação dos circuitos.

2. Quartus II da Altera

2.1 Introdução

O software Quartus II da Altera é uma ferramenta de CAD (computer aided design)

que cobre todo o ciclo de desenvolvimento de um sistema digital implementado num

dispositivo lógico programável (ex. FPGA). Um processo de desenvolvimento completo inclui:

Especificação do circuito – O circuito desejado é especificado usando um

esquemático (diagrama gráfico) ou uma linguagem de descrição de hardware (ex.

VHDL).

Síntese – O projecto é sintetizado num circuito, ou seja um conjunto de elementos

lógicos.

Simulação funcional – O circuito sintetizado é testado para verificar a sua correcção

funcional, não considerando ainda restrições temporais.

Definição do layout – a ferramenta de CAD determina a localização dos elementos

lógicos definidos na fase de síntese numa determinada FPGA; as ligações entre

elementos lógicos, de acordo com o circuito especificado, são também definidas

nesta fase.

Análise temporal – análise dos atrasos de propagação ao longo das ligações

definidas na fase anterior e indicação do desempenho esperado para o circuito.

Simulação temporal – o circuito é simulado para verificar simultaneamente a sua

correcção lógica e temporal.

Programação e configuração – o circuito projectado é implementado fisicamente

numa FPGA através da programação das ligações internas da FPGA que configuram

os elementos lógicos utilizados pelo circuito.

4 Um LED (light-emitting diode) é um componente electrónico que conduz corrente eléctrica apenas num sentido e que emite luz quando conduz (será estudado nas disciplinas de Electrónica).



Neste trabalho, iremos utilizar o Quartus II para cumprir as fases de especificação,

simulação funcional e programação. Na fase de especificação, serão utilizados apenas

esquemáticos.

Cada circuito lógico, ou sub-circuito, concebido no Quartus II é designado por project

(projecto). A aplicação permite trabalhar em apenas um projecto em cada momento e

mantém toda a informação sobre o mesmo num folder (directoria) do sistema de ficheiros.

Para iniciar a concepção de um novo circuito lógico, o primeiro passo é criar a directoria para

os ficheiros do projecto.

2.2 Ligar um interruptor a dois LEDs

Nesta fase do trabalho, iremos implementar numa placa DE2 da Altera um circuito

digital extremamente simples que apenas liga um interruptor a dois LEDs.

2.2.1 Actividades a realizar

2.2.1.1 Criação de um novo projecto no Quartus II

a) Inicie o software Quartus II 9.0 Web Edition. Deverá visualizar uma janela similar

à da Fig. 2. Esta janela permite aceder a várias funcionalidades do Quartus II, que o

utilizador selecciona com o rato (com o botão esquerdo).

Fig. 2. Janela principal do Quartus II.



b) Defina um novo projecto, seleccionando File > New Project Wizard. Aparece-lhe

uma janela informativa (Fig. 3) que poderá saltar em utilizações futuras, desde que

indique essa escolha. Seleccione Next para obter a janela da Fig. 4.

c) No Microsoft Windows, abra a sua directoria “Os meus documentos” e crie uma

nova directoria “LSD_P<seu_numero_turma>G<seu_numero_grupo>”. No

primeiro campo da janela da Fig. 4, seleccione a directoria onde vai guardar os

ficheiros do projecto. Use o botão “…” para navegar até à directoria que acabou de

criar, onde deverá criar uma directoria com o nome “interruptor-LED”. Seleccione

esta directoria e clique em Abrir (ou Open). Nos segundo e terceiro campos da janela

da Fig. 4, escolha um nome para o projecto (ex. “interruptor-LED”); pode ser o mesmo

nos dois campos. Clique em Next; como a directoria não existe, o sistema perguntar-

lhe-á se a deseja criar; deverá responder afirmativamente para obter a janela da Fig.

5. Clique em Next novamente, uma vez que ainda não possui qualquer ficheiro para

incluir no novo projecto.

Fig. 3. Janela informativa sobre as tarefas executadas pelo wizard.



Fig. 4. Criação de um novo projecto no Quartus II.

Fig. 5. O wizard pode incluir no projecto ficheiros especificados pelo utilizador.



d) Nesta altura, deverá visualizar a janela da Fig. 6, onde terá de especificar a família do

dispositivo e o dispositivo específico dessa família que está a utilizar. A Fig. 6 mostra os

valores que deve seleccionar se estiver a utilizar a placa DE2 [2], ou seja tem que

seleccionar “Cyclone II” e “EP2C35F672C6” correspondendo ao CI que encontra

na placa. Clique em Finish para finalizar a criação do projecto. Dessa forma retornará

à janela principal do Quartus II, mas já com o projecto “interruptor-LED” seleccionado

como o projecto actual (ver Fig. 7).

2.2.1.2 Desenho do esquemático

a) Seleccione File>New para obter a janela da Fig. 8. Escolha Block

Diagram/Schematic File e clique em Ok. Esta acção abrirá a janela de edição

gráfica de esquemáticos, onde deverá especificar um nome para o ficheiro a ser criado,

seleccionado File>Save As (pode ser “interruptor-LED” novamente) e deixando

activada a opção Add file to current project. Depois criar o ficheiro, a janela do

Quartus II terá um aspecto similar à Fig. 9.

Fig. 6. Escolha a família do dispositivo e o dispositivo que está a usar.



Fig. 7. A janela principal do Quartus II após a criação de um novo projecto.

Fig. 8. Escolha do tipo do novo ficheiro a incluir no projecto.



Fig. 9. Editor gráfico de esquemáticos.

b) O editor de esquemáticos possui um conjunto de bibliotecas (libraries) que incluem

elementos que podem ser importados para um esquemático. Faça duplo-clique algures

na área de edição. Nesta altura, irá aparecer uma caixa pop-up (ver Fig. 10) onde

deverá expandir libraries, depois a biblioteca primitives e, finalmente, a biblioteca

logic, que contém portas lógicas. Seleccione um not e clique em Ok. O símbolo de

um inversor aparece agora na área de edição, que poderá mover usando o rato e

posicionar clicando com o botão esquerdo. Este procedimento poderia ser repetido

para outros elementos lógicos, caso fosse necessário.



Fig. 10. Escolha de um símbolo de uma biblioteca.

c) Vai necessitar agora de incluir no esquemático símbolos que representam as entradas

e saídas do circuito; neste caso, iremos incluir um pino de entrada e dois pinos de

saída. Para isso, use o mesmo procedimento que usaria para incluir portas lógicas, mas

escolha a biblioteca primitives>pin. Deverá importar uma instância de input port e

duas instâncias de output port, para obter a imagem da Fig. 11. Atribua nomes aos

pinos de entrada. Posicione o cursor do rato sobre a caixa pin_name (mas sem ser

em cima do nome pin_name) e clique duas vezes para poder editar o nome do pino

na caixa de diálogo da Fig. 12. Repita o procedimento para todos os pinos. Escolha os

nomes SW[0] para a entrada, LEDG[7] para a saída de cima e LEDR[0] para a saída de

baixo5.

5 Esta notação facilitará o mapeamento das entradas e saídas representadas no esquemático nos pinos de entrada e saída da placa DE2, principalmente em circuitos de maior complexidade a implementar futuramente nas aulas de laboratório, contendo muitas entradas e saídas. A sigla SW representa um switch (interruptor), a sigla LEDG um LED de cor verde (green) e a sigla LEDR um LED de cor vermelha (red). O índice (parênteses rectos e um número) serviria para distinguir entre si, num circuito mais complexo, múltiplas entidades semelhantes (ex. vários LEDs vermelhos).



Fig. 11. Importação dos pinos de entrada e saída para o esquemático.

d) Agora vai precisar de estabelecer as ligações (wires), desenhando linhas. Para isso,

poderá utilizar os botões disponibilizados na barra de ferramentas de desenho situada

na parte esquerda do editor gráfico. Desenhe as ligações necessárias até obter um

esquemático idêntico ao da Fig. 13. Nesta altura, não se esqueça de salvar o

esquemático, utilizando File>Save ou o botão que existe para o efeito na barra de

ferramentas principal do Quartus II (topo da janela). Em projectos mais complexos, é

aliás aconselhável não o fazer só no final da edição do esquemático.

Fig. 12. Definição do nome de um pino.

2.2.1.3 Compilação do circuito

O circuito desenhado anteriormente deverá ser processado por várias ferramentas do

Quartus II para analisar o ficheiro e detectar eventuais erros, sintetizar o circuito e gerar

uma implementação física para o hardware específico que esteja a ser utilizado.



Fig. 13. O diagrama esquemático completo de um circuito para ligar um interruptor

a dois LEDs.

a) Corra o compilador, seleccionado a opção Processing>Start Compilation. Também

existe um botão para o efeito numa das barras de ferramentas do Quartus II (triângulo

magenta). À medida que a compilação decorre, poderá observar as várias etapas do

processo numa janela situada na parte esquerda do Quartus II (Fig. 14). No final,

aparecerá uma pop-box a informar o utilizador acerca do sucesso ou insucesso da

compilação. Nessa altura, aparecerá também um relatório da compilação, que poderá

ser visualizado de novo mais tarde a partir de Processing>Compilation Report.

Fig. 14. Compilação do circuito.



b) Se eventualmente ocorrer algum erro de compilação, deverá analisar a descrição do

erro na caixa de mensagens situada no rodapé da janela do Quartus II e voltar à

edição do esquemático para os resolver. Depois de corrigido o erro, repita a

compilação ( alínea a) ).

2.2.1.4 Simulação funcional

Antes de implementar um circuito na placa da Altera, é prudente proceder à sua

simulação com o objectivo de se verificar a correcção do seu comportamento. O Quartus II

inclui uma ferramenta de simulação que pode ser usada para simular o comportamento de

um circuito projectado. Mas antes do circuito poder ser simulado, é necessário criar as

formas de onda desejadas para os sinais de entrada, a que se chamam vectores de teste.

a) Abra o editor de formas de onda, seleccionando File>New. Clique no separador

Verification/Debugging Files para aceder à janela da Fig. 15. Seleccione Vector

Waveform File e clique em Ok. O editor de formas de onda é mostrado na Fig. 16.

Salve o ficheiro com nome “interruptor-LED.vwf”.

Fig. 15. Criação de um ficheiro com vectores de teste.

b) Pode definir como intervalo de simulação [0; 200] ns (1ns = 10-9 segundos)

seleccionado Edit>End Time e inserindo o valor 200ns na caixa de diálogo. Se

seleccionar View>Fit in Window, poderá visualizar na janela a totalidade do

intervalo de tempo escolhido.



Fig. 16. Janela do editor de formas de onda.

c) De seguida, é necessário incluir os nós de entrada e de saída do circuito cujos sinais

deverão ser obtidos pelo simulador. Clique em Edit>Insert Node or Bus para obter

a janela da Fig. 17. Pode introduzir o nome de um sinal (pino) na caixa Name, mas é

mais fácil clicar no botão Node Finder que lhe permite aceder à janela da Fig. 18.

Nesta janela, contém um filtro que lhe permite seleccionar sub-grupos de pinos a

serem procurados no circuito projectado. A opção mais frequente é Pins: all. Clique

em List para encontrar todos os nós de entrada e de saída do circuito (lado esquerdo

da Fig. 18). Clique nos nós a incluir na selecção (pode seleccionar mais do que um nó

ao mesmo tempo se pressionar a tecla CTRL ou ALT) e clique em >. No final, clique

em Ok. Clique também em Ok na janela da Fig. 17. para obter algo similar ao que se

mostra na Fig. 19.

Fig. 17. Caixa de diálogo para definir os sinais a simular.



d) Utilize a barra de ferramentas situada na parte esquerda do editor de formas de onda

para criar um vector de teste para a única entrada do circuito (SW[0]). Para o efeito,

terá de clicar na ferramenta de desenho “seta”, seleccionar trechos do sinal SW[0] e

forçar o nível do sinal (0 ou 1). Por exemplo, coloque a entrada a 1 entre 100ns e

150ns (ver Fig. 19).

Fig. 18. Selecção dos nós a serem inseridos no editor de formas de onda.

Fig. 19. Nós seleccionados para a simulação e vector de teste para SW[0].

e) Seleccione Assignments>Settings para abrir a janela da Fig. 20. Seleccione

Simulation Settings e seleccione Functional na caixa Simulation mode. Clique

em Ok. Seleccione Processing>Generate Functional Simulation Netlist para

criar a lista de ligações do circuito (netlist). Finalmente, para simular o circuito,

seleccione Processing>Start Simulation ou clique no botão da seta azul na barra

de ferramentas do Quartus II. A Fig. 21 mostra o resultado da simulação. Pode mover



a linha vertical ao longo do gráfico para medir o instante de tempo em que ocorrem

transições nos sinais. Na Fig. 21, essa linha foi posicionada em t=100ns.

Fig. 20. Especificação do modo de simulação.

Fig. 21. Resultado da simulação funcional.



2.2.1.5 Atribuição de pinos

Durante a compilação, o compilador escolheu de livre arbítrio os pinos da FPGA a

utilizar para implementar a entradas e as duas saídas do circuito. O utilizador pode

obviamente escolher os pinos da FPGA a utilizar. De seguida, é proposta uma lista de

procedimentos para fazer a atribuição de pinos. No caso da placa DE2 [2], iremos utilizar o

interruptor SW0 para a entrada SW[0], o LED vermelho LEDR0 para a saída LEDR[0] e o LED

verde LEDG7 para a saída LEDG[7] (ver Fig. 22)..

a) Entre no editor de atribuições de pinos através de Assignments>Pin Planner (Fig.

23). Nesta editor, tem a possibilidade de editar um pino de cada vez, indicando o pino

da FPGA a atribuir a cada uma das entradas/saídas do circuito. Isto pode ser

interessante para circuitos com poucas entradas/saídas (como é o caso), mas

normalmente é melhor adoptar um outro procedimento.

Fig. 22. Desenho da placa DE2 da Altera [2].

b) Edite um ficheiro de texto (ex. no Notepad do MS Windows) com a informação sobre

atribuições de pinos apresentada na Fig. 24. Guarde esse ficheiro na directoria do seu

projecto, com o nome “pin-assignments.csv” (formato CSV ou comma separated

value). No final, importe estas atribuições de pinos através da opção

Assignments>Import Assignments, obtendo o resultado mostrado na Fig. 25.

SW[0] LEDR[0] LEDG[7]



b) Compile novamente o circuito para gerar correctamente o ficheiro de programação

“interruptor-LED.sof”.

Fig. 23. Editor de atribuições de pinos.

Fig. 24. Lista de atribuições de pinos para a placa DE2 [2].

Fig. 25. Atribuições de pinos.



2.2.1.6 Programação e configuração da FPGA

A FPGA tem de ser programada e configurada para implementar o circuito projectado.

A informação necessária para isto é criada durante a compilação do circuito. A informação é

transferida do computador onde está a ser executado o Quartus II para a placa da Altera

através de uma porta USB. A placa DE2 da Altera possui dois modos de

programação/configuração:

JTAG – Joint Test Action Group – A informação é carregada directamente na FPGA.

É uma forma simples de testar circuitos digitais, que para a DE2 tem a

particularidade de não permitir reter a programação da placa depois da placa ser

desligada e ligada novamente 6.

AS – Active Serial – A informação é guardada numa memória não volátil (ex.

memória flash) da placa DE2 da Altera. Depois a informação é também transferida

desta memória para a FPGA. Este modo de programação tem a particularidade de

reter a programação mesmo depois de se desligar e ligar novamente a placa.

Nestas aulas de laboratório, iremos utilizar sempre o modo de programação JTAG. Para

o efeito, o comutador RUN/PROG existente na placa DE2 deverá ser mantido sempre na

posição RUN.

a) Certifique-se que a sua placa DE2 está ON e devidamente ligada ao seu computador

(USB blaster port ao lado da alimentação). Seleccione Tools>Programmer para

aceder à janela da Fig. 26. Aqui é necessário especificar o modo de programação

JTAG (caixa mode) e seleccionar o hardware utilizado pelo computador para

comunicar com a placa da Altera, através do botão Hardware Setup. No caso da

placa DE2, seleccione USB-Blaster.

c) Seleccione o ficheiro “interruptor-LED.sof” apresentado na lista de ficheiros da Fig. 26

e marque a opção Program/Configure. Clique em Start para iniciar a

programação/configuração da placa. Acenderá um LED na placa quando a

programação/configuração tiver terminado.

d) Actue no interruptor da placa e observe o comportamento dos LEDs e o funcionamento

do circuito.

6 Existem outras FPGAs de menor capacidade que retêm a programação, como por exemplo a MAX EPM7128S da altera utilizada nas placas UP1 e UP2. A MAX retém a programação internamente depois de desligada, sem ter de recorrer a memória flash externa, a Cyclone II que vamos utilizar neste trabalho não.



Fig. 26. Janela de programação.

3. Controlar a luz do pátio com circuito de lógica combinacional

3.1 Introdução

Um projecto de lógica combinacional envolve a criação de circuitos cujas saídas

binárias são funções directas da combinação presente nas suas entradas binárias. Estes

circuitos fazem uso de portas lógicas Booleanas: AND, OR, NOT, NAND, NOR, etc.

O comportamento combinacional pode ser descrito usando tabelas de verdade ou

equações Booleanas. O projecto de um simples circuito combinacional é feito em 3 passos:

(1) captura do comportamento do circuito através de uma tabela de verdade ou de equações

Booleanas; (2) conversão para equações Booleanas (se necessário) e simplificação

(optimização); e (3) implementação das equações com portas lógicas básicas.

Nesta fase do trabalho, pretende-se projectar um circuito combinacional para controlar

a iluminação do pátio de uma residência. A luz só deve acender quando: a entrada de um

sensor de luz D é 0 (indicando que não é de dia) e a entrada de um sensor de movimento M

é 1 (indicando movimento). Temos ainda a entrada de um interruptor I que quando é 1

indica que a luz deve ficar ligada, independentemente dos valores de D e M. Para ligar a luz

deve-se colocar a saída L a 1. A Fig. 27 mostra o diagrama de blocos do circuito a projectar.



Fig. 27. Diagrama de blocos do controlador da luz do pátio.

3.2 Actividades

Em seguida, é proposta uma sequência de actividades para projectar, simular e

implementar o circuito anterior, usando o Quartus II e a placa FPGA da Altera DE2.

3.2.1 Projectar circuito e criação de um novo projecto no Quartus II

a) O primeiro passo do projecto é capturar o comportamento do circuito por uma

equação Booleana, que indica o valor da saída em função das entradas. Este

comportamento pode ser descrito através da equação Booleana L=M.D‟+I, em que D‟

representa “não D” (não é de dia), „.‟ E (AND) e „+‟ OU (OR).

b) Crie um novo projecto “combinacional-luz-do-patio”. Guarde este projecto na directoria

“LSD_P<numero_turma>G<numero_grupo>\combinacional-luz-do-patio”. Tenha em

atenção a configuração da família do dispositivo e o dispositivo específico da Altera que

está a usar (ver 2.2.1.1-d).

3.2.2 Desenho do esquemático e compilação do circuito

a) Desenhe o esquemático do circuito combinacional para controlar a luz do pátio. Atribua

aos sinais de entrada/saída os nomes indicados na Fig. 28.

Fig. 28. Esquemático do circuito combinacional para controlar a luz do pátio.

b) Compile o circuito. Enquanto houver erros de compilação, corrija os erros e repita as

alíneas a) e b).

D

M

I

L Circuito a

implementar



3.2.3 Simulação

b) Abra o editor de formas de onda e crie os vectores de teste necessários para testar o

circuito combinacional para todas as combinações das entradas (3 entradas => 23 = 8

combinações). Deverá obter algo similar ao que é mostrado na Fig. 29.

c) Crie a lista de ligações do circuito (netlist) e, em seguida, proceda à simulação

funcional do circuito. Observe a forma de onda da saída do circuito e verifique a

correcção do circuito projectado. Deverá obter algo semelhante à Fig. 30. Se detectar

algum erro no comportamento do circuito, deverá verificar se executou correctamente

as actividades 3.2.2 e 3.2.3, fazer as correcções necessárias e repetir a simulação.

Fig. 29. Vectores de teste para simular o circuito de controlo da luz do pátio.

Fig. 30. Simulação do circuito para controlar a luz do pátio.



3.2.4 Atribuição dos pinos, programação da FPGA e teste

a) Faça a atribuição dos sinais do circuito aos pinos da FPGA de acordo com a Tabela 1 .

Sinal Placa DE2

M SW[0] PIN_N25

D SW[1] PIN_N26

I SW[2] PIN_P25

L LEDR[0] PIN_AE23

Tabela 1. Atribuição dos pinos para o circuito para controlar a luz do pátio.

b) Compile novamente o circuito (para criar o ficheiro de programação da FPGA já com as

atribuições de pinos correctas).

c) Programe/configure a FPGA para implementar o circuito projectado.

d) Actue nos interruptores e teste o circuito em todas as situações (8 combinações).

4. Contador binário com visor de 7 segmentos

4.1 Visor de 7 segmentos com descodificador

4.1.1 Introdução

Nos sistemas digitais reais, é comum a utilização de conjuntos de interruptores

dispostos em linha – DIP (dual-in-line package) switches – para representar uma palavra

binária, habitualmente para configurar um parâmetro do sistema. A Fig. 31 mostra alguns

DIP switches e um DIP switch de 4 posições ligado a um conjunto de 4 LEDs.

Fig. 31. DIP switches , e ligação a LEDS para representar números binários (01102=610).

Porém, para visualizar dígitos, é mais conveniente recorrer a visores de 7 segmentos.

Estes visores permitem indicar um dígito decimal ou hexadecimal em função do valor binário

existente numa palavra binária de 4 bits. Cada segmento do visor é também um LED e

temos que recorrer a um circuito combinacional para controlar cada um do 7 segmentos. Os

DIP switch

LEDs

1 0



7 segmentos são geralmente etiquetados com as letras (minúsculas) a a g, em que o

segmento a é o de cima, e g é o do centro. As representações dos dígitos decimais 0 a 9 são

feitas como se indica na Fig. 32.

Fig. 32. Dígitos decimais num visor de 7 segmentos.

Os visores disponíveis directamente em alguns módulos de teste são de cátodo

comum, sendo necessário aplicar o nível lógico 1 a um determinado segmento para que

este acenda. Os restantes visores que vamos usar são do tipo ânodo comum – o terminal

positivo, o ânodo, de todos os segmentos é ligado em comum – pelo que um segmento

acende com o nível lógico 0. Os visores cujo circuito se apresenta na Fig. 33 estão já

montados num circuito impresso, que inclui as resistências limitadoras de corrente.

Fig. 33. Visor de 7 segmentos e respectivo circuito com LEDs to tipo ânodo comum.

Na família de lógica standard 74x temos já disponíveis CI‟s com circuitos

combinacionais para controlar cada um dos 7 segmentos: o CI ‟47 para visores de ânodo

comum e o CI ‟48 para visores de cátodo comum.

As placas DE2 possuem visores de 7 segmentos de ânodo comum, cujos segmentos

estão ligados a pinos da FPGA. Isto significa que para se acender um segmento é necessário

aplicar um 0 ao pino respectivo. Recorrendo a bibliotecas de componentes lógicos do

Quartus II podemos colocar no nosso projecto esquemático componentes equivalentes aos

da família lógica standard TTL (74xxx).

a

b

c

d

f

e

g

0 1 2 3 4 5 6 7 8 9



4.1.2 Enunciado

a) Crie um novo projecto no Quartus II, chamado “visor-7-seg-anodo-comum”. Guarde

este projecto na directoria “LSD_P<numero_turma>G<numero_grupo>\visor-7-seg-

anodo-comum”. Tenha em atenção a configuração da família do dispositivo e o

dispositivo específico da Altera que está a usar (ver 2.2.1.1-d).

b) Desenhe o esquemático de um pequeno circuito para visualizar uma quantidade binária

de 4 bits num visor de 7 segmentos de ânodo comum (Fig. 34). Vai precisar de

incluir no circuito um descodificador de BCD para 7 segmentos com saídas activas ao

nível baixo (CI ‟47). O símbolo deste componente está disponível na biblioteca

others>maxplus2 com o nome 7447. As entradas LTN, RBIN e BIN do CI devem

ser colocadas a 1 (Vcc). A saída RBON deve ficar desligada.

c) Faça a atribuição dos sinais do circuito aos pinos da FPGA de acordo com a Tabela 2.

d) Compile o circuito. Enquanto houver erros de compilação, corrija os erros e repita as

alíneas a) a c).

Fig. 34. Visor de 7 segmentos de ânodo comum com descodificador.

e) Programe/configure a FPGA com o circuito projectado. Actue nos 4 interruptores e

teste o circuito para todas as combinações possíveis. Se detectar erros de projecto,

volte atrás para corrigir.



Sinal Placa DE2

I0 SW[0] PIN_N25

I1 SW[1] PIN_N26

I2 SW[2] PIN_P25

I3 SW[3] PIN_AE14

a HEX0[0] PIN_AF10

b HEX0[1] PIN_AB12

c HEX0[2] PIN_AC12

d HEX0[3] PIN_AD11

e HEX0[4] PIN_AE11

f HEX0[5] PIN_V14

g HEX0[6] PIN_V13

Tabela 2. Atribuição dos pinos para o visor de 7 segmentos com descodificador.

4.2 Contador síncrono com visor de 7 segmentos

4.2.1 Introdução

No projecto de sistemas digitais ao nível de transferência de registos (register-transfer-

level), utilizam-se componentes que armazenam e/ou transformam dados (data). Um destes

componentes é o contador síncrono, que incrementa o seu próprio valor (soma 1) a cada

ciclo de um sinal de relógio. Um sinal de relógio é um sinal periódico quadrado como o da

Fig. 35, que é frequentemente utilizado nos sistemas digitais para manter sincronizados os

diversos elementos de um circuito. Habitualmente são usadas as transições (flancos positivos

ou negativos) destes sinais para definir os instantes de sincronização. Um contador diz-se

síncrono se incrementar a sua saída de forma sincronizada com os flancos positivos ou

negativos de um sinal de relógio.

Fig. 35. Sinal de relógio.

0V

+5V



4.2.2 Enunciado

a) Crie um novo projecto no Quartus II, chamado “contador-visor-7-seg-anodo-comum”.

Guarde este projecto na directoria “LSD_T<numero_turma>G<numero_grupo>\

contador-visor-7-seg-anodo-comum”. Tenha em atenção a configuração da família do

dispositivo e o dispositivo específico da Altera que está a usar (ver 2.2.1.1-d).

b) Desenhe o esquemático de um circuito para visualizar o estado de um contador binário

de 4 bits num visor de 7 segmentos de ânodo comum (Fig. 36). Para além do CI „47

(7447), vai precisar de incluir no circuito o símbolo do contador (CI „161), que está

disponível na biblioteca others>maxplus2 com o nome 74161. A saída OVFLW será

ligada a um LED para sinalizar a situação de overflow (o contador atinge a contagem

máxima). A entrada CLEAR será ligada a um botão de pressão que permitirá anular a

contagem. A entrada CLOCK será também ligada a um botão de pressão para emular o

sinal de relógio. As placas da Altera geram sinais de relógio internamente, mas têm

uma frequência demasiado elevada para esta experiência, sendo necessário colocar

divisores de frequência para gerar os valores pretendidos.

Fig. 36. Contador digital ligado a um visor de 7 segmentos.

c) Faça a atribuição dos sinais do circuito aos pinos da FPGA de acordo com a Tabela 3.

d) Compile o circuito. Enquanto houver erros de compilação, corrija os erros e repita as

alíneas a) a d).

e) Programe/configure a FPGA com o circuito projectado. Actue nos botões de pressão e

teste o circuito. Se detectar erros de projecto, volte atrás para corrigir.



Sinal Placa DE2

CLOCK KEY[0] PIN_G26

CLEAR KEY[1] PIN_N23

a HEX0[0] PIN_AF10

b HEX0[1] PIN_AB12

c HEX0[2] PIN_AC12

d HEX0[3] PIN_AD11

e HEX0[4] PIN_AE11

f HEX0[5] PIN_V14

g HEX0[6] PIN_V13

OVFLW LEDR[0] PIN_AE23

Tabela 3. Atribuição dos pinos para o contador com visor de 7 segmentos.

f) Amplie o esquemático da alínea a) para que a contagem seja anulada quando o

contador transitar de 9 (10012) para 10 (10102). Deve também alterar o circuito para

que a saída OVFLW fique a 1 quando a contagem atingir o valor 9.

g) Teste a nova versão do circuito na FPGA e verifique o seu correcto funcionamento.



5. Lista de verificação

Actividade

1 2.2.1.1 Ligar um interruptor a dois LEDs: Criação de um novo projecto no Quartus II

2 2.2.1.2 Ligar um interruptor a dois LEDs: Desenho do esquemático

3 2.2.1.3 Ligar um interruptor a dois LEDs: Compilação do circuito

4 2.2.1.5 Ligar um interruptor a dois LEDs: Simulação funcional

5 2.2.1.4 Ligar um interruptor a dois LEDs: Atribuição de pinos

6 2.2.1.6 Ligar um interruptor a dois LEDs: Atribuição dos pinos, programação da FPGA e teste Atribuição dos pinos, programação da FPGA e teste

7 3 Controlar a luz do pátio com circuito de lógica combinacional

8 4.1 Visor de 7 segmentos com descodificador

9 4.2 Contador binário com visor de 7 segmentos

10 4.2.2 f) Contador com reset para contar de 0 a 9 (BCD)

Importante: Antes de dar por terminado este trabalho laboratorial, preencha a tabela

anterior e chame o docente para este verificar e registar a execução das várias actividades

propostas neste enunciado.

6. Referências

[1] Digital Design. Frank Vahid, John Wiley & Sons, 2006.

[2] DE2 Development and Education Board. Altera, 72 páginas, 2006.

i Conteúdo pedagógico preparado em Julho de 2011 pelos docentes Jorge Lobo e Rui P. Rocha do DEEC-FCTUC, que asseguram a leccionação da unidade curricular Laboratório de Sistemas Digitais (MiEEC, 1.º ano, 1.º semestre).

Documents

LAB01 – Introdução ao Altera Quartus II: LEDs, lógica ... · PDF fileLAB01 – Introdução ao Altera Quartus II: LEDs, ... VHDL). Síntese – O projecto é sintetizado num circuito,