Apostila - Lógica Programável Ranhel Rev 6

Dispositivos Lógicos Programáveis
Apostila com práticas em VHDL.
Julho – 2015.
Prof. João Ranhel
-- Apostila: Dispositivos Lógicos Programáveis e VHDL - Prof. João Ranhel 1
Introdução
Esta é uma apostila para introduzir dispositivos programáveis aos alunos de iniciação em Eletrônica Digital
(na UFPE: Técnicas Digitais). Acredito, e as evidências de mercado/indústria apontam isso, que circuitos
integrados discretos são o passado. A questão é: como ensinar aos iniciantes em circuitos digitais que os
dispositivos lógicos programáveis (CPLDs, FPGAs e os SoCs) podem ser compreendidos com a mesma
facilidade que os circuitos da geração anterior?
A primeira coisa é tomar contato logo de cara com os circuitos. A segunda é isolar o objeto de estudo,
tirando-o do contexto dos kits de desenvolvimento que algumas empresas vendem, que são caros e trazem
muitos recursos (displays, LCDs, chaves e botões, saída VGA, conversores A/D e D/A, entrada e saída de
áudio, memória, etc.). São recursos desejáveis para quem desenvolve sistemas digitais mais avançados.
Para o aluno que está começando aprender portas, blocos lógicos combinacionais e circuitos sequenciais,
ter muito recurso na placa pode intimidar, pode criar ruído onde não precisa existir algum.
Acredito que ensinar lógica programável diretamente no objeto a ser programado (CPLD e FPGA) é muito
mais construtivo. Por isso, sou adepto das placas de FPGA e CPLD mínimas. Elas possuem apenas os
circuitos integrados básicos para alimentação do chip, cristais osciladores, memória de configuração
(embora dispensável), e os conectores ligados direto nos pinos do circuito integrado.
A burocracia brasileira dificulta a compra de pequenos dispositivos. Um kit mínimo custa menos de US$ 40
nos sites de venda pela Internet. Muitos alunos podem comprar um kit assim. O desenvolvimento desse
aluno, tendo o kit para trabalhar, é superior ao daquele que só faz as práticas e daqueles que só aprendem
na teoria. Acreditando que estudantes devem ter acesso a esse material, solicitei a alguns alunos que
ajudassem a criar os kits na UFPE. O resultado foi a confecção de placas de alta qualidade. A ideia é que o
resultado desse desenvolvimento seja hardware livre (Hardware_Livre_UFPE) e por isso disponibilizamos os
esquemas dos projetos. Os arquivos desenvolvidos no CAD Eagle estão livres para quem quiser. A pessoa
pode escolher uma empresa que confeccione as placas de circuito impresso (PCBs) e o custo de produção
de cada PCB tem sido entre 1 e 2 dólares sem componentes. Escolhemos um CI FPGA que custa menos de
US 12. As listas de materiais estão disponíveis, portanto, o aluno pode montar sua própria FPGA e as placas
básicas de entrada e saída. Além disso, alunos já desenvolveram outros módulos que são agregadas ao
sistema como os shields do Arduino (aliás, uma placa desenvolvida por aluno agrega Arduino ao sistema).
Dessa forma, agora temos nossos kits minimalistas para aprendizado de eletrônica digital em dispositivos
lógicos programáveis. Aos alunos pioneiros que ajudaram no projeto (Jéssica Ribeiro, André Moraes, João
Henrique CC Albuquerque, Dierson Antônio Silva, Samuel Sobral dos Santos, José Rodrigues O Neto)
devemos nossos sinceros agradecimentos. Eles fizeram os kits se tornarem realidade.
Ensinar “descrição” (ou “configuração”) de hardware logo no primeiro contato com eletrônica digital pode
parecer improdutivo ou demasiado complexo, afinal, o aluno tem que aprender uma linguagem. A prática
tem mostrado que não. Ensinamos aos alunos que começamos por montar “tabelas” verdade. Em seguida,
extraímos das tabelas “equações” booleanas, ou seja, leis matemáticas. Equações são apenas outra forma
(mais abstrata) de representação das tabelas. Depois vem simplificação algébrica, e então ensinamos a
transformar equações em “diagramas”. Portas e blocos lógicos desenhados em circuitos eletrônicos são
apenas outra forma de representação das tabelas e equações. Se, logo de início, mostramos aos alunos que
existe outra forma de representar a mesma coisa, a “descrição” na forma de texto, o aluno aprende sem o
salto entre a forma “antiga” de criar projetos em eletrônica digital e a forma “nova”.
A apostila é um texto guia sobre dispositivos programáveis, VHDL, e o uso dos kits desenvolvidos no Depto.
de Eletrônica e Sistemas (DES) da UFPE. Um livro para aprofundar nesses assuntos é imprescindível.
Lógica Programável
Dispositivos Lógicos Programáveis (PLDs – programmable logic devices) são componentes eletrônicos
utilizados para construir sistemas digitais. Introduzidos na década de 1980, estes circuitos surgiram para
atender a grande demanda crescente na complexidade dos sistemas digitais, demandas de diminuição e
simplificação das placas de circuito impresso (PCBs), de consumo de energia, de velocidade de operação,
entre outras. Ao contrário de um circuito integrado (CI) discreto com portas ou blocos lógicos, cuja função é
fixa, um PLD tem uma função indefinida quando é fabricado. Em geral, o usuário/criador do sistema digital
é que programa um PLD determinando sua funcionalidade.
Alternativa aos circuitos programáveis são os circuitos cuja função é destinada a um propósito específico,
denominados ASICs (application-specific integrated circuit - ou circuitos integrados de aplicação específica).
Estes CIs são geralmente mais velozes, otimizados com relação ao consumo de energia, geralmente mais
baratos quando fabricados aos milhões, e suas funções são definidas na fabricação. Geralmente, ASICs não
necessitam de muitos componentes externos porque sua alta densidade permite absorver grande parte dos
subsistemas, que são implementados dentro dos próprios chips. Os problemas com ASICs são: seu
desenvolvimento é caro e demorado, não podem ser reprogramados; portanto, sua função e/ou vida útil
fica dependente do tempo de existência do produto ao que foi destinado.
Em contrapartida, os PLDs são flexíveis e podem ser reutilizados, garantindo ao produto vida útil maior
porque novas versões dos sistemas digitais podem ser programadas com seu uso, apesar de custarem mais
que os ASICs, de consumirem um pouco mais de energia em geral, e de não atingirem as velocidades de
operação mais altas que os concorrentes ASICs. Em comparação com outras tecnologias de circuitos
integrados digitais (por exemplo, circuitos discretos – hoje obsoletos), os dispositivos de lógica programável
apresentam um ciclo de projeto menor e custos reduzidos.
Os PLDs podem, atualmente, ser classificados em dois tipos de circuitos: CPLDs (complex programmable
logic device) e FPGAs (Field Programmable Logic Arrays). As CPLDs são mais simples que as FPGAs e são
utilizadas para implementação de sistemas ou circuitos lógicos de complexidade intermediária, são
reconfiguráveis e sua configuração é não volátil. As FPGAs permitem implementar sistemas lógicos de
grande complexidade em função de possuírem blocos lógicos mais complexos (explicado adiante), sistemas
de roteamento em maior escala, sistemas de distribuições de sinais globais como clock e reset, circuitos
aritméticos e DPS com multiplicadores, somadores, etc; e principalmente, blocos de memória interna –
inclusive memória RAM de porta dupla (dual-port RAM). Existem FPGAs com configuração não volátil, mas
a maioria utiliza memória RAM estática que é volátil. Portanto, uma característica marcante das FPGAs é
que elas precisam ser reconfiguradas cada vez que são desligadas. Essa reconfiguração pode ser feita de
várias maneiras diferentes: automaticamente após o reset pela FPGA que lê os bits de reconfiguração numa
memória externa, por um microprocessador externo, ou via uma porta especial chamada JTAG.
Vamos trabalhar com os CIs FPGA da Altera. Portanto, vamos explicar o que há dentro de uma família de
FPGAs especificas chamada CYCLONE II.
Evolução da lógica programável

Os arranjos lógicos programáveis:
Um arranjo lógico programável consiste em circuitos que possuem estrutura interna baseada em um
conjunto deportas AND-OR (o conjunto de portas AND e OR são chamados de arranjos) que podem ser
ligados ou desligados para se obter, geralmente, SOMA DE PRODUTOS. As entradas desse circuito são
ligadas às portas AND (formando produtos: P = A•B•C ... •Z) e as saídas das portas AND são conectadas às
entradas das portas OR (realizando a soma: X = P1 + P2 + ... + PN), que são as saídas do circuito.
Lógica Programável em ROM:
É possível fazer lógica programável em memórias ROM. Antes das PLD's serem inventadas, as memórias
ROM foram utilizadas para implementar lógica combinatória. Considere uma ROM com m entradas (Linhas
de endereço) e n saídas (bits de dados). Quando usadas como memória, cada ROM contém 2n palavras de
n-bits. Considere que as entradas são ligadas não a um endereço m-bits mas a m sinais lógicos
independentes; teremos em tese 2m funções booleanas possíveis desses sinais. Por exemplo, suponha que
m=3 = {A,B,C}. Podemos ter as seguintes combinações (endereços):
Contudo, a estrutura da ROM permite apenas n destas funções sejam obtidas nos pinos de saída. Ou seja,
se escolhermos o bit D0 como saída, podemos gravar a ROM para gerar em D0 uma soma de qualquer dos
produtos acima, basta gravar um bit ‘1’ na posição equivalente ao termo da equação desejado. Como
temos n saídas (digamos 8 bits) então teremos n (8) funções lógicas possíveis, uma em cada pino de saída
de dados (D0, D1, D2, D3, D4, D5, D6, D7). Um exemplo em D0 poderia ser gravar: {1 + 0 + 0 + 1 + 1 + 0 + 0 + 0}
que significa que no bit D0 teríamos a função:
A ROM torna-se equivalente a n de circuitos lógicos paralelos, cada qual gerando sua função lógica
independente de m entradas. Pode-se utilizar ROM (PROMs, EPROMs, EEPROMs) para esse fim para gerar
qualquer função lógica combinacional com m entradas, o que tornando o dispositivo lógico disponível para
aplicações variadas. O inconveniente é que as ROMs ficam com grande parte de seu circuito sem utilização,
são mais lentas que os circuitos convencionais, consomem mais energia, não permitem implementação de
lógica sequencial; portanto implementar lógica programável em ROM é ineficiente. A noção de
programação de memória ROM como PLD é mostrada na figura 1.
Fig. 1: Uma ROM vista como dispositivo programável (img modificada da internet).
Circuitos Programáveis Específicos:
Na década de 1970 começaram a surgir os circuitos programáveis específicos. A ideia principal era atender
uma demanda de engenharia que precisava de lógica combinacional programável para diminuição dos
espaços utilizados em PCBs. Datas marcantes e as principais tecnologias introduzidas foram:
•PLA (Programmable Logic Array – ou arranjo lógico programável)
Em 1970, a Texas Instruments desenvolveu um CI programável por máscara baseado em memória

associativa. Este componente, o TMS2000 era programado alterando-se a camada de metal durante a
fabricação. A Texas criou o termo Programmable Logic Array (PLA) para este dispositivo. Em 1973, a
National Semiconductor introduziu um dispositivo PLA programável por máscara (DM7575) com 14
entradas e 8 saídas sem registradores de memória. A ideia principal da PLA é ilustrada na figura 2
Fig. 2: arranjo típico de um PLA: tanto a matriz AND quanto a matriz OR são programáveis (img internet).
Este tipo de circuito era particularmente difícil de ser programado devido ao fato de o projetista ter que
escolher a programação tanto dos termos de produto quanto da soma. Para melhor utilizar os Cis isso
requeria dos projetistas realizar simplificações dos circuitos desejados, o que resultava em pouca economia
de tempo de projeto.
No exemplo da Fig. 2 vemos como devem ser programadas as conexões tanto na matriz AND quanto na
matriz OR para se obter cada uma das 6 funções de saída.
• PAL - (Programmable Array Logic – ou Matriz lógica programável)
A MMI introduziu um dispositivo diferente das PLAs em 1978, com uma arquitetura mais simples porque
omitia a matriz programável OR, ou seja, a matriz OR já vem configurada. Isto tornava os componentes
mais rápidos, menores e mais baratos, e o projetista deveria optar pelo tipo de arranjo de saída que
desejava. As PALs também possuíam flip-flops (ver Fig. 3) incorporados às matrizes OR, que podiam ser
programados para criar máquinas sequenciais e máquinas de estados finitos (FSM) mais facilmente.
Em certo sentido a PAL desmistifica o processo de construção de sistemas digitais porque um software de
design convertia equações booleanas de engenharia em padrões de queima ou não de fusíveis necessários
para programar o componente. Os componentes PAL rapidamente se tornaram populares.
Acompanhando o avanço dos circuitos integrados, surgem as primeiras linguagens de descrição de

hardware HDL (Hardware Description Language), tais como ABEL, CUPL, ou PALASM. Algumas linguagens
oferecem opções de síntese, ou seja a capacidade de converter a descrição do circuito em configuração (ou
programação) dos circuitos integrados.
Fig. 3: circuito do PAL PLUS 16R4 da Philips: a matriz AND é programávem e a matriz OR é fixa. Note-se a presença de
flip-flops, apropriados para criação de FSM (imagem manual Philips).
• GAL - (Generic Array Logic)
Com o sucesso das PALs, a Lattice semiconductor em 1985 expandiu a ideia criando os GAL, que tem as
mesmas propriedades lógicas das PAL mas podem ser apagadas e reprogramadas. Estes circuitos se
mostraram úteis no estágio de prototipagem de um projecto, quando alguns erros lógicos podem surgir. As
GAL podem ser programadas e reprogramadas usando um programador PAL ou usando uma técnica de um
circuito embutido em alguns chips. Um componente similar, o PEEL (programmable electrically erasable
logic), foi produzido pela ICT.1
Atualmente estes circuitos e técnicas de criação de sistemas lógicos programáveis foram substituídos pelos
novos dispositivos que surgiram a partir dos anos 1980, baseados em blocos lógicos programáveis.
1
Fonte: http://pt.wikipedia.org/wiki/Dispositivo_l%C3%B3gico_program%C3%A1vel (17/09/2014)
Elementos Lógicos Programáveis:
A Altera chama Elementos Lógicos (LE – Logic Elements) as estruturas que compõem a nova base de
dispositivos programáveis, mais genéricas e versáteis que as tradicionais matrizes de AND-OR dos arranjos
lógicos programáveis.
Fig. 4: Multiplexador de 2 entradas, e uma Look-up Table (LUT) de 2 entradas. As saídas do MUX na LUT são definidas
pelas variáveis de entrada A e B, e os registrador de deslocamento armazena os bits.
O principal componente introduzido neste tipo de tecnologia é o conceito de LUT (Look-up Table). Uma LUT
é composta de um multiplexador (figura 4) associado geralmente a um registrador de deslocamento cujos
bits de sua saída paralelizada são aplicados ao MUX. Assim, a saída F do multiplex é selecionada em função
das entradas (A e B – no exemplo). Se um determinado termo da função está ativo ou não é uma questão
de ligar (1) ou desligar (0) o bit de dado respectivo nos flip-flops do registrador.
Por exemplo, no esquema da figura 4, para obter a equação precisamos gravar os bits
“1001” nos flip-flops. Para obter a função (função XOR) precisamos gravar os bits “0110” nos
flip-flops do registrador ( ).
Associado às LUTs colocam-se algumas entradas adicionais e um ou dois flip-flops do tipo D para reter
dados, ou seja, para permitir criação de lógica sequencial. A esse conjunto a Altera dá o nome de Logical
Elements (LE), ou elementos lógicos, como pode ser visto na figura 5. Outro nome comum para esse bloco é
Configurable Logic Block (CLB).
Fig. 5: Esquemático de um bloco lógico configurável composto de uma LUT, um flip-flop e um multiplex de saída.
A complexidade dos elementos lógicos varia de tecnologia para tecnologia, e de fabricante para fabricante.
É comum construir elementos lógicos com 4, com 5 ou com 6 entradas nos multiplexadores. Isso depende
da família de elementos lógicos programáveis onde serão utilizados. A figura 6 mostra um elemento lógico
configurável de uma CPLD da Altera.
Fig. 6: Elemento Lógico (LE) configurável numa CPLD Altera. Nos dispositivos mais complexos como FPGA, os LEs
possuem entradas em cascatas para operações aritméticas e outras funções (imagem manual Altera).
Embora exista CPLDs com matrizes de portas AND e OR associadas a elementos lógicos (LUT), é uma
tendência que os circuitos, mesmo CPLDs, sejam feitos com elementos lógicos como os descritos acima.
PALs e GALs são construídos em tamanhos pequenos, ou seja, com relativamente poucos componentes
configuráveis. São apropriados para criação de circuitos lógicos de baixa complexidade, e são equivalentes
a algumas centenas de portas lógicas. Para sistemas lógicos maiores pode-se usar Complex PLD ou CPLDs.
• CPLDs (Complex Programmable Logic Devices)
CPLDs contém o equivalente a várias PALs que podem ser interligadas dentro de um único chip por meio de
barramentos programáveis. Dentro de um chip CPLD temos centenas ou milhares de elementos lógicos
programáveis podem ser interligados por barramentos de interconexão dentro do chip. CPLDs podem
assim substituir milhares de portas lógicas e/ou blocos lógicos vendidos em CIs discretos.
Alguns CPLDs mais antigos podem ser configurados/programados usando o programador PAL ou
programador universal, mas este método torna-se inconveniente para CIs com centenas de pinos. Assim,
surgiu outro método de programação que consiste em soldar o componente à PCB, ligar um cabo serial que
transfere dados de configuração a partir de um PC, e programar (configurar é a melhor palavra) o CI na
própria PCB junto com os outros componentes. O CPLD contém um circuito que decodifica os dados seriais
e configura o chip. Cada fabricante começou a usar um nome proprietário para o sistema de configuração
dos chips que usam essa metodologia; por exemplo, a Lattice chamou (ISP) "In-system Programming" (ou
programação no sistema), termo que ainda é utilizado.
Contudo, o método mais comum de gravação é o JTAG, que discutiremos adiante. Note que foi falado que
o CPLD é programado via cabo serial, esta é a razão por termos utilizado um registrador de deslocamento
na representação dos bits de configuração da LUT na Fig. 4. Na verdade, todos os bits de configuração de
um CPLD ou FPGA (tanto os das LUTs quanto os que configuram os barramentos de interconexões) são
introduzidos nos chips serialmente; os bits de configuração percorrem um registrador de deslocamento

bastante grande, que armazena todos os bits de configuração possíveis dentro do chip.
A Fig. 7 ilustra como é um diagrama de blocos com a configuração interna de um CPLD da Altera.
Fig. 7: Diagrama de blocos de um CPLD Altera (MAX V). Cada Bloco Lógico (LAB) é formado de vários elementos lógicos
programáveis (Les). Um barramento interconecta blocos lógicos. Os blocos IOE mostram os circuitos que
interconectam cada bloco com os pinos de entrada e saída do circuito integrado (img manual Altera).
Os CPLDs modernos são muito utilizados para fazer pontes entre barramentos (bus-bridge), quando há
diferenças entre tipos de barramentos num sistema. Podem ainda ser utilizados para fornecer lógica
complementar para FPGAs.
Fig. 8: kit EPM240 Altera MAX II CPLD. O kit custa ~ US$ 18,00. Baseado no CPLD EPM240 possui: 240 elementos
lógicos LEs, 192 macro células, 80 pinos I/O, opera até 340 MHz (foto da internet).
Atualmente (09/2014) é possível comprar uma placa (kit) de desenvolvimento CPLD em sites da internet
por menos de US$20, como a placa da figura 8. Estes kits facilitam o uso dos CPLDs porque já vem com toda
a parte de alimentação e regulação de tensão, filtros, entrada de programação JTAG e cristal oscilador
instalados na placa. Os pinos de entrada e saída (I/O) disponíveis para os usuários estão conectados a
barras de pinos, facilitando o acesso ao usuário. Por esse motivo, são bons para criar protótipos rápidos.
• FPGA (Field Programmable Gate Array)
FPGAs são circuitos integrados reprogramáveis que usam conjuntos de elementos lógicos (LEs, como
descritos anteriormente) como unidades básicas de construção de blocos programáveis. Cada fabricante dá
um nome ao seu conjunto de elementos lógicos, assim, podemos encontrar “blocos lógicos programáveis”
(PLBs ou Programmable Logic Blocks) ou Logic Array Blocks (LABs), e assim por diante. Para se ter uma
ideia, na família Cyclone IV da Altera, cada LAB possui:
■ 16 LEs
■ LAB control signals
■ LE carry chains
■ Register chains
■ Local interconnect
Apenas por essa pequena descrição dá para perceber que o que diferencia FPGAs de CPLDs é a
complexidade da construção dos elementos programáveis. À isso associam-se a integração em grande
escala permitindo que um chip possua milhares e até milhões de elementos lógicos (fig. 5). A fig. 9 ilustra
como estão estruturadas as FPGAs da família Cyclone II da Altera.
Fig. 9: Organização interna das matrizes de blocos lógicos (LAB) na Cyclone II da Altera. Cada LAB contém 16
elementos lógicos (Fig. 6) interconectados localmente. Entre LABs vizinhos há um barramento de interconexão local.
Para interconectar LABs distantes, há uma estrutura de barramentos de interconexão formando uma matriz (array)
com barramentos para colunas e linhas que formam a matriz de interconexões (img manual Altera).
Além de possuirem as estruturas de blocos lógicos programáveis, as FPGAs possuem também subsistemas
ou blocos lógicos dedicados. Por exemplo:
• Sistema de gerenciamento de clock – dedicado para gerenciar sinais vários sinais de clock (relógios do
sistema), sinais de reset e enable global, etc. Para isso, os blocos dos FGPAs avançados possuem PLLs
(Phase Locked Loop) que permitem multiplicar e dividir o clock de entrada gerando duty-cicles variados.
• Advanced I/O support – que permite gerar sinais diferenciais de alta velocidade nas saídas (para
transceptores diferenciais), ou permitem controlar os vários níveis de tensão (Single-ended I/O standard
support, including 2.5-V and 1.8-V, SSTL class I and II, 1.8-V and 1.5-V HSTL class I and II, 3.3-V PCI and PCI-X
1.0, 3.3-, 2.5-, 1.8-, and 1.5-V LVCMOS, and 3.3-, 2.5-, and 1.8-V LVTTL).
• Multiplicadores e Acumuladores embutidos – para facilitar operações aritméticas em hardware de alta

velocidade, facilitando implementação de processamentos de sinais digitais (DSPs).
• Bloco de memória RAM – internamente os chips FPGAs possuem atualmente RAM estática de alta
velocidade, alguns com dual-port RAM.
É possível comprar um kit FPGA atualmente (Fig. 10) por valores como ~US$ 30,00 (09/2014). Um circuito
integrado FPGA hoje, com 6.000 LEs pode custar em torno de US$ 12,00; apesar de haver CIs FPGA
especializados que custam até US$ 20.000,00 ou mais.
Fig. 10: Placa (kit) FPGA CoreEP4CE6 Cyclone IV Altera. A placa é feita par prover alimentação ao FPGA, sinal de clock e
acesso aos pinos do JTAG usados para configurar o chip. Os pinos e entrada e saída da FPGA ficam todos disponíveis
para o usuário (foto do site DX na internet).
Uma tendência também é embutir microprocessadores nas FPGAs, criando os chamados SoC (System on
Chips). Esse tipo de componente permite aproveitar o melhor dos dois mundos: a flexibilidade de rodar
software nos microprocessadores, dentro de uma FPGA que permite processamento em hardware.
Com dispositivos tão complexos, fica evidente a necessidade de utilização de uma ferramenta apropriada
para configurá-los. Um FPGA pode chegar a ter milhões de bits que precisam ser ligados ou desligados,
basicamente para três fins: implementar a lógica desejada nos LEs, configurar o roteamente e as
interconexões locais ou na matriz geral do chip, ou preencher os bits dos blocos de memória interna do
chip. Assim, um FPGA pode facilmente alcançar milhões de bits necessários para configurá-lo. Por esse
motivo, usa-se FFs tipo D em cada bit, e os dados de configuração são introduzidos no chip cada vez que o
FPGA é religado.
Cada bit interno pode representar um fio que o usuário precisaria ligar num protoboard, ou uma trilha a ser
feita na PCB. Só para dar um exemplo, se uma FPGA tem 2 milhões de bits internos para configuração, e o
usuário gastasse 1 segundo para ligar cada bit, ele levaria ~556 horas contínuas para liga-los; ou ~ 23 dias
contínuos. Fica evidente a necessidade da assistência de um computador para realizar tal tarefa. Para isso
foram desenvolvidos as ferramentas Electronic Design Automation (EDA ou ECAD), que fazem a
“automação do projeto eletrônico”. O programa EDA da Altera, onde o usuário descreve o hardware de seu
projeto é o QUARTUS II.
O usuário pode configurar esses chips para implementar funcionalidades complexas e personalizadas em
hardware. Para isso, ele deverá descrever o hardware desejado utilizando uma linguagem de descrição de
hardware (HDL – Hardware Description Language), que são introduzidas no QUARTUS. As duas linguagens
mais conhecidas para descrição de hardware são VERILOG e VHDL, na qual serão baseadas nossas práticas
descritas adiante.
• JTAG (Joint Test Action Group)
Já da década de 1970 o projeto das PCBs se tornaram complexo o bastante para causar um embaraço para
a indústria eletrônica: como testar cada placa produzida? Com os circuitos integrados crescendo em
complexidade o número de trilhas da placas aumentavam. Mais ainda, surgiram PCBs com vários layers e as
trilhas ficavam ‘escondidas’ e sem pontos de acesso para serem testadas. Posteriormente surgiram CIs
cujos pinos (e as trilhas) ficavam escondidos em baixo dos CIs (os BGAs ou ball gate arrays). Para resolver o
problema o IEEE criou um grupo que ficou conhecido como Joint Test Action Group, que criou um padrão
denominado IEEE 1149.1, que define uma ferramenta para testes de placas, conhecido também como
Standard Test Access Port e Boundary-Scan Architecture.
A imagem 11 mostra como o padrão IEEE 1149.1 insere no chip a capacidade de funcionar na cadeia de CIs
com arquitetura boundary-scan. Estes chips possuem em cada pino do CI um sistema de chaveamento que
permite desconectar a lógica interna do CI, portanto temos os núcleos lógicos do CI desconectados do
mundo externo; assim como desconectar as trilhas externas da lógica interna, portanto, uma trilha da placa
pode ser isolada. O boundary-scan permite excitar tanto a lógica interna do chip (com as trilhas
desconectadas) quanto as trilhas externas (com as lógicas internas dos chips desconectadas). Para isso os
CIs com JTAG possuem pinos adicionais dedicados, e são interconectados em cadeia. Assim, é possível
deslocar os bits da cadeia de forma que podemos ‘ler’ como está cada pino isolado de cada CI da cadeia.
Fig. 11: Chip com o boundary-scan architecture (ou JTAG). Estes chips possuem em cada pino do CI um sistema de
chaveamento que pode desconectar a lógica interna, pode desconectar as trilhas externas, e permite excitar tanto a
lógica interna quanto as trilhas externas. Os chips são interconectados em cadeia.
Dessa forma, podemos excitar uma trilha e verificar se o sinal chega apenas nos pinos aos quais ela está
ligada, verificando se há rompimento ou curto nas trilhas.
Por outro lado, se podemos desconectar os CIs e podemos excitá-los internamente, podemos então usar o
boundary-scan para dois outros propósitos: gravar bits dentro do chip e verificar o status desses bits; ou
seja, podemos configurar ou programar os chips. Por outro lado, se podemos ler os bits dentro do chip
então podemos usar o JTAG como ferramenta de depuração (debugging). A figura 12 mostra uma placa de
circuito impresso com alguns CIs com e outros sem JTAG, e a forma como a cadeia é ligada.
Os pinos JTAG do chip tem nomes definidos: TDI (test data input), TCK (test clock), TMS (test mode select) e
TDO (test data output). Para fazer a cadeia, conectam-se os pinos em paralelo exceto TDI/TDO que são
ligados em série. O pino TDI1 do 1º chip (por onde entram os dados da cadeia) está ligado no terminal JTAG.
O pino TDO1 do 1º chip é ligado ao TDI2 do 2º chip na cadeia, e seu TDO2 é ligado ao TDI do chip seguinte e
assim por diante, até que TDO do último chip se conecta ao terminal JTAG (figura 12).
Fig. 12: Placa de circuito impresso (PCB) com um terminal JTAG de acesso externo. Note como os CIs são ligados em
cadeia, com o TDOn de cada chip conectado ao TDIn+1 do chip seguinte. Os outros sinais são ligados em paralelo em
todos os CIs. Isso forma a cadeia boundary-scan que permite testar a placa, programá-la, e debugar projetos.
Vamos utilizar o terminal JTAG da placa para programar/configurar a placa FGPA, por isso precisamos de
um cabo ou adaptador serial que converta a saída do PC para a entrada JTAG da placa. O adaptador chama
USB-Blaster (figura 13). Este adaptador vem com dois cabos: um que se conecta à USB do PC e ao conversor
de níveis, e um flat-cable JTAG (10 pinos) que conecta o conversor ao conector JTAG da placa.
Fig. 13: Adaptador JTAG da Altera (USB-Blaster): O cabo preto é conectado a uma saída USB do PC e ao conversor de
níveis. O cabo chato (flat-cable) é conectado no conversor e no terminal JTAG da placa (foto da internet).
LINGUAGEM DE DESCRIÇÃO DE HARDWARE (HDL)
Como já foi dito, existem duas linguagens de descrição de hardware mais utilizadas atualmente: Verilog e
VHDL. Vamos utilizar a última por entender que ela está mais próxima do projetista de hardware, embora
Verilog também seja uma linguagem eficiente que é bastante utilizada na indústria eletrônica.
Ciclo de Desenvolvimento utilizando HDL:
Criar um projeto em HDL segue um ciclo de desenvolvimento. Primeiro o projetista cria um projeto e
descreve o circuito usando VHDL. Durante o processo o projetista pode verificar sintaxe, etc e garantir que
cada arquivo de código gerado está descrito corretamente. Geralmente, cada arquivo VHDL descreve um
circuito, um bloco lógico, um sistema. Se achar interessante a metáfora, pense nestes arquivos como se
fossem um circuito integrado que você compraria numa loja para integrar ao seu sistema. Um arquivo deve
descrever como esses vários arquivos VHDL estão interligados – que é o arquivo que descreve a estrutura
global do projeto.
O fluxo de projeto pode ser visto na figura 14. Após descrever em VHDL os blocos que fazem parte do
sistema (fig. 14 System Design) o usuário pode verificar a funcionalidade do projeto (bloco no canto
superior direito: Functional Simulation, Design Rule Checking e RTL View, onde se pode ver graficamente
os blocos no nível de transferência de registradores, ou RTL).
Em seguida, o usuário deve impor as restrições ao projeto, ou seja, deve configurar quais pinos físicos do CI
receberá os sinais que na descrição de hardware foram tratados por nomes. Pode ainda fazer análises de
performance aproximada e consumo, ambas baseadas em simulação (Fig 14 – I/O Assignment & Analysis).
Na sequência o usuário deve fazer a síntese propriamente dita (RTL Synthesis). O programa Quartus rotear
as funções desejadas dentro do dispositivo escolhido (Place & Route Process). O programa vai gerar um
arquivo que é uma fileira de bits ‘1’s e ‘0’s respeitando o que é descrito (a função que deve ser executada)
associada aos pinos físicos do FPGA. Nesse momento fazemos a gravação do arquivo configurador no
dispositivo.
Fig. 14: Fluxo de criação de um projeto em HDL (retirado manual Quartus II)
Projetistas já em estágio avançados podem editar os locais a distribuição de funções na planta do chip (Chip
Editor), mas podem também analisar por meio de simulações as áreas de dissipação de energia na FPGA de
forma mais realística, assim como a temporização dos sinais de forma estimada, porém mais realista. Para
isso, usam-se ferramentas de simulação (Power Analyis, Board-Level Timing, etc, quadro à direita inferior
na fig. 14). Esses procedimentos são avançados e não serão vistos na apostila. Pode-se ainda utilizar o JTAG
e outras ferramentas de software para DEBUGAR seu hardware já na placa (Fig. 14 In-System Verification).
Esse é o processo normal de criação de um projeto utilizando uma linguagem HDL e uma ferramenta EDA.
Agora, vamos analisar como se faz a descrição de hardware.
• VHDL (Very high-speed integrated circuits Hardware Description Language)
VHDL foi originalmente proposta pelo Depto de Defesa americano (DARPA) e depois foi transferida para o
IEEE (Institute of Electrical and Electronics Engineers) que a padronizou. A linguagem é formalmente
conhecida como IEEE 1076, ratificada em 1987, depois revisada em 1993, pequenas alterações foram
introduzidas em 2000 e 2002, e por último, em setembro de 2008 foi aprovado pelo REVCOM a mais
recente versão, IEEE 1076-2008.
A ideia inicial da linguagem de descrição de hardware era padronizar a forma de descrever os circuitos
lógicos de milhares de placas de diversos fornecedores do DARPA, em substituição aos desenhos dos
circuitos; assim, seria possível passar a descrição de uma placa de um fornecedor para outro fornecedor
com mais facilidade. Em seguida, observou-se que a linguagem de descrição do hardware também serve
para simulações, para testar se o circuito opera da forma que se espera. Portanto, um HDL serve também
para simular funcionamento dos circuitos, o que não é objeto desta apostila.
Depois, ferramentas foram criadas para sintetizar circuitos em CPLDs e FPGAs. Sintetizar significa
transformar a descrição dos circuitos em conexões dentro dos CIs de lógica programável, de forma que o
comportamento e as funcionalidades descritas na linguagem se tornem efetivamente circuitos de hardware
dentro dos chips. Nós vamos trabalhar com esta perspectiva.
Quais as vantagens de se utilizar VHDL?
Vantagens Desvantagens
Projeto independente da tecnologia; Hardware gerado é menos otimizado;
Facilidade na atualização dos projetos; Simulações mais lentas que implementações
Intercâmbio de projetos entre equipes de Dificuldade em encontrar pessoal treinado para
desenvolvedores lidar com a linguagem;
Reconfiguração parcial e dinâmica;
Reduz tempo de projeto e custo;
Elimina erros de baixo nível;
Simplifica a documentação
Aumento da performance
Toda linguagem tem um conjunto de regras (chamada sintaxe) que permite a um compilador,
interpretador e/ou sintetizador verificar se não há ambiguidades ou descrições incongruentes. Vamos
então analisar quais os conjuntos de sintaxes básicos de VHDL.
Lembre-se de uma coisa primordial: quando você está trabalhando em um HDL você não está
PROGRAMANDO, no sentido de fazer um programa em C ou assembly, você está DESCREVENDO
um hardware. Portanto, saiba primeiro o que você quer fazer no hardware.
• VHDL (regras e sintaxe)
• VHDL não é sensível à maiúsculas e minúsculas, nem aos espaços inseridos;
• Inserimos comentários em VHDL utilizando dois sinais ‘--‘; depois desses sinais podemos escrever
qualquer coisa que o compilador ignora (até o próximo ENTER);
• Como outras linguagens, um enunciado, comando, declaração em VHDL termina com ‘;’
• VHDL só reconhece os caracteres 1...9 e as letras A-Z ou a-z e ainda o caractere underline ‘_’. Um
identificador (variável, uma porta, ou nome de um sinal) tem que começar com uma letra. Identificadores
não podem também terminar com 2 ‘_´nem ter dois underlines seguidos.
Um exemplo de trecho de VHDL:

-- esta linha tem um comentário
C <= b; -- isto é um comando em que o sinal b é conectado a C
c <= b; -- esta linha de comando é exatamente igual à anterior, porque C é igual a c para VHDL
• As seguintes palavras são reservadas:

access after alias all attribute block
body buffer bus constant exit file
for function generic group in is
label loop mod new next null
of on open out range rem
return signal shared then to type
until use variable wait while with
VHDL está baseada na abordagem da “caixa preta”. Para descrevermos uma coisa a partir de caixas pretas
precisamos seguir um procedimento hierárquico. Em VHDL descrevemos a caixa preta numa seção
chamada ENTITY, que descreve a interface do circuito descrito com o mundo. Porém, o que existe dentro
dessa caixa preta é descrito em outra seção chamada ARCHITECTURE.
Vejamos um exemplo:
----------------------------------------------------------------------------------
-- Company: UFPE
-- Engineer: Joao Ranhel
--
-- Module Name: Circuito Controle Lampada
--
-- Descrição:
-- Circuito que controla uma lampada por múltiplos interruptores
--
----------------------------------------------------------------------------------
library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
-- descrição de uma entidade (a interface de um circuito)

entity Interruptor_3_IN is
-- estas são as portas que conectam a entidade ao mundo externo
Port ( CHV : in STD_LOGIC_VECTOR (2 downto 0);
LED : out STD_LOGIC);
end Interruptor_3_IN;
-- aqui começa a descrição de "como funciona" o circuito

architecture df_Interruptor_3_IN of Interruptor_3_IN is
begin
-- esta declaração cria o circuito XOR com os sinais de entrada

LED <= CHV(0) XOR CHV(1) XOR CHV(2);
end df_Interruptor_3_IN;
As 10 primeiras linhas desse código começam com “--“, ou seja o que vem na frente é comentário, é para
descrever o projeto e será desconsiderado na hora da sintetização. Depois vem as declarações
library IEEE;
Essa parte do código diz para o compilador/sintetizador quais bibliotecas a serem utilizadas na descrição e
quais funções, componentes ou blocos da bibliotecas serão usados. No caso, usamos todos (all). Depois
vemos a descrição da ENTITY, que é a interface do projeto:
entity Interruptor_3_IN is
-- estas são as portas que conectam a entidade ao mundo externo
Port ( CHV : in STD_LOGIC_VECTOR (2 downto 0);
LED : out STD_LOGIC);
end Interruptor_3_IN;
A descrição da caixa preta começa com a palavra-chave entity, então vem o nome do circuito
“Interruptor_3_IN”. Nunca use caracteres com acentos nem espaços nos nomes, e procure usar nomes
que signifiquem o que o circuito faz. Depois vem a palavra-chave is. A descrição dessa caixa preta só
termina com a palavra-chave end, seguida do nome da entidade e ponto e vírgula ‘;’.
No meio da definição da entidade há um bloco (Port) de descrição das portas que entram ou saem da caixa
preta. No exemplo, há um sinal de entrada chamado CHV que é um vetor (um barramento) de 3 bits; quer
dizer, há três sinais/fios chamado CHV que entram na caixa (CHV(2), CHV(1) e CHV(0)). Depois do nome do
sinal vem : in que determina que são fios/sinais de entrada. O tipo do sinal (STD_LOGIC_VECTOR) diz que se
trata de um vetor, e a abrangência (2 downto 0) diz que o vetor tem o bit mais significativo com o index 2,
e o menos significativo com o index 0.
No bloco (Port) também está descrito que existe uma porta chamada LED que é um sinal de saída (: out) e
que é um sinal lógico padrão (STD_LOGIC), ou seja, um fio único por onde o sinal sai da entidade.
A caixa preta descrita acima pode ser representada pelo seguinte diagrama de bloco:
CVH(2)
CVH(1) Interruptor_3_IN LED
CVH(0)
Em seguida no código surge a descrição do que existe dentro dessa caixa preta chamada. O início da
descrição da arquitetura do circuito começa com a palavra-chave architecture.
architecture df_Interruptor_3_IN of Interruptor_3_IN is

begin
-- esta declaração cria o circuito XOR com os sinais de entrada

LED <= CHV(0) XOR CHV(1) XOR CHV(2);
end df_Interruptor_3_IN;
Literalmente, a primeira linha quer dizer: “a arquitetura cujo nome é df_Interruptor_3_IN da caixa preta
chamada Interruptor_3_IN é”. O nome df_Interruptor_3_IN é o nome da arquitetura, você pode
utilizar o nome que quiser, respeitando as regras descritas acima.
A descrição da arquitetura começa com a palavra-chave begin e termina com a palavra-chave end, seguida
do nome da arquitetura e de ponto e vírgula ‘;’. No meio há uma atribuição, um comando que diz: LED
recebe o sinal da saída de (<=) uma porta XOR, cujos sinais de entrada são CHV(0) XOR CHV(1) XOR CHV(2). O
circuito completo descrito no código acima pode ser representado assim:
CVH(2)
CVH(1) LED
CVH(0)
• Estilos de Descrição em VHDL
Em VHDL devemos sempre lembrar que os blocos que estamos descrevendo acontecem em paralelo.
Existem três diferentes estilos ou abordagens para programação em VHDL: fluxo de dados (data flow),
descrição de estruturas (structure) e ainda descrição de comportamento (behavior).
Fluxos de dados são descritos geralmente por meio do operador “<=”, que especifica diretamente as
relações entre sinais. Podemos pensar que o equivalente seria lógica combinacional, ou seja, as saídas
dependem apenas das entradas que são usadas como operadores. Note-se que neste estilo de
programação o projetista descreve o circuito lógico como se estivesse detalhando graficamente. O
projetista tem que descrever as conexões e as operações que ocorrem entre os sinais.
Estruturas são necessárias para conectar hierarquicamente os vários blocos de um sistema digital. Assim, o
estilo estrutural é necessário para compor o bloco lógico hierárquico de maior importância no projeto.
Comportamento é um estilo mais abstrato de descrição de hardware. Neste estilo o projetista apenas diz
como o circuito deve se comportar, sem se importar com “como” estão conectados os elementos lógicos
que executam aquelas funções. Sabemos que o estilo behavioral está sendo utilizado porque a descrição de
comportamento é marcada pelo uso de processos.
Um processo (process) é caracterizado pela palavra-chave process seguido de uma lista de sinais que
disparam aquele processo. Veja o seguinte exemplo:
ARCHITECTURE arq_detecta OF detecta IS
begin
process(clk,sensor_1)
begin
if(rising_edge(clk) and sensor_1='1') then
led <= '1';
else
led <= '0';
end if;
end process;
end arq_detecta;
Dentro dessa arquitetura aparece um processo, descrito a partir da palavra-chave process(). Dentro dos
parênteses está indicado que dois sinais disparam este processo: o sinal clk e o sinal sensor_1. A descrição
do comportamento do circuito começa depois do begin dentro do processo e termina em end process;.
Dentro temos uma estrutura if (alguma condição) then, que termina em end if; e que tem uma alternativa
else no meio. O que é testado (alguma condição) é testado em relação a ser uma verdade booleana; por
exemplo, if (x or 1) then, sempre resultará 1, portanto sempre será executado. Já if (x and y and 0) then,
nunca será executado porque uma AND com entrada zero resulta zero, portanto, neste caso o else seria
executado.
O teste do if do exemplo acima é sobre ter ocorrido o evento de subida do sinal de clock (rising_edge(clk) e
(and) se o sinal do sensor_1 está em nível lógico ‘1’. Se isso ocorrer então a primeira parte do if é
executada e o else será ignorado, portanto, o sinal led assume o valor ‘1’.
Caso contrário, se o sinal sensor_1 estiver em ‘0’, o bloco do if será ignorado e o bloco dentro do else será
executado, fazendo o sinal led ser igual a ‘0’.
Toda vez que o ocorrer um evento (uma variação) no sinal de clk ou no sinal sensor_1 este processo será
executado e estas condições serão testadas.
Tenha em mente que em VHDL os processos acontecem em paralelo, assim, a descrição de hardware pode
ter vários processos mas, fisicamente no CI eles ocorrem em paralelo.
Mais detalhes da linguagem VHDL deve ser buscada nos livros que descrevem detalhes da linguagem. Um
livro indicado é Free Range VHDL Book - Free Range Factory, que pode ser baixado do site:
http://www.freerangefactory.org/dl/free_range_vhdl.pdf
A seguir, vamos descrever uma série de práticas para consolidar o aprendizado dos diversos.
Departamento de Eletrônica & Sistemas - UFPE

Prática 0: Apresentação das placas.
I. PRÁTICA ZERO... as placas ACIONADO o valor gerado para a FPGA

será ‘1’ (+V). Quando soltamos o botão o
Durante o semestre vamos executar práticas sinal enviado para a FPGA é zero volts, ou
no laboratório que dependem do nível lógico ‘0’.
conhecimento de basicamente três módulos: A Fig. 1 mostra a placa de entrada
- placa de circuito impresso de entrada (BASIC_IN), e seu esquema eletrônico é
- placa de circuito impresso de saída mostrado em anexo.
- placa FPGA (Field Programmable Gate Array).
1.2 Placa de saída: possui oito LEDs que
As placas precisam ser conectadas com a indicam se o sinal está em nível lógico ‘1’
FPGA por meio de um cabo ‘flat cable’ de 16 (aceso) ou em nível lógico ‘0’ (apagado). A
vias. Basta encaixar o cabo no conector na placa possui também um display de 7-
placa e o outro lado no conector desejado na segmentos. São na verdade oito LEDs
FPGA. montados na forma de uma matriz que
Tanto a placa de entrada quanto a placa de imitam a forma como escrevemos números.
saída PRECISAM ser energizadas para Como são LEDs, esses displays podem ter
funcionar. A alimentação será feita por meio todos os ânodos dos LEDs ligados em
de um cabo de alimentação com dois fios: comum (ânodo-comum) ou todos os lados
+3,3V e terra (GND). Prestem atenção na dos cátodos em comum. O display utilizado é
POLARIDADE e não troquem esses fios. O ÂNODO COMUM.
pino de alimentação mais próximo do A Fig. 2 mostra uma placa de saída, e o
conector com a FPGA é o fio +3,3V. esquema da placa BASIC_OUT é mostrado
em anexo.
Quem trocar os dois fios vai queimar tanto a
FPGA quanto a placa de entrada/saída.
1.1 Placa de entrada: possui um conjunto de

chaves que nos permitem inserir na FPGA
sinais ‘1’ (+V) ou ‘0’ (zero volts). Cada chave
tem um LED associado e quando ele está
ligado (aceso) o nível lógico será ‘1’ (está
enviando +V para a FPGA). Quando o LED
estiver apagado a tensão enviada para a
FPGA será zero volts, ou seja, nível lógico
‘0’.
Fig. 2: placa BASIC_OUT com cabo flat cable
A. Propostas da aula prática:
1) Conectar uma placa BASIC_IN a uma

placa BASIC_OUT.
Observar quais dos LEDs da placa de saída
pulsam quando os botões são acionados.
2) Ligar e Desligar as chaves (dip-switches)
na placa BASIC_IN de forma que os números
Fig. 1: placa BASIC_IN com flat cable. apareçam no display de 7-segmentos na
placa BASIC-OUT.
A placa também possui DOIS botões que
servirão para gerar pulsos em futuras 3) Explique a lógica pela qual os LEDs
práticas. Enquanto um botão estiver acendem ou apagam nas duas placas, sendo
que um INVERSOR é utilizado como ‘driver’ 3) Fundamentação Teórica: Contém a teoria

(fornecedor) de corrente para cada um dos utilizada na prática. Uma breve descrição
LEDs. sobre o que faz o circuito (no caso o
comparador de magnitude). Ou seja, explique
4) Explique como funciona a lógica que
de onde saiu o circuito inicial;
acende os LEDS no DISPLAY, uma vez que
o display é do tipo ÂNODO COMUM (ou seja, 4) Metodologia: deve conter o arranjo
todos os ânodos dos diodos leds do display experimental, os métodos de medição e os
estão ligados em +3,3V) resultados da simulação/experimentos;
5) Explique para que servem os resistores R1 5) Análise: deve conter a análise dos
... R8 na placa BASIC_OUT. resultados experimentais em comparação
com os resultados teóricos e/ou simulados.
* Monte os circuitos por etapas, e teste cada
etapa, ou seja, garanta que a placa que você Dificuldades e problemas com resultados
ligou está funcionando. devem estar registrados nessa seção;
B. Execução 6) Conclusões: apresente as conclusões do
Espera-se aqui que o aluno alimente as duas relatório. O que se pode afirmar sobre os
placas e que as interconecte modelos utilizados e comentários sobre as
CORRETAMENTE. Observe os vários níveis aplicações podem estar nessa seção.
de tensão que significam ‘1’ ou ‘0’ lógico.
7) Referências (Opcional): deve conter as
Observe que a interpretação do conjunto de referências utilizadas na prática.
‘1s’ e ‘0s’ depende do contexto, por exemplo,
quando um número binário é representado
por níveis lógicos e quando um número é
III. Ferramentas e Literatura
representado por um conjunto de lâmpadas
ligadas ou desligadas.
- Programa QUARTUS II da Altera ou ISE da XILINX;
II. Organização do Relatório - Placa FPGA ou CPLD;
O relatório deve ser organizado nos - Livros:

seguintes tópicos (os títulos dos tópicos não - B. Mealy, F. Tappero, Free Range VHDL. Rel: 1.17/2013.
precisam ser os mesmos indicados) (Usem  http://www.freerangefactory.org
200 palavras por tópico – aprendam a ser concisos); - Pong P. FPGA Prototyping by VHDL Examples: Xilinx
1) Resumo (Opcional): Deve conter um breve Spartan-3 Version, 1 ed. Wiley-Interscience; 2008.
resumo sobre o trabalho com os principais
resultados obtidos;
2) Introdução/Motivação: Deve conter uma
breve introdução/motivação sobre a prática,
com objetivos e roteiros
ESQUEMA DA PLACA BASIC_IN (Placa de ENTRADA de Sinais)

ESQUEMA DA PLACA BASIC_OUT (Placa de SAÍDA de Sinais)

1.3 Placa de FPGA: criada e montada aqui no DES da UFPE, a placa de FPGA é baseada no
circuito integrado CYCLONE IV da empresa Altera.
A alimentação das placas FPGA pode ser utilizados para qualquer função que você
feita de duas formas: pelo próprio conector desejar.
mini-USB (preferível), ou por meio de dois A placa FPGA também tem 4 saídas de 3,3V
pinos de entrada (+V), e neste caso, que podem ser utilizadas para alimentar as
certifique-se da polaridade da conexão. No placas básicas de entrada e saída.
conector mini-USB a tensão de entrada é
+5V e os reguladores internos tratam de
baixar para os valores corretos. Se utilizar os
pinos de entrada, certifique-se de que é uma
tensão estabilizada de +5V.
As placas precisam ser CONFIGURADAS

(ou programadas) via JTAG, que é um
conector especial de 10 pinos na placa.
Conecte o cabo de configuração da Altera
(USB Blaster) no conector JTAG e o outro
lado do cabo na USB do micro.
Fig. 1: placa FPGA – DES / UFPE.
Entre no programa QUARTUS II e escolha
como dispositivo a FPGA Cyclone IV
Outras placas que forem desenvolvidas para
(EP4CE6C22I8L), que é o chip utilizado em
este sistema podem ter que precisar ter suas
nosso projeto.
próprias fontes de energia. O regulador
interno dessa placa pode fornecer no máximo
Descreva o hardware desejado em VHDL,
800 mA – suficiente para a própria FPGA + 4
conforme as práticas seguintes.
placas Basic_IO, mas não para outros fins.
Pode acontecer também de uma placa (e.g.
Depois faça a síntese da descrição. O
Arduino) é que fornecer +5V para esta placa
Quartus II vai gerar um arquivo de bits ‘1’s e
FPGA.
‘0’s. É necessário também configurar os
nomes dos sinais internamente descritos no
A placa tem uma chave LIGA/DESLIGA.
código VHDL com os pinos reais do CI
Certifique-se de que esteja ligada antes de
FPGA. Para isso, tem que entrar no PIN
gravar o circuito. Um LED azul acende
PLANNER e fazer as conexões.
quando a placa está energizada e ligada.
Outro LED (vermelho) indica que a FPGA
Depois disso, com os pinos configurados,
está programada (algumas versões da placa
faça a gravação do arquivo sintetizado com
não tem este LED). É preciso que os dois
os pinos definidos na FPGA. Utilize o módulo
LEDs estejam ligados para indicar que a
gravador no QUARTUS II – e certifique-se de
que a placa FPGA (o chip EP4CE6C22I8L) FPGA está programada.
foi reconhecida. Depois de programado, o
Há um botão de RESET na placa – caso
circuito que você descreveu estará
você o pressione a FPGA será resetada e
configurado na FPGA.
toda a programação se perde (note que o
Se você desligar a energia da placa você terá LED vermelho apaga).
que gravar o chip FPGA novamente, porque
a memória de configuração interna do chip é Nas versões da placa com memória de
configuração, a FPGA se reconfigura auto-
do tipo RAM volátil.
maticamente depois do reset ou de ser
ligada. Para gravar a memória da placa
Conecte os cabos flat cables na FPGA e
FPGA (quando a placa tem memória) é
pode começar a operar seu circuito.
preciso utilizar o conector AS, em vez do
JTAG.
A placa FPGA tem quatro terminais com 16
pinos de saída, portanto, temos 48 pinos de
entrada ou saída prontos para serem
ESQUEMA DA PLACA BASIC_FPGA – FOLHA 1

ESQUEMA DA PLACA BASIC_FPGA – FOLHA 2

KIT Altera DE2-115

Outra opção para executarmos as práticas será utilizar o kit Altera DE2-115. Este kit utiliza uma
FPGA da mesma família – Altera Cyclone IV EP4CE115F29C7N. Contudo, a placa do kit tem uma
série de recursos a mais que não serão utilizados em nossas práticas, como por exemplo um
display de LCD, saída VGA, memórias, conversores A/D, etc.
O kit contém chaves deslizantes (sliders) e pulsadores push-bottom de entrada (INPUTS) na
própria placa de circuito impresso (PCB – printed circuit board). Também possui elementos de
saída como LEDs e DISPLAYs. No kit há 18 chaves deslizantes (SW0...SW 17) que não tem
debouncing (servem apenas para entrada de níveis lógicos), quatro pulsadores (KEY0 ... KEY3)
com debouncing que servem para entrada de pulsos, oito LEDS verdes (LEDG0 ... LEDG7) e 18
vermelhos (LEDR0 ... LEDR17). Possui ainda oito displays de 7-segmentos (HEX0 ... HEX7) ânodo
comum, ou seja, são ativados em ‘0’ (acendem o segmento com um ZERO). Estes são os
dispositivos de entrada e saída que utilizaremos dessa placa em Técnicas Digitais.
Cada um desses pinos de I/O está conectado a um pino da FPGA, portanto é menos maleável
que nosso kit, contudo é mais prático, porque não precisamos usar flat-cables. Dessa forma, ao
escolher uma chave ou um LED ou display, certifique-se de que a pinagem está de acordo com o
manual da placa (reproduzido a seguir).
Signal Name FPGA Pin No. Description I/O Standard

Chaves deslizantes (no debouncing) =’0’ posição para fora =’1’ para dentro da placa
SW[0] PIN_AB28 Slide Switch[1]
SW[1] PIN_AC28 Slide Switch[3]
SW[3] PIN_AD27 Slide Switch[3]
SW[6] PIN_AD26 Slide Switch[6]
SW[13] PIN_AA24 Slide Switch[13]
SW[16] PIN_Y24 Slide Switch[16]
SW[17] PIN_Y23 Slide Switch[17]
Push-bottoms (com debouncing) =’0’ se pressionado =’1’ não pressionado
KEY[0] PIN_M23 Push-button[0]
KEY[1] PIN_M21 Push-button[1]
KEY[2] PIN_N21 Push-button[2]
KEY[3] PIN_R24 Push-button[3]
LEDs VERDES (cátodo comum = acende com ‘1’)
LEDG[0] PIN_E21 LED Green[0]
LEDG[4] PIN_H21 LED Green[4]
LEDG[5] PIN_G20 LED Green[5]
LEDG[8] PIN_F17 LED Green[8]
LEDs VERMELHOS (cátodo comum = acende com ‘1’)
LEDR[0] PIN_G19 LED Red[0]
LEDR[1] PIN_F19 LED Red[1]
LEDR[2] PIN_E19 LED Red[2]
LEDR[5] PIN_E18 LED Red[5]
LEDR[6] PIN_J19 LED Red[6]
LEDR[7] PIN_H19 LED Red[7]
CLOCK de input (gerador de clock da placa – 50 MHz)
CLOCK_50 PIN_Y2 50 MHz clock input
CLOCK2_50 PIN_AG14 50 MHz clock input
CLOCK3_50 PIN_AG15 50 MHz clock input
Signal Name FPGA Pin No. Description I/O Standard

DISPLAY 7seg - 0 (ânodo comum = acende segmento com nível ‘0’)
HEX0[0] PIN_G18 Seven Segment Digit 0[0]
HEX0[1] PIN_F22 Seven Segment Digit 0[1]
HEX0[2] PIN_E17 Seven Segment Digit 0[2]
HEX0[3] PIN_L26 Seven Segment Digit 0[3]
HEX0[4] PIN_L25 Seven Segment Digit 0[4]
HEX0[5] PIN_J22 Seven Segment Digit 0[5]
HEX0[6] PIN_H22 Seven Segment Digit 0[6]
DISPLAY 7seg - 1
HEX1[0] PIN_M24 Seven Segment Digit 1[0]
HEX1[1] PIN_Y22 Seven Segment Digit 1[1]
HEX1[2] PIN_W21 Seven Segment Digit 1[2]
HEX1[5] PIN_U23 Seven Segment Digit 1[5]
DISPLAY 7seg - 2
HEX2[0] PIN_AA25 Seven Segment Digit 2[0]
DISPLAY 7seg - 3
HEX3[0] PIN_V21 Seven Segment Digit 3[0]
HEX3[2] PIN_AB20 Seven Segment Digit 3[2]
HEX3[4] PIN_AD24 Seven Segment Digit 3[4]
HEX3[5] PIN_AF23 Seven Segment Digit 3[5]
DISPLAY 7seg - 4
HEX4[2] PIN_AG21 Seven Segment Digit 4[2]
HEX4[3] PIN_AH21 Seven Segment Digit 4[3]
HEX4[4] PIN_AE19 Seven Segment Digit 4[4]
DISPLAY 7seg - 5
HEX5[1] PIN_AC18 Seven Segment Digit 5[1]
DISPLAY 7seg - 6
HEX6[6] PIN_AC17 Seven Segment Digit 6[6]
DISPLAY 7seg - 7

Prática 01: Lógica Combinacional – Portas Lógicas em VHDL.
I. Experimento e Simulação 1) Resumo (Opcional): Deve conter um breve

Considere este problema: em uma sala há resultados obtidos;
três portas (A, B, C). Em cada porta há um
interruptor que pode estar ligado ‘1’ ou
desligado ‘0’.
A C
S1 S3
3) Fundamentação Teórica: Contém a teoria
utilizada na prática. Uma breve descrição
B S2
Fig. 1 – . sobre o que faz o circuito (no caso o
comparador de magnitude). Ou seja, explique
Em qualquer porta que você entrar/sair você de onde saiu o circuito inicial;
aciona o interruptor (muda o estado dele de
4) Metodologia: deve conter o arranjo
‘1’’0’ ou de ‘0’’1’) e a lâmpada muda seu
experimental, os métodos de medição e os
estado (acende ou apaga). Use um LED.
resultados da simulação/experimentos;
A. Propostas da aula prática: 5) Análise: deve conter a análise dos
resultados experimentais em comparação
1) Descrever o circuito que realiza o controle com os resultados teóricos e/ou simulados.
da lâmpada usando VHDL e o estilo “data- Dificuldades e problemas com resultados
flow”. devem estar registrados nessa seção;
* Monte os circuitos por etapas, e teste cada 6) Conclusões: apresente as conclusões do
etapa, assim você garante que não vai relatório. O que se pode afirmar sobre os
passar para módulos mais complexos sem modelos utilizados e comentários sobre as
que os módulos mais simples estejam aplicações podem estar nessa seção.
funcionando.
7) Referências (Opcional): deve conter as
B. Execução referências utilizadas na prática.
Espera-se aqui que o aluno implante circuitos
em CPLD ou em FPGA, e não apenas
simule.
Esteja atento que os níveis lógicos das
CPLDs e FPGAs são 3,3V para entradas e - Programa QUARTUS II da Altera ou ISE da XILINX;
saídas. Pode-se utilizar LEDs para medir
saídas e chaves DIP-Switches para entrada - Placa FPGA ou CPLD;
dos níveis lógicos. Utilize as placas - Livros:
BASIC_IN e BASIC_OUT. Preste atenção
- B. Mealy, F. Tappero, Free Range VHDL. Rel: 1.17/2013.
nos pinos e sinais utilizados e faça a escolha http://www.freerangefactory.org
correta no PIN PLANNER.
- Pong P. FPGA Prototyping by VHDL Examples: Xilinx
Spartan-3 Version, 1 ed. Wiley-Interscience; 2008.
II. Organização do Relatório
O relatório deve ser organizado nos
seguintes tópicos (os títulos dos tópicos não
precisam ser os mesmos indicados) (Usem no
máximo  200 palavras por tópico – aprendam a ser
concisos);
Código em VHDL (esta é uma proposta... faça a sua própria solução).

----------------------------------------------------------------------------------
-- Company: UFPE
-- Engineer: João Ranhel
--
-- Create Date: 01/08/2012
-- Design Name: Práticas de Técnicas Digitais
-- Module Name: Circuito Controle Lâmpada
--
-- Descrição:
-- Circuito que controla uma lâmpada por múltiplos interruptores
-- O estilo utilizado é somente dataflow
----------------------------------------------------------------------------------
library IEEE;
-- descrição de uma entidade (a interface de um circuito COM O MUNDO EXTERIOR)

entity Pratica_01 is
-- estas são as portas que conectam essa entidade ao mundo externo
Port ( s1, s2, s3 : in STD_LOGIC;
lamp : out STD_LOGIC);
end Pratica_01;
-- aqui começa a descrição de "como funciona" este circuito
architecture df_Pratica_01 of Pratica_01 is

begin
-- esta declaração cria o circuito XOR com
lamp <= s1 XOR s2 XOR s3;
end df_Pratica_01;
-- -------------------------------------------------------------------------------------
----------
Como Interligar as placas:
1 – lembre-se de alimentar as placas de entrada e saída. O terminal +V está sempre mais

próximo do conector do flat cable.
2 – Os terminais +V e GND para alimentar as placas E/S estão marcados na FPGA.
3 – Escolha o conector que desejar na FPGA. Conecte o flat cable tanto na FPGA quanto nas
placas de Entrada/Saída sempre com os cabos voltados para fora das placas.
Dois modos de ligar as placas Entrada e Saída na FPGA (lembre-se de configurar os pinos no
PIN PLANNER)

Prática 02: Lógica Combinacional – ENCODER (exercício da Caixa d’água)
I. Experimento e Simulação TABELA VERDADE:

Considere o exercício feito em sala, na qual ENTRADAS SAÍDAS
vários sensores (bóias) indicam o nível de
H G F E D C B A D3 D2 D1 D0
água numa caixa dágua.
Nosso projeto foi criar um circuito digital que 1 1 1 1 1 1 1 1 1 0 0 0
codificasse as entradas e gerasse como 0 1 1 1 1 1 1 1 0 1 1 1
saída um número binário BCD. 0 0 1 1 1 1 1 1 0 1 1 0
0 0 0 1 1 1 1 1 0 1 0 1
0 0 0 0 1 1 1 1 0 1 0 0
0 0 0 0 0 1 1 1 0 0 1 1
0 0 0 0 0 0 1 1 0 0 1 0
0 0 0 0 0 0 0 1 0 0 0 1
0 0 0 0 0 0 0 0 0 0 0 0

Fig. 1 – Problema da Caixa d’água e o diagrama de
blocos do ENCODER.
seguintes tópicos (Usem no máximo  200
palavras/tópico – aprendam a ser sintéticos);
A partir deste bloco, construir em VHDL um
codificador (encoder) de 8 entradas para 1) Resumo (Opcional): Deve conter um breve
BCD (4 bits) que considera a prioridade dos resumo sobre o trabalho com os principais
sinais de maior valor (H>G>F>E>D>C>B>A) resultados obtidos;
1) Descrever um circuito codificador com
prioridade (H>...>A), em VHDL. Vamos usar 3) Fundamentação Teórica: Contém a teoria
a estrutura WITH e SELECT para desenhar o utilizada nessa prática. Uma breve descrição
circuito a partir da tabela da verdade apenas. sobre o que fazem os circuitos (encoders).
Ou seja, explique de onde saiu o circuito
Neste projeto vamos também introduzir o inicial, conforme desenvolvido em sala;
conceito de LOGIC_VECTOR em VHDL.
 Logic Vector permite que você entre com um experimental, os métodos de medição e os
conjunto de dados (um barramento) e determine resultados da simulação/experimentos;
a dimensão desse barramento (ou seja, a
quantidade de bits que o barramento vai ter). 5) Análise: contém a análise dos resultados
experimentais em comparação a teoria.
 A tabela a seguir mostra o circuito conforme Dificuldades e problemas devem estar
desenvolvemos em sala, agora considerando registrados nessa seção;
apenas que a chave maior é prioritária
6) Conclusões: apresente as conclusões do
2) DESAFIO: tente modificar o código para relatório.
15 chaves de entrada... 7) Referências (Opcional): deve conter as
referências utilizadas na prática.
B. Execução
Espera-se aqui que o aluno sintetize e
implante os circuitos em CPLD/FPGA.
----------------------------------------------------------------------------------
-- Company: UFPE
--
-- Create Date: 09/04/2016
-- Module Name: Circuito ENCODER 8 inputs para BCD
--
-- Descrição:
-- Circuito que apresenta a estrutura WITH SELECT e o conceito de LOGIC_VECTOR
----------------------------------------------------------------------------------
library IEEE;
-- descrição de uma entidade (a interface de um circuito COM O MUNDO EXTERIOR)

--conforme aprendemos até agora, a entity seria assim (note que está comentado...)
-- entity Encoder_8IN_BCD_Prior is
-- Port ( A, B, C, D, E, F, G, H : in STD_LOGIC;
-- D3, D2, D1, D0 : out STD_LOGIC);
-- end Encoder_8IN_BCD_Prior;
-- PORÉM, vamos utilizer o conceito de LOGIC_VECTOR para definir entrada/saída
entity Encoder_8IN_BCD_Prior is
-- estas são as portas NA FORMA DE VETORES que conectam essa entidade ao mundo externo
Port ( I : in STD_LOGIC_VECTOR(7 downto 0);
D : out STD_LOGIC_VECTOR(3 downto 0));
end Encoder_8IN_BCD_Prior;
-- aqui começa a descrição de "como funciona" este circuito

architecture df_Encoder_8IN_BCD_Prior of Encoder_8IN_BCD_Prior is
begin
-- esta estrutura cria um circuito a partir de uma tabela verdade
with I select
D(3 downto 0) <=
"1000" when "11111111", -- a boia #8 está ativa, sai BCD = 8
"0111" when "01111111", -- a boia #8 está desativada e #7 ativa, BCD = 7
"0110" when "00111111", -- # 6 com prioridade
"0101" when "00011111", -- # 5
"0100" when "00001111", -- # 4
"0011" when "00000111", -- # 3
"0010" when "00000011", -- # 2
"0001" when "00000001", -- # 1
"0000" when others; -- se nenhuma boia está ativa
end df_Encoder_8IN_BCD_Prior;
-- -----------------------------------------------------------------------------------------------

Prática 03: Lógica Combinacional - Comparador de 4 bits em VHDL
I. Experimento e Simulação BASIC_IN e BASIC_OUT. Preste atenção

nos pinos e sinais utilizados e faça a escolha
Considere o circuito da Fig. 1. correta no PIN PLANNER.

precisam ser os mesmos indicados) (Usem no
máximo  200 palavras por tópico – aprendam a ser
concisos);
1) Resumo (Opcional): Deve conter um breve

resultados obtidos;
Fig. 1 – 2 comparadores de 4 bits em cascata.
Trata-se de dois circuitos comparadores de utilizada na prática. Uma breve descrição
4-bits ligados em cascata, formando um sobre o que faz o circuito (no caso o
comparador de 8 bits. comparador de magnitude). Ou seja, explique
de onde saiu o circuito inicial;
A. Propostas da aula prática: 4) Metodologia: deve conter o arranjo
experimental, os métodos de medição e os
1) Descrever um circuito comparador de 1-bit resultados da simulação/experimentos;
em VHDL usando o estilo “data-flow”.
5) Análise: deve conter a análise dos
2) Descrever um circuito comparador de 4- resultados experimentais em comparação
bits usando estilo “estrutural” a partir do com os resultados teóricos e/ou simulados.
componente descrito no item anterior, tal que
forme um bloco lógico como um dos circuitos Dificuldades e problemas com resultados
da Fig. 1. devem estar registrados nessa seção;
3) Tarefa: Descreva um circuito comparador 6) Conclusões: apresente as conclusões do
de 8-bits tal como o desenho da Fig. 1, relatório. O que se pode afirmar sobre os
utilizando o estilo “estrutural”, a partir dos modelos utilizados e comentários sobre as
circuitos anteriores. aplicações podem estar nessa seção.
* Monte os circuitos por etapas, e teste cada 7) Referências (Opcional): deve conter as
etapa, assim você garante que não vai referências utilizadas na prática.
passar para módulos mais complexos sem
que os módulos mais simples estejam
funcionando. III. Ferramentas e Literatura
B. Execução
Espera-se aqui que o aluno implante os - Programa QUARTUS II da Altera ou ISE da XILINX;
circuitos em CPLD ou em FPGA, e não - Placa FPGA ou CPLD;
apenas simule.
- Livros:
Esteja atento que os níveis lógicos das - B. Mealy, F. Tappero, Free Range VHDL. Rel: 1.17/2013.
CPLDs e FPGAs são 3,3V para entradas e http://www.freerangefactory.org
saídas. Pode-se utilizar LEDs para medir
- Pong P. FPGA Prototyping by VHDL Examples: Xilinx
saídas e chaves DIP-Switches para entrada
Spartan-3 Version, 1 ed. Wiley-Interscience; 2008.
dos níveis lógicos. Utilize as placas
----------------------------------------------------------------------------------
-- Company: UFPE
--
-- Create Date: 08/17/2013
-- Module Name: Comparador de 1 bit - dataflow
--
-- Descrição:
-- Módulo comparador de 1 BIT de A com 1 bit de B
-- que será usado como COMPONENTE num comparador de 4 bits
----------------------------------------------------------------------------------
library IEEE;
-- descrição de uma entidade (a interface de um circuito) que compara 1 bit

entity Igual_1bit is
Port ( A, B : in STD_LOGIC;
AigB : out STD_LOGIC);
end Igual_1bit;
-- aqui começa a descrição de "como funciona" este circuito comparador de 1 bit

architecture df_Igual_1bit of Igual_1bit is
signal p0, p1 : std_logic;
begin
-- estas declarações fazem os produtos dos termos (AND)
p0 <= (not A) and (not B);
p1 <= A and B;
-- esta declaração faz a soma(OR) dos termos

AigB <= p0 or p1;
end df_Igual_1bit;
-- esta forma de escrever (soma de produtos) é apenas didática...

-- seria possível (1) não declarar p0 e p1,
-- (2) fazer uma única linha, assim:
-- AigB <= ((not A) and (not B)) or (A and B);
-- ------------------------------------------------------------------------------
----------------------------------------------------------------------------------
-- Company: UFPE
--
-- Create Date: 08/17/2013
-- Module Name: Comparador de 4 bits - Estrutural + dataflow
--
-- Descrição:
-- Este módulo é a ESTRUTURA principal de um comparador de 4 bits
-- criado a partir do componente 'Igual_1bit' que compara o bit A com B
-- (obs: este é um exemplo didático de como se monta estrutura com componentes
----------------------------------------------------------------------------------
library IEEE;
-- esta é a declaração da entidade (da interface do circuito com o mundo)

entity Comparador_4_bits is
-- aqui declaramos as portas de entrada e saída da entidade
Port ( A : in STD_LOGIC_VECTOR (3 downto 0);
B : in STD_LOGIC_VECTOR (3 downto 0);
A_igual_B : out STD_LOGIC);
end Comparador_4_bits;
-- aqui começa a descrição de como conectar 4 comparadores de 1Bit numa ESTRUTURA

architecture str_Comparador_4_bits of Comparador_4_bits is
signal X : STD_LOGIC_VECTOR (3 downto 0); -- 4 sinais p/ interligar componentes
begin
-- instancia o comparador do bit '0' usando Igual1
-- work.Igual_1bit indica biblioteca do prj e a entity que vamos usar
ig_bit0 : entity work.Igual_1bit(df_Igual_1bit)
-- port map = como se conectam as portas de Igual1 aos sinais internos
port map(A => A(0), B => B(0), AigB => X(0));



-- uma porta AND une os 4 sinais de X(0...3) porque A=B apenas quando todos forem =1
(AND)
A_igual_B <= X(0) and X(1) and X(2) and X(3);
end str_Comparador_4_bits;
-- OBS: O MESMO RESULTADO se obtém com o circuito descrito abaixo apenas com dataflow:
-- architecture str_cmp4_bits of Compara_4_bits is

-- signal X : std_logic_vector (3 downto 0);
-- begin
-- X(0) <= A(0) xnor B(0); -- o sinal X(0) recebe o resultado de A(0)
xnor B(0)
-- X(1) <= A(1) xnor B(1);
-- X(2) <= A(2) xnor B(2);
-- X(3) <= A(3) xnor B(3);
-- A_igual_B <= X(0) and X(1) and X(2) and X(3);
-- end str_cmp4_bits;
-- OBS: O MESMO RESULTADO se obtém também com o código seguinte, que descreve FIG 1.
-- architecture str_cmp4_bits of Compara_4_bits is
-- signal X : std_logic_vector (3 downto 0);
-- begin
-- X(0) <= A(0) xor B(0); -- o sinal X(0) recebe o resultado de A(0)
xnor B(0)
-- X(1) <= A(1) xor B(1);
-- X(2) <= A(2) xor B(2);
-- X(3) <= A(3) xor B(3);
-- A_igual_B <= X(0) nor X(1) nor X(2) nor X(3);
-- end str_cmp4_bits
-- --------------------------------------------------------------------------------

Prática 04: Lógica Combinacional – Somador e Subtratores completos
I. Experimento e Simulação 3) Descreva um circuito que faça a

Considere o circuito da Fig. 1. soma/subtração, com a entrada M.
* Monte os circuitos por etapas, e teste cada
etapa, assim você garante que não vai
passar para módulos seguinte sem que os
módulos mais simples estejam ok.
B. Execução
Espera-se aqui que o aluno sintetize e
implante os circuitos em CPLD/FPGA.
Fig. 1 – Somador/Subtrator completo de 1 bit (Img do II. Organização do Relatório

livro Idoeta/Capuano, fig 5.57- pag 225).
A partir deste circuito, construir em VHDL um seguintes tópicos (Usem no máximo  200
palavras/tópico – aprendam a ser sintéticos);
somador/subtrator completo de 4 bits.
resultados obtidos;
sobre o que fazem os circuitos (somador e
Fig. 2 – Somador/Subtrator de 4 bits. subtrator). Ou seja, explique de onde saiu o
circuito inicial, conforme desenvolvido em
Trata-se de um bloco lógico capaz de somar sala;
dois números digitais de 4-bits (A+B) quando 4) Metodologia: deve conter o arranjo
a entrada (modo) M = 1, ou subtrair (A-B) experimental, os métodos de medição e os
quando a entrada M = 0. O circuito gera uma resultados da simulação/experimentos;
saída S0...S3 como resultado e um 5) Análise: deve conter a análise dos
transporte (Ts) quando a soma é maior que resultados experimentais em comparação
“1111” ou quando a subtração resultar um com os resultados teóricos e/ou simulados.
número negativo (se A>B).
Dificuldades e problemas com resultados
A. Propostas da aula prática: devem estar registrados nessa seção;
6) Conclusões: apresente as conclusões do
1) Descrever um circuito somador completo relatório. O que se pode afirmar sobre os
de 1-bit em VHDL usando o estilo “data-flow”. modelos utilizados e comentários sobre as
Depois descrever o circuito subtrator aplicações podem estar nessa seção.
completo também utilizando “data-flow”. 7) Referências (Opcional): deve conter as
2) Descrever um circuito somador e também referências utilizadas na prática.
o subtrator de 4-bits usando o estilo
“estrutural”, a partir dos componentes
descritos no item anterior.
Descrição de um circuito SOMADOR COMPLETO:

----------------------------------------------------------------------------------
-- Company: UFPE
-- Create Date: 08/12/2013
-- Module Name: Somador e Subtrator Completo 1Bit - dataflow
-- Descrição:
-- Este módulo soma UM BIT presente em A com B, quando (M=0)
-- subtrai 1 bit de A do bit em B, quando (M=1)
-- dependendo da variável M (que controla o modo de operação)
-- O módulo leva em conta o Carry IN (variável Te) e sai Carry Out (em Ts)
----------------------------------------------------------------------------------
library IEEE;
-- esta é a declaração da entidade (da interface do componente com o mundo)
entity Soma_Sub_1Bit is
Port ( A, B, Te, M : in STD_LOGIC;
S, Ts : out STD_LOGIC);
end Soma_Sub_1Bit;
architecture df_Soma_Sub_1Bit of Soma_Sub_1Bit is

begin
-- aqui começa a descrição em dataflow dos circuitos
S <= A xor B xor Te;
Ts <= (B and Te) or ((M xor A) and (B or Te));
end df_Soma_Sub_1Bit;
-----.---------..---------..---------..---------..---------..---------..---------.------
-- Company: UFPE
-- Create Date: 08/17/2013
-- Module Name: Somador e Subtrator Completo 4-Bits - Structural + dataflow
-- Descrição:
-- Este módulo soma/subtrai 4 bits de A com B, dependendo do valor da entrada M.
-- Se M=0 soma, se M=1 subtrai. O resultado sai em S(3...0) e Carry_Out em Ts.
----------------------------------------------------------------------------------
library IEEE;

entity Somador_Subtrator_4bits is
Port ( A, B : in STD_LOGIC_VECTOR (3 downto 0);
M : in STD_LOGIC;
S : out STD_LOGIC_VECTOR (3 downto 0);
Ts_out : out STD_LOGIC);
end Somador_Subtrator_4bits;
-- esta é a declaração da arquitetura (que descreve a estrutura do circuito)

architecture st_Somador_Subtrator_4bits of Somador_Subtrator_4bits is
signal xT : STD_LOGIC_VECTOR (3 downto 0);
signal Te0: STD_LOGIC;
begin
-- o primeiro sinal de Carry_IN é zero sempre, isso força esta condição...
Te0 <= '0';
-- aqui instancia os componentes somador/subtrator de 1 bit para o bit (0) ... (3)
Soma_Sub_0: entity work.Soma_Sub_1Bit(df_Soma_Sub_1Bit)
Port map(A=>A(0), B=>B(0), Te=>Te0, M=>M, S=>S(0), Ts=> xT(0));

Port map(A=>A(1), B=>B(1), Te=>xT(0), M=>M, S=>S(1), Ts=> xT(1));


-- o sinal de Carry_Out é o próprio sinal de saida Ts do módulo Soma_Sub_3
Ts_out <= xT(3);
end st_Somador_Subtrator_4bits;
-- ---------------------------------------------------------------------

Prática 05: Lógica Combinacional – Decoder 7 segmentos
I. Experimento e Simulação os níveis lógicos das CPLDs e FPGAs

são 3,3V para entradas e saídas.
Considere o circuito da Fig. 1.
seguintes tópicos (os títulos dos tópicos
não precisam ser necessariamente os
mesmos indicados) (Usem no máximo 
200 palavras/tópico – sejam concisos);
1) Resumo (Opcional): Deve conter um

breve resumo sobre o trabalho com os
principais resultados obtidos;
Fig. 1 – Decoder BCD / 7-segmentos.
2) Introdução/Motivação: Deve conter
Trata-se de um bloco lógico (decoder) uma breve introdução/motivação sobre
que transforma uma entrada BCD em a prática, com objetivos e roteiros
sinais que acendem ou apagam os 3) Fundamentação Teórica: Contém a
LEDs de um display de 7 segmentos. teoria utilizada na prática. Uma breve
descrição sobre o circuito decoder de
A. Propostas da aula prática: BCD-7seg.
1) Descrever um circuito em VHDL 4) Metodologia: deve conter o arranjo
usando o estilo “data-flow” que faça a experimental, os métodos de medição
conversão BCD para 7 segmentos. e os resultados da simulação;
Utilize o comando condicional with – 5) Análise: contém análise / resultados
select (com o sinal BCD como a experimentais em comparação com os
expressão de seleção). Note que with- resultados teóricos e/ou simulados.
select ainda é estilo data-flow!!!
Dificuldades e problemas devem estar
2) Utilizando o estilo VHDL “estrutural” registrados nessa seção;
agregue este decoder no circuito
somador / subtrator da prática passada 6) Conclusões: apresente as
(prática 03). O circuito utilizará apenas conclusões do relatório. O que se pode
um dígito para mostrar o resultado. afirmar sobre os modelos utilizados e
Contudo, utilize o ponto decimal do comentários sobre as aplicações
display para mostrar Carry-OUT (Ts). podem estar nessa seção.
3) DESAFIO (obrigatório): descreva 7) Referências (Opcional): deve conter
em VHDL o projeto da caixa d’água as referências utilizadas na prática.
desenvolvido em sala, incluindo o
decoder para 7-segmentos. Faça você III. Ferramentas e Literatura
mesmo o código e inclua no relatório.
* Monte os circuitos por etapas, e teste
- Placa FPGA ou CPLD;
cada etapa, assim você garante que
não vai passar para módulos mais - Livros:
complexos sem que os módulos mais - B. Mealy, F. Tappero, Free Range VHDL. Rel:
simples estejam funcionando. 1.17/2013. http://www.freerangefactory.org
B. Execução
Espera-se que o aluno implemente
circuitos em FPGA. Esteja atento que
Descrição de um circuito DECODIFICADOR BCD-7-SEG:

----------------------------------------------------------------------------------
-- Company: UFPE
--
-- Create Date: 08/15/2013
-- Module Name: Decodificador_7_segmentos - Dataflow
--
-- Descrição:
-- Este módulo decodifica um valor em binário (numBCD) para 7 segmentos (sseg)
-- O módulo está escrito para cátodo comum e para ânodo comum
-- OBS: O ponto é o MSB sseg(7), g = sseg(6), e a = sseg(0)
----------------------------------------------------------------------------------
library IEEE;
-- caixa preta: entra um número BCD e sai 7seg + DP

entity Decoder_7seg is
Port (numBCD : in STD_LOGIC_VECTOR (3 downto 0); -- nums BCD de 4 bits
sseg : out STD_LOGIC_VECTOR (7 downto 0)); -- sinal 7 segmtos + dp
end Decoder_7seg;
-- declaração da arquitetura, que descreve em dataflow como o circuito se comporta...

architecture df_Decoder_7seg of Decoder_7seg is
begin
-- força desligamento do ponto (para ligá-lo é preciso uma lógica adicional)

sseg(7) <= '1';
-- conversão para 7-seg ANODO COMUM-dataflow (pode ser copiado em outros projs)
with numBCD select
sseg(6 downto 0) <=
"1000000" when "0000", -- alg 0 decimal, anodo comum
"1111001" when "0001", -- 1
"0100100" when "0010", -- 2
"0110000" when "0011", -- 3
"0011001" when "0100", -- 4
"0010010" when "0101", -- 5
"0000010" when "0110", -- 6
"1111000" when "0111", -- 7
"0000000" when "1000", -- 8
"0010000" when "1001", -- 9
"0001000" when "1010", -- A (hexa) anodo comum
"0000011" when "1011", -- B
"1000110" when "1100", -- C
"0100001" when "1101", -- D
"0000110" when "1110", -- E
"0001110" when "1111", -- F
"1111111" when others;
-- conversão para 7-seg CÁTODO COMUM-dataflow (pode ser copiado em outros projs)
-- with numBCD select
-- sseg(6 downto 0) <=
-- "0111111" when "0000", -- alg 0 decimal, anodo comum
-- "0000110" when "0001", -- 1
-- "1011011" when "0010", -- 2
-- "1001111" when "0011", -- 3
-- "1100110" when "0100", -- 4
-- "1101101" when "0101", -- 5
-- "1111101" when "0110", -- 6
-- "0000111" when "0111", -- 7
-- "1111111" when "1000", -- 8
-- "1101111" when "1001", -- 9
-- "1110111" when "1010", -- A (hexa) anodo comum
-- "1111100" when "1011", -- B
-- "0111001" when "1100", -- C
-- "1011110" when "1101", -- D
-- "1111001" when "1110", -- E
-- "1110001" when "1111", -- F
-- "0000000" when others;
end df_Decoder_7seg;
-- -------------------------------------------------------------------------
O código acima pode ser reutilizado em vários projetos. Reutilizando o projeto do somador ficará assim:
Obs: escolha uma chave deslizante do KIT DE2-115 da placa para ser o MODE. No kit UFPE escolha um dos
botões de pulsador. Ligue TS-OUT em um LED para verificar quando ocorre overflow.
Descrição de um circuito SOMADOR COMPLETO com decoder 7-segmentos:

----------------------------------------------------------------------------------
-- Company: UFPE
-- Create Date: 08/12/2013
-- Module Name: Somador e Subtrator Completo 1Bit - dataflow
-- Descrição:
-- Este módulo soma UM BIT presente em A com B, quando (M=0)
-- subtrai 1 bit de A do bit em B, quando (M=1)
-- dependendo da variável M (que controla o modo de operação)
-- O módulo leva em conta o Carry IN (variável Te) e sai Carry Out (em Ts)
-- O módulo gera uma saída EM DISPLAY DE 7SEGs.
----------------------------------------------------------------------------------
library IEEE;
-- esta é a declaração da entidade (da interface do componente com o mundo)

entity Soma_Sub_1Bit is
Port ( A, B, Te, M : in STD_LOGIC;
S, Ts : out STD_LOGIC);
end Soma_Sub_1Bit;
-- arquitetura que descreve por dataflow o circuito que soma e/ou subtrai 1 bit
architecture df_Soma_Sub_1Bit of Soma_Sub_1Bit is
begin
-- aqui começa a descrição em dataflow dos circuitos
S <= A xor B xor Te;
Ts <= (B and Te) or ((M xor A) and (B or Te));
end df_Soma_Sub_1Bit;
-----.---------..---------..---------..---------..---------..---------..---------.------
-- Company: UFPE
-- Create Date: 08/17/2013
-- Module Name: Somador e Subtrator Completo 4-Bits - Structural + dataflow
-- Descrição:
-- Este módulo soma/subtrai 4 bits de A com B, dependendo do valor da entrada M.
-- Se M=0 soma, se M=1 subtrai. O resultado sai em S(3...0) e Carry_Out em Ts.
----------------------------------------------------------------------------------
library IEEE;

entity Somador_Subtrator_4bits is
Port ( A, B : in STD_LOGIC_VECTOR (3 downto 0);
M : in STD_LOGIC;
sseg : out STD_LOGIC_VECTOR (6 downto 0);
Ts_out : out STD_LOGIC);
end Somador_Subtrator_4bits;
-- arquitetura que descreve a estrutura do somador de 4 bits, baseado no somador 1 bit

architecture st_Somador_Subtrator_4bits of Somador_Subtrator_4bits is
signal S : STD_LOGIC_VECTOR (3 downto 0);
signal xT : STD_LOGIC_VECTOR (3 downto 0)
signal Te0: STD_LOGIC;
begin
-- o primeiro sinal de Carry_IN é zero sempre, isso força esta condição...
Te0 <= '0';
-- aqui instancia os componentes somador/subtrator de 1 bit para o bit (0) ... (3)
Port map(A=>A(0), B=>B(0), Te=>Te0, M=>M, S=>S(0), Ts=> xT(0));



-- o sinal de Carry_Out é o próprio sinal de saida Ts do módulo Soma_Sub_3

Ts_out <= xT(3);
-- aqui entra o decoder p/ 7-segmentos

-- conversão para 7-seg ANODO COMUM-dataflow (pode ser copiado em outros projs)
with S select
sseg(6 downto 0) <=
"1111001" when "0001", -- 1
"0100100" when "0010", -- 2
"0110000" when "0011", -- 3
"0011001" when "0100", -- 4
"0010010" when "0101", -- 5
"0000010" when "0110", -- 6
"1111000" when "0111", -- 7
"0000000" when "1000", -- 8
"0010000" when "1001", -- 9
"0000011" when "1011", -- B
"1000110" when "1100", -- C
"0100001" when "1101", -- D
"0000110" when "1110", -- E
"0001110" when "1111", -- F
end st_Somador_Subtrator_4bits;
-- ---------------------------------------------------------------------

Prática 06: Lógica Sequencial – Flip-Flop “D” e REGISTRADOR - Behavioral.
I. Experimento e Simulação 1) Resumo (Opcional): Deve conter um breve

Considere o circuito da Fig. 1. resultados obtidos;
com objetivos e roteiros. O objetivo aqui é
D Q compreender como FFs são gerados em
VHDL.
ck
Fig. 1 – Flip-Flop tipo D controla acender um LED. sobre o que faz o circuito (no caso o FF tipo
D). Ou seja, explique de onde saiu o circuito
Esta prática mostra como um Flip-Flop tipo D e qual é o objetivo de existir um FF-D.
é criado usando a linguagem VHDL.
A. Propostas da aula prática: experimental, os métodos de medição e os
1) Criar um circuito que retém um BIT, 5) Análise: deve conter a análise dos
quando um sinal de clock é ativado. Para resultados experimentais em comparação
isso, use uma chave deslizante para entrada com os resultados teóricos e/ou simulados.
do dado D, e um botão pulsador para gerar o
clock do circuito. Dificuldades e problemas com resultados
devem estar registrados nessa seção;
2) Descrever um flip-flop usando o estilo
“behavioral”. Nesse caso, dentro da seção 6) Conclusões: apresente as conclusões do
architecture você deve definir um PROCESS. relatório. O que se pode afirmar sobre os
modelos utilizados e comentários sobre as
3) Tarefa: depois de executar o FF-D da aplicações podem estar nessa seção.
forma proposta, troque o sensor de evento do
clock de rising_edge() para falling_edge() e 7) Referências (Opcional): deve conter as
descreva a mudança no comportamento. referências utilizadas na prática.
4) Tarefa: depois de executar o circuito

anterior, crie um REGISTRADOR de 8 bits
(latch de 8 bits). III. Ferramentas e Literatura
B. Execução - Programa QUARTUS II da Altera ou ISE da XILINX;

Espera-se aqui que o aluno implante os
circuitos em CPLD/FPGA.
- Livros:
Esteja atento que os níveis lógicos das
CPLDs e FPGAs são 3,3V para entradas e - B. Mealy, F. Tappero, Free Range VHDL. Rel: 1.17/2013.
http://www.freerangefactory.org
saídas. Utilize as placas BASIC_IN e
BASIC_OUT. Preste atenção nos pinos e - Pong P. FPGA Prototyping by VHDL Examples: Xilinx
sinais utilizados e faça a escolha correta no Spartan-3 Version, 1 ed. Wiley-Interscience; 2008.
PIN PLANNER. Os pulsadores da placa
BASIC_IN (e da FPGA) possuem debouncing
(por meio de um inversor schmitt trigger).

precisam ser necessariamente os mesmos
indicados) (Máximo  200 palavras por tópico –
escrevam sínteses);
Descrição de um circuito FLIP-FLOP tipo D (base para criar o REGISTRADOR)

----------------------------------------------------------------------------------
-- Company: UFPE
--
-- Create Date: 31/05/2016
-- Module Name: FLIP-FLOP D + REGISTRADOR - Behavioral
--
-- Descrição: Este código mostra um flip-flop tipo D (1 bit).
-- O clock de input advém do sinal de PULSO de uma chave.
-- Use chaves deslizantes (switches) para ajustar os bits de dados.
----------------------------------------------------------------------------------
library IEEE;
use IEEE.NUMERIC_STD.ALL;
-- aqui definimos a entidade

entity Registrador is
Port ( clk : in STD_LOGIC;
Din : in STD_LOGIC;
Q : out STD_LOGIC);
end Registrador;
-- aqui começa o architecture (descrição do comportamento do circuito)

architecture bh_Registrador of Registrador is
begin
-- processo que memoriza os bits de entrada (Din) em Flip-Flops tipo D

mem_FF: process(clk) -- inicia a descrição de um porcesso
begin
if rising_edge(clk) then -- SE ocorrer evento clk (sobe/desce)
Q <= Din; -- Q memoriza o valor de Din
end if;
end process mem_FF; -- fim descrição do processo
end bh_Registrador;
-- TAREFA 1: troque rising_edge() na forma sensorial do clock para falling_edge()
-- TAREFA 2: transforme este circuito em um REGISTRADOR de 4 ou 8 bits

-- -------------------------------------------------------------------------------------------------

Prática 07: Lógica Sequencial – Contador Binário - Behavioral.
I. Experimento e Simulação indicados) (Máximo  200 palavras por tópico –

escrevam sínteses);
Considere o circuito da Fig. 1.
max_ou resumo sobre o trabalho com os principais
Contador
Qt resultados obtidos;
n-1
clk_Pulse
BINÁRIO 2) Introdução/Motivação: Deve conter uma
...
Reset breve introdução/motivação sobre a prática,
Q0 com objetivos e roteiros
Fig. 1 – Divisor de clock E circuito contador binário.
sobre o que faz o circuito (no caso o divisor
de clock). Ou seja, explique de onde saiu o
Contadores podem funcionar com clock
circuito inicial – dos circuitos contadores;
contínuo gerado automaticamente, ou podem
contar pulsos gerados por sensores (ou 4) Metodologia: deve conter o arranjo
manualmente). experimental, os métodos de medição e os
A. Propostas da aula prática: 5) Análise: deve conter a análise dos
resultados experimentais em comparação
1) Criar um contador binário hexa que conte com os resultados teóricos e/ou simulados.
os pulsos gerados por um botão pulsador,
com saída em 4 LEDs. Use RESET. Dificuldades e problemas com resultados
devem estar registrados nessa seção;
2) Descrever um contador decimal de 4-bits
em VHDL usando o estilo “behavioral” 6) Conclusões: apresente as conclusões do
também com saída nos LEDs. Utilize RESET. relatório. O que se pode afirmar sobre os
modelos utilizados e comentários sobre as
3) Tarefa: mostre o resultado dos contadores aplicações podem estar nessa seção.
no display de 7 segmentos usando o
conversor desenvolvido na prática 4! 7) Referências (Opcional): deve conter as
4) Tarefa: depois de executar o contador da
forma proposta, troque o sensor de evento do
clock de rising_edge() para falling_edge() e
descreva a mudança no comportamento. III. Ferramentas e Literatura
B. Execução - Programa QUARTUS II da Altera ou ISE da XILINX;
circuitos em CPLD / FPGA, e não apenas - Placa FPGA ou CPLD;
simule. - Livros:
Esteja atento que os níveis lógicos das - B. Mealy, F. Tappero, Free Range VHDL. Rel: 1.17/2013.
CPLDs e FPGAs são 3,3V para entradas e http://www.freerangefactory.org
saídas. Utilize as placas BASIC_IN e - Pong P. FPGA Prototyping by VHDL Examples: Xilinx
BASIC_OUT. Preste atenção nos pinos e Spartan-3 Version, 1 ed. Wiley-Interscience; 2008.
sinais utilizados e faça a escolha correta no
PIN PLANNER. As chaves da placa
BASIC_IN já possuem debouncing (por meio
de um inversor schmitt trigger).

precisam ser necessariamente os mesmos
Descrição de um circuito CONTADOR BINÁRIO

----------------------------------------------------------------------------------
-- Company: UFPE
--
-- Create Date: 01/08/2014
-- Module Name: Binary_Counter - Structural + Behavioral
--
-- Descrição: Este código mostra um contador binário síncrono com reset assíncrono
-- de N bits (N é declarado no generic, e vc pode modificar p/ qualquer
-- número de bits desejado).
-- O clock de input advém do sinal de PULSO de entrada
----------------------------------------------------------------------------------
library IEEE;
-- aqui definimos a entidade

entity Binary_Counter is
generic( N : integer := 4); -- altere aqui o núm de bits do contador
Port ( clk_Pulse : in STD_LOGIC;
reset : in STD_LOGIC;
max_out : out STD_LOGIC;
Q : out STD_LOGIC_VECTOR (N-1 downto 0));
end Binary_Counter;
-- aqui começa o architecture (descrição do comportamento do circuito)

architecture bh_Binary_Counter of Binary_Counter is
signal r_conta: unsigned(N-1 downto 0);
signal r_proxi: unsigned(N-1 downto 0);
-- começo da arquitetura
begin
-- processo que memoriza o valor de contagem

mem_contagem: process(clk_Pulse,reset)
begin
if (reset='0') then -- se reset (assíncrono) desce p/ ZERO
r_conta <= (others => '0'); -- bits dos FFs de contagem são zerados
elsif rising_edge(clk_Pulse) then -- com evento de clk_Pulse...
r_conta <= r_proxi; -- r_conta memoriza o valor de r_proxi
end if;
end process mem_contagem;
-- esse procedimento incrementa o próximo estado

r_proxi <= r_conta + 1; -- calcula o próximo estado na contagem
-- este procedimento conecta as saídas dos FFs r_conta com as saídas Q da entidade
Q <= STD_LOGIC_VECTOR(r_conta); -- Q(i) converte vetor em saída(pinos)
-- este procedimento gera um pulso '1' quando o último número (2**N-1) é atingido
max_out <= '1' when r_conta=(2**N-1) else '0';
end bh_Binary_Counter;
-- OBS: neste código, o número de BITS do contador (ou seja, o número de FFs) é definido
-- por você, no GENERIC (default = 4) e pode ser mudado na hora de instanciar esse
-- componente, em outra estrutura, usando generic map ( N => 10 ), por exemplo.
-- TAREFA: troque rising_edge() na forma sensorial do clock para falling_edge()

-- -------------------------------------------------------------------------------------------------

Prática 08: Lógica Sequencial – Contador de MÓDULO-M.
I. Experimento e Simulação
Considere o circuito da Fig. 1. O relatório deve ser organizado nos
seguintes tópicos (os títulos dos tópicos
não precisam ser necessariamente os
mesmos indicados) (sejam sintéticos, usem
 200 palavras por tópico no máximo);
1) Resumo (Opcional): Deve conter um
breve resumo sobre o trabalho com os
principais resultados obtidos;
2) Introdução/Motivação: Deve conter
Fig. 1 – Contador decimal síncrono de 4-bits. uma breve introdução/motivação sobre
a prática, com objetivos e roteiros
Trata-se de um contador binário de 4 3) Fundamentação Teórica: Contém a
bits cujo clock está ligado aos FFs em teoria utilizada na prática. Uma breve
paralelo (contador síncrono). Note que descrição sobre o que faz o circuito (no
portas AND adicionais detectam caso o contador binário, contador de
quando o FF-C muda (quando a década, e divisor de frequência). Ou
contagem chega a 3) e quando o FF-D seja, explique de onde saiu o circuito
muda (quando chega a 7). inicial;
Este contador conta até 10 e reseta os
FFs quando a porta NAND tem 4) Metodologia: deve conter o arranjo
entradas = ‘1’. Portanto, depois do experimental, os métodos de medição
número 9, ao receber um clock, o e os resultados da
contador volta para “0000”. Por isso é simulação/experimentos;
chamado contador decimal binário. 5) Análise: deve conter a análise dos
O contador de módulo-M conta em resultados experimentais em
binário até o número M que você o comparação com os resultados teóricos
programar. e/ou simulados.
A. Propostas da aula prática: Dificuldades e problemas com

resultados devem estar registrados
1) Descreva um contador DECIMAL nessa seção;
binário em VHDL usando o estilo 6) Conclusões: apresente as
“behavioral”. conclusões do relatório. O que se pode
2) Descreva um circuito contador que afirmar sobre os modelos utilizados e
conte até qualquer valor M (módulo-M). comentários sobre as aplicações
podem estar nessa seção.
3) DESAFIO: usando os componentes
contador de Mod-M e divisor de clock, 7) Referências (Opcional): deve conter
criar um cronômetro: um contador de 4 as referências utilizadas na prática.
dígitos que conte em décimos de
segundos. III. Ferramentas e Literatura
B. Execução
Espera-se aqui que o aluno implante os - Placa FPGA ou CPLD;
circuitos em CPLD ou em FPGA. Esteja - Livros: - B. Mealy, F. Tappero, Free Range VHDL.
atento que os níveis lógicos das CPLDs Rel: 1.17/2013. http://www.freerangefactory.org
e FPGAs são 3,3V. Pode-se utilizar - Pong P. FPGA Prototyping by VHDL Examples: Xilinx
LEDs para medir saídas e chaves DIP- Spartan-3 Version, 1 ed. Wiley-Interscience; 2008.
Switches para I/O dos níveis lógicos.
Contador binário com reset assíncrono:

----------------------------------------------------------------------------------
-- Company: UFPE
--
-- Create Date: 08/17/2013
-- Module Name: Contador de Módulo M - Behavioral
--
-- Descrição:
-- Este circuito é um contador de N bits de módulo M, ou seja
-- o contador conta de 0 até M (M tem que ser representável em N bits)
-- Os valores de N e M podem ser ajustados no GENERIC ou em GENERIC MAP...
-- Cada vez que o valor máximo é atingido, o contador gera um pulso em max-out.
----------------------------------------------------------------------------------
library IEEE;
-- aqui começa a descrição da entidade (interface)

entity Conta_Mod_M is
generic(N : integer := 4; -- num de bits desse contador
M : integer := 10); -- módulo do contador (conta até M)
Port (clk : in STD_LOGIC;
max : out STD_LOGIC;
end Conta_Mod_M;
-- aqui começa a descrição da arquitetura (comportamento do circuito)

architecture bhv_Conta_Mod_M of Conta_Mod_M is
signal r_conta: unsigned(N-1 downto 0); -- sinal p/ registrar contagem
signal r_proxi: unsigned(N-1 downto 0); -- sinal p/ proximo valor
begin
-- este processo conta pulsos e memoriza em r_conta
mem_conta: process(clk,reset)
begin
if (reset='0') then -- reset assíncrono em ZERO
r_conta <= (others => '0'); -- zera todos os bits de r_conta
elsif rising_edge(clk) then -- sem reset, na subida de clk
r_conta <= r_proxi; -- memoriza proximo valor
end if;
end process mem_conta;
-- próximo estado lógico

r_proxi <= (others=>'0') when r_conta>=(M-1) else r_conta+1;
-- gera o pulso max se chegou no maior valor do módulo M

pulso_out: process(r_conta)
begin
if r_conta=(M-1) then max <= '1'; else max <= '0'; end if;
end process pulso_out;
-- conecta os sinais do contador r_conta com as saídas Q da interface

Q <= STD_LOGIC_VECTOR (r_conta);
end bhv_Conta_Mod_M;
-- -----------------------------------------------------------------------

Prática 09: Lógica Sequencial e Combinacional – Multiplex para 4 Displays 7-seg
I. Experimento e Simulação 3) Descrever um circuito que faça

multiplexação entre D1, D2, D3 e D4. Para
Considere a placa de display mostrada na cada dígito (i) ligado, decodificar o número
Fig.1. BCD equivalente (BCD-7seg) gerando o par:
Di ligado e Num_7-segi.
B. Execução
circuitos em CPLD ou em FPGA.

seguintes tópicos: (sejam concisos);
Fig. 1 – Placa com 4 Displays 7 Segmentos.
Trata-se de uma placa que serve como resultados obtidos;
interface para vários projetos: 4 displays de
7-segmentos, ânodo comum (cada segmento 2) Introdução/Motivação: Deve conter uma
acende quando ligado a GND). breve introdução/motivação sobre a prática,
Para isso, a placa possui uma entrada VCC com objetivos e roteiros
que pode ser ligada em 3,3V na 3) Fundamentação Teórica: Contém a teoria
FPGA/CPLD. utilizada na prática. Uma breve descrição
Note que na pinagem tem apenas sobre o que faz o circuito (no caso o
A,B,C,D,E,F,G e H (pto decimal). Depois tem Multiplexador temporal 4 dígitos e 7-
D1, D2, D3 e D4. O que temos que fazer é segmentos). Ou seja, explique de onde saiu
multiplexar os displays. o circuito inicial;
Colocamos o valor BCD da unidade no
decoder BCD-7seg e ativamos D1 (D1=’0’). 4) Metodologia: deve conter o arranjo
Em seguida colocamos o valor da dezena no experimental, os métodos de medição e os
decoder e ativamos D2 (=0), e repetimos isso resultados da simulação/experimentos;
para a centena ativando D3 e milhar, 5) Análise: deve conter a análise dos
ativando D4. Isso se chama varredura. Se resultados experimentais em comparação
fizermos a varredura o suficiente (digamos, com os resultados teóricos e/ou simulados.
60 vezes por segundo), nossos olhos não
percebem que deixamos os displays Dificuldades e problemas com resultados
apagados ¼ do tempo. devem estar registrados nessa seção;
Por que multiplexar? 6) Conclusões: apresente as conclusões do
Para economizar fios e conexões! relatório. O que se pode afirmar sobre os
Note que para o dispositivo multiplexado modelos utilizados e comentários sobre as
temos 13 fios, enquanto que para 4 dígitos aplicações podem estar nessa seção.
de 7-segs seriam necessários 32 fios + VCC
ou GND. 7) Referências (Opcional): deve conter as
1) Instanciar em VHDL o divisor de clock que - Programa QUARTUS II da Altera ou ISE da XILINX;
gere 10 Hz, e outro que gere o clock de - Placa FPGA ou CPLD;
varredura de 240 Hz.
- Livros:
2) Descrever um circuito cronômetro digital
- B. Mealy, F. Tappero, Free Range VHDL. Rel: 1.17/2013.
que conte décimos de segundo: http://www.freerangefactory.org
(cent_seg dez_seg uni_seg  décimo_seg).

----------------------------------------------------------------------------------
-- Company: UFPE
-- Create Date: 08/17/2013
-- Module Name: Estrutura Display de 4 dígitos x 7 segmentos
-- Descrição:
-- Este arquivo é a ESTRUTURA principal do contador de 4 dígitos, com 7 seg multiplexado
-- clk deve ser ligado nos 32 MHz e reset deve ser um PINO de entrada na placa
-- sai sseg:(sseg(7) é o pto decimal, sseg(6) é o LED "g", e sseg(0) é o Led "a" (ativos=0)
-- dig: qual dos dígitos está ligado (ativo em 0): dig(3) é o milhar, dig(0) é unidade.
-- NOTA: neste programa usa-se 4 bits (portanto, N=4 no genérico em mod_M_conta senão dá erro)
----------------------------------------------------------------------------------
library IEEE;
entity Display_4dig_7seg_mux is
Port ( clk, reset : in STD_LOGIC;
sseg : out STD_LOGIC_VECTOR (7 downto 0);
dig : out STD_LOGIC_VECTOR (3 downto 0));
end Display_4dig_7seg_mux;
architecture st_Display_4dig_7seg_mux of Display_4dig_7seg_mux is

-- sinais internos dessa architeture
signal clk_10Hz : STD_LOGIC; -- clock para 1o. contador
signal mx1,mx2,mx3,mx4 : STD_LOGIC; -- val max = clk p/ módulos seguintes
signal cU,cD,cC,cM : STD_LOGIC_VECTOR (3 downto 0); -- nums BCD de 4 bits Unid Dez Cen Mil
begin
-- instanciar o componente divisor de frequência para 10 Hz...
clock_10Hz : entity work.clk_div(bh_clk_div)
generic map(N => 1600000) -- (Na Papilio, 32Mhz, N=1600000 -> clkout= 10Hz)
port map(CLKin => clk,
reset => reset,
CLKout => clk_10Hz);
-- instanciar 1o. contador de módulo M (unidade)
conta_Un : entity work.conta_mod_M(bhv_conta_mod_M)
generic map(N => 4, M => 10) -- N = 4 bits e M = 10 (modulo 10)
port map(clk => clk_10Hz,
reset => reset,
max => mx1,
q => cU);
-- instanciar 2o. contador de módulo M (dezena)
conta_Dz : entity work.conta_mod_M(bhv_conta_mod_M)
port map(clk => mx1,
reset => reset,
max => mx2,
q => cD);
-- instanciar 3o. contador de módulo M (centena)
conta_Cn : entity work.conta_mod_M(bhv_conta_mod_M)
reset => reset,
max => mx3,
q => cC);
-- instanciar 4o. contador de módulo M (milhar)
conta_Ml : entity work.conta_mod_M(bhv_conta_mod_M)
reset => reset,
max => mx4,
q => cM);
-- instanciar o multiplex nesta estrutura
mux_4x_7s : entity work.Mux_4dig_7seg(bh_Mux_4dig_7seg)
port map(clk => clk,
reset => reset,
nU => cU,
nD => cD,
nC => cC,
nM => cM,
sseg => sseg,
dig => dig);
end st_Display_4dig_7seg_mux;
-- FIM da entidade principal --
----------------------------------------------------------------------------------
-- Company: UFPE
--
-- Create Date: 08/17/2013
-- Module Name: Multiplex de 4 dígitos e 7 segmentos
-- Descrição:
-- Este módulo pode ser utilizado em vários projetos que utilizem 4 nums c/ display 7 seg
-- entra 4 nums em nU...nM, sai o vetor dig "1110"=dig unidade e "0111"=milhar (ativo low)
-- sai sseg (7 downto 0) 0 LED "a" é o LSB, "g" = sseg(6), e ponto decimal em sseg(7).
-- O circuito apaga os leds zerados à esquerda (blanking em dígitos não significativos)
----------------------------------------------------------------------------------
library IEEE;
-- caixa preta: entra clock + 4 nums BCD e sai 7seg DP + sinal dígito da vez...
entity Mux_4dig_7seg is
Port ( clk, reset : in STD_LOGIC; -- sinal de clock
nU,nD,nC,nM : in STD_LOGIC_VECTOR (3 downto 0); -- nums BCD de 4 bits
sseg : out STD_LOGIC_VECTOR (7 downto 0); -- sinal 7 segmtos + dp
dig : out STD_LOGIC_VECTOR (3 downto 0)); -- seleção dígito na placa
end Mux_4dig_7seg;
architecture bh_Mux_4dig_7seg of Mux_4dig_7seg is

-- declara o uso do componente divisor de clock do sistema (usa 120 Hz para varredura)
signal dignxt : STD_LOGIC_VECTOR (3 downto 0);
signal digaux : STD_LOGIC_VECTOR (3 downto 0);
signal clk_varre : STD_LOGIC; -- sinal de clock de varredura
begin
clock_varre : entity work.clk_div(bh_clk_div)
generic map(N => 132000) -- N = 132.000 faz o clk out ~ 120 Hz
reset => reset,
CLKout => clk_varre);
-- a cada pulso de clk_varre o circ seleciona O PROXIMO dígito (display 7 seg)

proc_varredura: process(clk_varre, reset) is
begin
dignxt <= "1110" ; -- mostra apenas o 1º. digito
elsif(clk_varre'event and clk_varre='1') then -- na subida de clock de varredura…
if dignxt="1110" then -- blanking: se estiver varrendo dig UN
if nM>"0000" or nC>"0000" or nD>"0000" then -- e algum dos nums (Dz, Cn, Milhar)>0
dignxt <= "1101"; -- passa a varrer a dezena
else -- se nenhum for maior que zero
dignxt <= "1110"; -- mostra apenas o dig da unidade
end if;
elsif dignxt="1101" then -- blanking: se estiver varrendo dig DZ
if nM>"0000" or nC>"0000" then -- e (Cn ou Ml)>0
dignxt <= "1011"; -- varre a centena
else -- se não,
dignxt <= "1110"; -- volta a varrer a unidade
end if;
elsif dignxt="1011" then -- blanking: se estiver varrendo centena
if nM>"0000" then -- e Ml > 0
dignxt <= "0111"; -- varre a milhar
else
dignxt <= "1110"; -- caso contrário, volta para unidade
end if;
elsif dignxt="0111" then
dignxt <= "1110";
else -- pega o resto (por segurança)
dignxt <= "1110";
end if;
end if;
end process proc_varredura;
-- processo que ajusta o valor do dado digaux para un, dz, cn, milhar...
Ajst_digaux : process (dignxt) is
begin
case (dignxt) is
when "1110" => digaux <= nU; sseg(7) <= '1';
when "1101" => digaux <= nD; sseg(7) <= '0'; -- deixei o pto fixo na dezena!
when "1011" => digaux <= nC; sseg(7) <= '1';
when "0111" => digaux <= nM; sseg(7) <= '1';

when others => digaux <= "1111"; sseg(7) <= '1';
end case;
end process Ajst_digaux ;
-- e ajusta a saída dig para selecionar o prox dígito a ser ligado
dig <= dignxt;
-- conversão para sete segmentos (ANODO COMUM dataflow)

with digaux select
sseg(6 downto 0) <=
"1111001" when "0001", -- 1
"0100100" when "0010", -- 2
"0110000" when "0011", -- 3
"0011001" when "0100", -- 4
"0010010" when "0101", -- 5
"0000010" when "0110", -- 6
"1111000" when "0111", -- 7
"0000000" when "1000", -- 8
"0010000" when "1001", -- 9
"0000011" when "1011", -- B
"1000110" when "1100", -- C
"0100001" when "1101", -- D
"0000110" when "1110", -- E
"0001110" when "1111", -- F
end bh_Mux_4dig_7seg;
-- FIM do circuito multiplex --
----------------------------------------------------------------------------------
-- Company: UFPE
--
-- Create Date: 08/17/2013
-- Module Name: Divisor de clock - Behavioral
-- Descrição:
-- Módulo DIVISOR DE CLOCK por um valor N inteiro (CLKin é dividido por N).
-- (duty cycle=50%: a saída CLKout='1' por N/2 pulsos de CLKin; CLKout='0' durante N/2 pulsos)
-- Ajuste os generics N_varre e N_10Hz no início do módulo (na entity) p/ mudar f_varre e timer
----------------------------------------------------------------------------------
library IEEE;
-- esta é a entidade do divisor de clock

entity clk_div is
generic ( N : integer := 16000000); -- default: este núm gera 1Hz => (32M/16.000.000)/2
port ( CLKin : in std_logic; -- entra o clock a ser dividido
reset : in std_logic; -- entra o reset
CLKout: out std_logic); -- sai clock out dividido por N (duty cicle ~50%)
end clk_div;
-- aqui a arch que descreve o comportamento do divisor de clock

architecture bh_clk_div of clk_div is
signal r_conta: integer; -- sinal (vetor inteiro de N bits,) p/ r_conta
signal f_clk : std_logic; -- flag que indica se clkout está em 1 ou 0
begin -- começo da descrição do comportamento
divide_clock: process(CLKin) -- processo (devido a lógica seq do r_conta)
begin
r_conta <= 0; -- zera o contador
elsif rising_edge(CLKin) then -- se acontecer a subida de clock
if (r_conta = N) then -- se r_conta já contou até N
f_clk <= NOT(f_clk); -- inverte o f_clk (1-> 0; ou 0 -> 1)
r_conta <= 0; -- e zera o contador
else -- caso contrário,
r_conta <= r_conta+1; -- incrementa o r_conta
end if;
end if;
end process divide_clock;
CLKout <= f_clk; -- fazer o clock de saída igual ao valor do f_clk
end bh_clk_div;
-- FIM do circuito divisor de clock –
----------------------------------------------------------------------------------
-- Company: UFPE
--
-- Create Date: 08/17/2013
-- Design Name: Práticas de Técnicas Digitais - PR_04B
--
-- Descrição:
----------------------------------------------------------------------------------
library IEEE;

end Conta_Mod_M;

begin -- da architecture

begin
elsif falling_edge(clk) then -- sem reset, na descida de clk
end if;


begin

-- FIM do contador de módulo M --
-- --------------------------------------------------------------------------
Código VHDL para utilização no KIT DE2-115

----------------------------------------------------------------------------------
-- Company: UFPE
--
-- Create Date: 08/17/2013
-- Module Name: Estrutura Display de 4 dígitos x 7 segmentos
-- Descrição:
-- Este arquivo é a ESTRUTURA principal do contador de 4 dígitos, com 7 seg multiplexado
-- clk deve ser ligado nos 50 MHz e reset deve ser um PINO de entrada na placa
-- sai sseg1,sseg2,sseg3,sseg4,:(ssegX(6) é o LED "g", e ssegX(0) é o Led "a" (ativos=0)
-- NOTA: neste programa usa-se 4 bits (portanto, N=4 no genérico em mod_M_conta senão dá erro)
----------------------------------------------------------------------------------
library IEEE;
entity Display_4dig_7seg_mux is
Port ( clk, reset : in STD_LOGIC;
sseg1, sseg2, sseg3, sseg4 : out STD_LOGIC_VECTOR (6 downto 0));
end Display_4dig_7seg_mux;
architecture st_Display_4dig_7seg_mux of Display_4dig_7seg_mux is

signal clk_10Hz : STD_LOGIC; -- clock para 1o. contador
signal mx1,mx2,mx3,mx4 : STD_LOGIC; -- val max = clk p/ módulos seguintes
signal cUn,cDz,cCn,cMl : STD_LOGIC_VECTOR (3 downto 0); -- nums BCD de 4 bits Unid Dez Cen Mil
signal sseg : STD_LOGIC_VECTOR (6 downto 0); -- vetor 7 segmentos
signal dig : STD_LOGIC_VECTOR (3 downto 0); -- vetor c/ qual dos displays acende
begin
clock_10Hz : entity work.clk_div(bh_clk_div)
generic map(N => 1600000) -- (Na Papilio, 32Mhz, N=1600000 -> clkout= 10Hz)
reset => reset,
CLKout => clk_10Hz);
-- instanciar 1o. contador de módulo M (unidade)
conta_Un : entity work.conta_mod_M(bhv_conta_mod_M)
port map(clk => clk_10Hz,
reset => reset,
max => mx1,
q => cUn);
-- instanciar 2o. contador de módulo M (dezena)
conta_Dz : entity work.conta_mod_M(bhv_conta_mod_M)
reset => reset,
max => mx2,
q => cDz);
-- instanciar 3o. contador de módulo M (centena)
conta_Cn : entity work.conta_mod_M(bhv_conta_mod_M)
reset => reset,
max => mx3,
q => cCn);
-- instanciar 4o. contador de módulo M (milhar)
conta_Ml : entity work.conta_mod_M(bhv_conta_mod_M)
reset => reset,
max => mx4,
q => cMl);
mux_4x_7s : entity work.Mux_4dig_7seg(bh_Mux_4dig_7seg)
reset => reset,
nUn => cUn,
nDz => cDz,
nCn => cCn,
nMl => cMl,
sseg => sseg,
dig => dig);
-- esta parte do circuito liga apenas UM dos displays por vez (time multiplex) ...
proc_mux_display: process(dig) is
begin
if dig="1110" then -- se estiver varrendo dig UN
sseg1 <= sseg;
else
sseg1 <= "1111111"; -- se não, apaga o display
end if;
sseg2 <= sseg;
else
end if;
sseg3 <= sseg;
else
end if;
sseg4 <= sseg;
else
end if;
end process proc_mux_display;
end st_Display_4dig_7seg_mux;
-- FIM da entidade principal –
----------------------------------------------------------------------------------
-- Company: UFPE
--
-- Create Date: 08/17/2013
-- Module Name: Multiplex de 4 dígitos e 7 segmentos
-- Descrição:
-- entra 4 nums em nU...nM, sai o vetor dig "1110"=dig unidade e "0111"=milhar (ativo low)
-- sai sseg (7 downto 0) 0 LED "a" é o LSB, "g" = sseg(6), e ponto decimal em sseg(7).
----------------------------------------------------------------------------------
library IEEE;
-- caixa preta: entra clock + 4 nums BCD e sai 7seg DP + sinal dígito da vez...
Port (clk, reset : in STD_LOGIC; -- sinal de clock e reset
nUn,nDz,nCn,nMl : in STD_LOGIC_VECTOR (3 downto 0); -- nums BCD de 4 bits
sseg : out STD_LOGIC_VECTOR (6 downto 0); -- sinal 7 segmtos
dig : out STD_LOGIC_VECTOR (3 downto 0)); -- seleção dígito na placa
end Mux_4dig_7seg;

signal dignxt : STD_LOGIC_VECTOR (3 downto 0);
signal digaux : STD_LOGIC_VECTOR (3 downto 0);
signal clk_varre : STD_LOGIC; -- sinal de clock de varredura
begin
clock_varre : entity work.clk_div(bh_clk_div)
generic map(N => 200000) -- N = 200.000 faz o clk out ~ 125 Hz
reset => reset,
-- a cada pulso de clk_varre o circ seleciona O PROXIMO dígito (display 7 seg)

proc_varredura : process(reset, clk_varre) is
begin
dignxt<="1110" ; -- mostra apenas o 1º. digito
elsif (rising_edge(clk_varre)) then -- na subida de clock de varredura…
if dignxt="1110" then -- blanking: se estiver varrendo dig UN
if nMl>"0000" or nCn>"0000" or nDz>"0000" then -- e algum dos nums (Dz, Cn, Milhar)>0
dignxt <= "1101"; -- passa a varrer a dezena
else -- se nenhum for maior que zero
dignxt <= "1110"; -- mostra apenas o dig da unidade
end if;
elsif dignxt="1101" then -- blanking: se estiver varrendo dig DZ
if nMl>"0000" or nCn>"0000" then -- e (Cn ou Ml)>0
dignxt <= "1011"; -- varre a centena
else -- se não,
dignxt <= "1110"; -- volta a varrer a unidade
end if;
elsif dignxt="1011" then -- blanking: se estiver varrendo centena
if nMl>"0000" then -- e Ml > 0
dignxt <= "0111"; -- varre a milhar
else
dignxt <= "1110"; -- caso contrário, volta para unidade
end if;
elsif dignxt="0111" then
dignxt <= "1110";
else -- pega o resto (por segurança)
dignxt <= "1110";
end if;
end if;
end process proc_varredura;
-- processo que ajusta o valor do dado digaux para un, dz, cn, milhar...
Ajst_digaux: process (dignxt) is
begin
case (dignxt) is
when "1110" => digaux <= nUn;
when "1101" => digaux <= nDz;
when "1011" => digaux <= nCn;
when "0111" => digaux <= nMl;
when others => digaux <= "1111";
end case;
end process Ajst_digaux ;
-- e ajusta a saída dig para selecionar o prox dígito a ser ligado
dig <= dignxt;

with digaux select
sseg(6 downto 0) <=
"1111001" when "0001", -- 1
"0100100" when "0010", -- 2
"0110000" when "0011", -- 3
"0011001" when "0100", -- 4
"0010010" when "0101", -- 5
"0000010" when "0110", -- 6
"1111000" when "0111", -- 7
"0000000" when "1000", -- 8
"0010000" when "1001", -- 9
"0000011" when "1011", -- B
"1000110" when "1100", -- C
"0100001" when "1101", -- D
"0000110" when "1110", -- E
"0001110" when "1111", -- F
-- FIM do circuito multiplex --

----------------------------------------------------------------------------------
-- Company: UFPE
-- Create Date: 08/17/2013
-- Descrição:
-- Ajuste os generics N_varre e N_10Hz no início do módulo (na entity) p/ mudar f_varre e timer
----------------------------------------------------------------------------------
library IEEE;

entity clk_div is
end clk_div;

begin
end if;
end if;
end bh_clk_div;
-- FIM do circuito divisor de clock –
----------------------------------------------------------------------------------
----------------------------------------------------------------------------------
-- Company: UFPE
-- Create Date: 08/17/2013
--
-- Descrição:
----------------------------------------------------------------------------------
library IEEE;

end Conta_Mod_M;

begin
elsif falling_edge(clk) then -- sem reset, na descida de clk
end if;
begin

-- --------------------------------------------------------------------------

Prática 10: Lógica Sequencial – Máquina de Estados, MUX e Contadores
I. Experimento e Simulação 2) Descrever um circuito cronômetro digital

que conte centésimos de segundo:
Considere a placa mostrada na Fig. 1.
( 105 104 103 102 101 1  10-1 10-2)
segundos.
3) Descrever um circuito que multiplexe
D1...D8. Para cada dígito (i) ligado,
decodificar o valor equivalente (BCD-7seg).
4) Descrever um circuito que gere string com
2 bytes: string = (bits D1...D8) & (7-seg + dp)
Fig. Placa display com 8 dígitos de 7-segmentos. 5) Criar uma máquina de estados que tome
cada bit dessa string e coloque em DIO, suba
Trata-se de uma placa com 8 dígitos de 7- o pulso SCK, desça o pulso SCK, repita isso
seg que possui apenas 5 fios de entrada: para os 16 bits. Ao final, suba o RCK, desça
VCC, GND, SCK, RCK e DIO. Esta placa o pulso RCK e indique o final da serialização.
utiliza comunicação SERIAL. A placa possui Gerar o par: Di ligado e Num_7-segi..
dois circuitos integrados 74HC595 –
registrador de deslocamento, cujo diagrama - A prática requer conceito de MÁQUINA DE
de blocos aparece na Fig. 2. ESTADOS para enviar dados serializados.

seguintes tópicos (sejam sucintos);
1) Resumo (Opcional;
breve introdução/motivação sobre a prática;
sobre o que faz o circuito, incluindo o
74HC595;
Os sinais OE e MR estão devidamente experimental, os métodos de medição e os
ligados. Deve-se colocar o dado disponível resultados da simulação/experimentos;
em DIO, na subida de SCK o dado é
serializado para o shift-register. Depois que 8 5) Análise: deve conter a análise dos
bits de dados são deslocados para o SR resultados experimentais em comparação
devemos dar um pulso de clock em RCK com os resultados teóricos e/ou simulados.
para copiar o conteúdo do SR para a saída 6) Conclusões: apresente as conclusões do
do 74HC595 (Q0...Q7). relatório. O que se pode afirmar sobre os
As saídas dos dois 74HC595 servem para: modelos utilizados e comentários sobre as
a) o 1º 74HC595 retém qual dígito (D1...D8) aplicações podem estar nessa seção.
deve estar ligado (ativo em ‘1’);
b) o 2º 74HC595 retém o código 7-segs 7) Referências (Opcional): deve conter as
(ânodo comum) que o dígito (D1...D8) deve referências utilizadas na prática.
mostrar.
A. Propostas da aula prática: - Programa QUARTUS II da Altera ou ISE da XILINX;
1) Instanciar clock_div p/ gerar 100 Hz, e
outro que gere o clock de varredura de 4KHz.
-- este é o código da estrutura principal do mux serial...
----------------------------------------------------------------------------------
-- Company: UFPE
--
-- Create Date: 08/17/2013
-- Module Name: Display_8dig_7seg_serial - Structural + Behavioral + Dataflow
--
-- Descrição:
-- Additional Comments:
-- Este arquivo é a ESTRUTURA principal do contador de 8 dígitos, com 7 seg serial
-- clk deve ser ligado nos X MHz da placa e reset deve ser um PINO de entrada na placa
-- saem apenas 3 sinais:
-- DIO: é o dado serial que será enviado para os shift-registers 74HC595
-- SCK: é o sinal de clock usado para serializar dados para os SRs
-- RCK: é o sinal que copia os dados serializados para a saída do 74HC595
----------------------------------------------------------------------------------
library IEEE;
entity Display_8dig_7seg_serial is
Port (clk, reset : in STD_LOGIC;
DIO : out STD_LOGIC;
SCK : out STD_LOGIC;
RCK : out STD_LOGIC);
end Display_8dig_7seg_serial;
architecture st_Display_8dig_7seg_serial of Display_8dig_7seg_serial is

signal clk_cont : STD_LOGIC; -- clock para 1o. contador
signal mx1,mx2,mx3,mx4,
mx5,mx6,mx7,mx8 : STD_LOGIC; -- val max = clk p/ módulos seguintes
signal c1,c2,c3,c4,
c5,c6,c7,c8 : STD_LOGIC_VECTOR (3 downto 0); -- nums BCD de 4 bits Unid Dez Cen
Milhar
-- começo da architecture
begin
divclk_contador : entity work.clk_div(bh_clk_div)
generic map(N => 160000) --(p/ 100 Hz em 32MHz N= 160.000)
reset => reset,
CLKout => clk_cont);
-- instanciar 1o. contador de módulo N1 (unidade)

conta_N1 : entity work.conta_mod_M(bhv_conta_mod_M)
port map(CLKin => clk_cont,
reset => reset,
max => mx1,
q => c1);
-- instanciar 2o. contador de módulo N2 (dezena)
port map(CLKin => mx1,
reset => reset,
max => mx2,
q => c2);
-- instanciar 3o. contador de módulo N3 (mil)
reset => reset,
max => mx3,
q => c3);
-- instanciar 4o. contador de módulo N4 (dzmil)
reset => reset,
max => mx4,
q => c4);
-- instanciar 5o. contador de módulo N5 (centmil)
reset => reset,
max => mx5,
q => c5);
-- instanciar 6o. contador de módulo N6 (milhão)
Dispositivos Lógicos Programáveis João Ranhel 61
reset => reset,
max => mx6,
q => c6);
-- instanciar 7o. contador de módulo N7 (dzmilhão)
reset => reset,
max => mx7,
q => c7);
-- instanciar 8o. contador de módulo N8 (centmilhão)
reset => reset,
max => mx8,
q => c8);

mux_8x_7s: entity work.Mux_8dig_7seg(bh_Mux_8dig_7seg)
reset => reset,
n1 => c1,
n2 => c2,
n3 => c3,
n4 => c4,
n5 => c5,
n6 => c6,
n7 => c7,
n8 => c8,
sck => SCK,
rck => RCK,
dout => DIO);
end st_Display_8dig_7seg_serial;
-- FIM da estrutura principal --
----------------------------------------------------------------------------------
-- Company: UFPE
--
-- Create Date: 08/17/2013
-- Module Name: MÓDULO MUX e FSM para - Structural + Behavioral + Dataflow
--
-- Descrição:
-- (este é apenas o módulo MUX que multiplexa e serializa dados para o 74HC595)
-- entra 8 nums em n1...n8, sai o sinal de dados e um pulso de clock para serializa-lo.
-- A frequencia de varredura é conseguida instanciando o clk_div p/ 2 KHz...
----------------------------------------------------------------------------------
library IEEE;
-- este componente é um multiplex de 8 digitos serial...

Port ( clk, reset : in STD_LOGIC; -- sinal de clock e reset
n1,n2,n3,n4,n5,n6,n7,n8 : in STD_LOGIC_VECTOR (3 downto 0); -- nums BCD de 4 bits
sck, rck, dout : out STD_LOGIC); -- saídas seriais
end Mux_8dig_7seg;
-- define uma variável do tipo vars de estado (usando type) com 35 estados E00...E34
type tipo_estado is (E00,E01,E02,E03,E04,E05,E06,E07,E08,E09,E10,E11,E12,E13,E14,E15,E16,
E17,E18,E19,E20,E21,E22,E23,E24,E25,E26,E27,E28,E29,E30,E31,E32,E33,E34);
-- define sinais internos da arquitetura
signal EsA, EsF : tipo_estado;
signal clk_varre: STD_LOGIC; -- clock varredura (=4KHz, 500 vezes/display)
signal proxdig : STD_LOGIC_VECTOR (7 downto 0); -- sinaliza o prox dígito
signal sseg : STD_LOGIC_VECTOR (7 downto 0); -- valor do dado a ser serializado
signal val_aux : STD_LOGIC_VECTOR (3 downto 0); -- valor aux para conversão BCD-7seg
signal Reg_Out : STD_LOGIC_VECTOR (15 downto 0);-- reg p/ armazenar concatenação sseg &
proxdig
begin -- começo da arquitetura

-- instanciar o componente divisor de frequência para Freq_Varredura 4 KHz...
div_clk_varre : entity work.clk_div(bh_clk_div)
generic map(N => 8000) -- para freq 2KHz (~250 Hz em cada dígito)
reset => reset,
-- a cada pulso de clk_varre o circ seleciona e memoriza O PROXIMO dígito (display 7 seg)
prox_digito: process(clk_varre, reset)
begin
if (reset='0') then
proxdig <= "00000000";
elsif rising_edge(clk_varre) then
proxdig <= "00000001"; -- por default varre o dígito 1 apenas
val_aux <= n1; -- e mostra o número da unidade!
if proxdig = "00000001" then
-- blanking: se varre dig N1 e algum dos dígitos seguintes > 0, varre também N2
if (n8>"0000" or n7>"0000" or n6>"0000" or n5>"0000" or n4>"0000" or n3>"0000" or n2>"0000") then
proxdig <= "00000010"; -- passa a varrer o segundo dígito e memoriza proxdig
val_aux <= n2;
end if;
elsif proxdig = "00000010" then
-- blanking: se varre dig N2 e algum dos seguintes > 0, varre também N3
if (n8>"0000" or n7>"0000" or n6>"0000" or n5>"0000" or n4>"0000" or n3>"0000") then
proxdig <= "00000100"; -- passa a varrer o 3o dígito
val_aux <= n3;
end if;
if (n8>"0000" or n7>"0000" or n6>"0000" or n5>"0000" or n4>"0000") then
val_aux <= n4;
end if;
if (n8>"0000" or n7>"0000" or n6>"0000" or n5>"0000") then
val_aux <= n5;
end if;
if (n8>"0000" or n7>"0000" or n6>"0000") then
val_aux <= n6;
end if;
if (n8>"0000" or n7>"0000") then
val_aux <= n7;
end if;
if (n8>"0000") then
val_aux <= n8;
end if;
proxdig <= "00000001"; -- inicia mostrando apenas o digito 1
val_aux <= n1;
end if;
end if;
end process prox_digito;

with val_aux select
sseg(7 downto 1) <= "0000001" when "0000", -- alg 0, anodo comum = 1000000 c/ a=MSBit
"1001111" when "0001", -- 1 ac = 1111001
"0010010" when "0010", -- 2 = 0100100
"0000110" when "0011", -- 3 = 0110000
"1001100" when "0100", -- 4 = 0011001
"0100100" when "0101", -- 5 = 0010010
"0100000" when "0110", -- 6 = 0000010
"0001111" when "0111", -- 7 = 1111000
"0000000" when "1000", -- 8 = 0000000
"0000100" when "1001", -- 9 = 0010000
"0001000" when "1010", -- A(hx)= 0001000
"1100000" when "1011", -- B = 0000011
"0110001" when "1100", -- C = 1000110
"1000010" when "1101", -- D = 0100001
"0110000" when "1110", -- E = 0000110
"0111000" when "1111", -- F = 0001110
-- considerar uma lógica para controle do posicionamento do ponto decimal...
sseg(0) <= '1'; -- aqui, ponto fixo em nenhuma casa dp = LSBit
-- uma máquina de estados para enviar os dados serialmente para o 74HC595 da placa
sync_FSM_serial: process(clk, EsF, clk_varre)
begin
-- aqui acontece o processo síncrono, saída = prox estado (no clock) ou reset...
if (clk_varre = '0') then -- clk_varre faz o papel de RESET (='0' faz voltar para
E00)
EsA <= E00;
elsif (rising_edge(clk)) then -- SE clk_varre='1', CADA subida de clk
EsA <= EsF; -- assume prox estado
end if;
end process sync_FSM_serial;
comb_FSM_serial: process(EsA)
begin
rck <= '0'; -- STCP #12 HC595 storage register clk input
sck <= '0'; -- default sck='0' SHCP #11 HC595 shift register clk input
dout <= '0'; -- dout = '1'
case EsA is
-- no estado zero do contador cria o contador Reg_Out (concatena sseg & proxdig)
when E00 =>
Reg_Out <= sseg & proxdig; -- concatena os 16 bits do 'Reg_Out' a serem
enviados
EsF <= E01; -- ajusta o prox estado para E01
when E01 =>
EsF <= E02; -- prox estado
when E02 =>
dout <= Reg_Out(0); -- coloca o bit de dado na saída
sck <= '1'; -- levanta o pulso de clock p. HC595 copiar bit
when E03 =>
sck <= '0'; -- baixa o pulso de clock p. HC595
when E04 =>
when E05 =>
when E06 =>
when E07 =>
when E08 =>
when E09 =>
when E10 =>
when E11 =>
when E12 =>
when E13 =>
when E14 =>
when E15 =>
when E16 =>

when E17 =>
when E18 =>
when E19 =>
when E20 =>
when E21 =>
when E22 =>
when E23 =>
when E24 =>
when E25 =>
when E26 =>
when E27 =>
when E28 =>
when E29 =>
when E30 =>
when E31 =>
when E32 =>
when E33 =>
when others =>
EsF <= E34; -- prox estado: FICA EM STATE 34 com rck = '1'
end case;
end process comb_FSM_serial;
-- FIM do multiplexado de 8 dígitos --

----------------------------------------------------------------------------------
-- Company: UFPE
--
-- Create Date: 08/17/2013
--
-- Descrição:
----------------------------------------------------------------------------------
library IEEE;

end Conta_Mod_M;


begin
elsif rising_edge(clk) then -- sem reset, na subida de clk
end if;


begin


----------------------------------------------------------------------------------
-- Company: UFPE
--
-- Create Date: 08/17/2013
--
-- Descrição:
-- Ajuste os generics N_varre e N_10Hz no início do módulo (na entity) p/ mudar f_varre e
timer
----------------------------------------------------------------------------------
library IEEE;

entity clk_div is
end clk_div;

begin
end if;
end if;
end bh_clk_div;
-- FIM do circuito divisor de clock –----------------------------------------

Apostila - Lógica Programável Ranhel Rev 6

Enviado por

Dados do documento

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Apostila - Lógica Programável Ranhel Rev 6

Enviado por

Direitos autorais:

Formatos disponíveis

Dispositivos Lógicos Programáveis

Apostila com práticas em VHDL.

Evolução da lógica programável

Lógica Programável em ROM:

Circuitos Programáveis Específicos:

•PLA (Programmable Logic Array – ou arranjo lógico programável)

Em 1970, a Texas Instruments desenvolveu um CI programável por máscara baseado em memória

• PAL - (Programmable Array Logic – ou Matriz lógica programável)

Acompanhando o avanço dos circuitos integrados, surgem as primeiras linguagens de descrição de

• GAL - (Generic Array Logic)

Elementos Lógicos Programáveis:

• CPLDs (Complex Programmable Logic Devices)

introduzidos nos chips serialmente; os bits de configuração percorrem um registrador de deslocamento

• FPGA (Field Programmable Gate Array)

• Multiplicadores e Acumuladores embutidos – para facilitar operações aritméticas em hardware de alta

• JTAG (Joint Test Action Group)

LINGUAGEM DE DESCRIÇÃO DE HARDWARE (HDL)

Ciclo de Desenvolvimento utilizando HDL:

• VHDL (Very high-speed integrated circuits Hardware Description Language)

Quais as vantagens de se utilizar VHDL?

• VHDL (regras e sintaxe)

• VHDL não é sensível à maiúsculas e minúsculas, nem aos espaços inseridos;

Um exemplo de trecho de VHDL:

C <= b; -- isto é um comando em que o sinal b é conectado a C

• As seguintes palavras são reservadas:

-- descrição de uma entidade (a interface de um circuito)

-- aqui começa a descrição de "como funciona" o circuito

-- esta declaração cria o circuito XOR com os sinais de entrada

CVH(1) Interruptor_3_IN LED

architecture df_Interruptor_3_IN of Interruptor_3_IN is

-- esta declaração cria o circuito XOR com os sinais de entrada

• Estilos de Descrição em VHDL

Departamento de Eletrônica & Sistemas - UFPE

I. PRÁTICA ZERO... as placas ACIONADO o valor gerado para a FPGA

1.1 Placa de entrada: possui um conjunto de

Fig. 2: placa BASIC_OUT com cabo flat cable

A. Propostas da aula prática:

1) Conectar uma placa BASIC_IN a uma

que um INVERSOR é utilizado como ‘driver’ 3) Fundamentação Teórica: Contém a teoria

II. Organização do Relatório - Placa FPGA ou CPLD;

O relatório deve ser organizado nos - Livros:

ESQUEMA DA PLACA BASIC_IN (Placa de ENTRADA de Sinais)

ESQUEMA DA PLACA BASIC_OUT (Placa de SAÍDA de Sinais)

As placas precisam ser CONFIGURADAS

ESQUEMA DA PLACA BASIC_FPGA – FOLHA 1

ESQUEMA DA PLACA BASIC_FPGA – FOLHA 2

KIT Altera DE2-115

Signal Name FPGA Pin No. Description I/O Standard

Signal Name FPGA Pin No. Description I/O Standard

Departamento de Eletrônica & Sistemas - UFPE

I. Experimento e Simulação 1) Resumo (Opcional): Deve conter um breve

Código em VHDL (esta é uma proposta... faça a sua própria solução).

-- descrição de uma entidade (a interface de um circuito COM O MUNDO EXTERIOR)

-- aqui começa a descrição de "como funciona" este circuito

architecture df_Pratica_01 of Pratica_01 is

1 – lembre-se de alimentar as placas de entrada e saída. O terminal +V está sempre mais

2 – Os terminais +V e GND para alimentar as placas E/S estão marcados na FPGA.

Departamento de Eletrônica & Sistemas - UFPE

I. Experimento e Simulação TABELA VERDADE:

II. Organização do Relatório

-- descrição de uma entidade (a interface de um circuito COM O MUNDO EXTERIOR)

-- PORÉM, vamos utilizer o conceito de LOGIC_VECTOR para definir entrada/saída

-- aqui começa a descrição de "como funciona" este circuito

Departamento de Eletrônica & Sistemas - UFPE