Apostila - Lógica Programável_Ranhel_Verilog_v03 (1)

Prévia do material em texto

Dispositivos Lógicos Programáveis 
 
 
 
 
 
Apostila com práticas em VERILOG. 
 
 
 
 
 
 
 
 
Junho – 2019 (versão 3). 
Prof. João Ranhel 
Apostila: Dispositivos Lógicos Programáveis e Verilog - Prof. João Ranhel 
 
1 
Introdução 
 
Esta é uma apostila para introduzir dispositivos programáveis (“reconfiguráveis”) aos alunos do curso de 
Eletrônica Digital (disciplina ESTI002-17 no curso de Engenharia de Informação/CECS/UFABC). Acredito, e as 
evidências de mercado/indústria apontam, que circuitos integrados (CI) digitais discretos pertencem ao 
passado. Atualmente, projetos digitais são criados em dispositivos programáveis. São ao menos três linhas 
de CIs que permitem reconfiguração: CPLD (complex programmable logic devices – com centenas de blocos 
lógicos programáveis), FPGA (field programmable logic arrays – com milhares/milhões de blocos lógicos 
associados à memória interna e circuitos de suporte), e SoC (system on chip – um FPGA e um ou mais núcleos 
de CPU/processador, memória, etc. integrados no mesmo chip). 
Contudo, como ensinar que PLD (programmable logic devices - dispositivos lógicos programáveis) podem 
ser compreendidos com a mesma facilidade que os circuitos da geração anterior? A primeira providência 
pode ser tomar contato com os circuitos programáveis. 
Nesse sentido, temos a sorte de ter atualmente na UFABC um dos kits mais completos para ensino de PLDs. 
Usamos o kit DE2-115 da Terasic, que possui um FPGA da Altera/Intel com 115.000 blocos programáveis. O 
aluno perguntará se isso é muito – sim, é muito mais do que precisamos para fazer a disciplina. Em todas as 
aulas práticas que fazemos nessa disciplina não usamos mais de uns 5.000 blocos lógicos. 
Este é o argumento fatal a favor da mudança de paradigma para PLDs em vez dos CIs discretos. Fazer um 
projeto, do protótipo à placa de circuito final (PCI – placa de circuito impresso ou, PCB – printed circuit board) 
era um processo demorado e custoso. Hoje, estes kits permitem prototipagem rápida e, caso não demande 
criação de milhões de PCBs, é possível usar os circuitos programáveis nos projetos finais. Para se ter uma 
ideia, um CPLD com 32 células de programação (grosso modo equivale a 32 CIs discretos) custa em torno de 
US$ 1,50. Um FPGA com 6.000 blocos lógicos tem custo a partir de US$ 12,50. Estes custos têm caído 
rapidamente. Apenas para comparação, um 74HC163 (contador da geração anterior) custa ~US$ 0,50 por CI. 
A tendência é que fique mais difícil e mais caro obter componentes discretos devido à diminuição da 
produção em escala. A economia de tempo e custo de horas de engenharia de desenvolvimento (custo NRE 
– non-recurrent engineering), capacidade de customização de projetos, economia de energia, aumento de 
velocidade de processamento de informação, redução do tamanho das PCBs, e vários outros benefícios, 
apontam que os PLDs se tornaram a forma irreversível de se fazer projetos em eletrônica digital. 
Os kits de desenvolvimento do padrão da DE2-115 são caros e trazem vários 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.) que são desejáveis 
para quem desenvolve sistemas digitais avançados. Contudo, para o aluno que começa a aprender sobre 
portas e blocos lógicos combinacionais, circuitos sequenciais e máquinas de estado, há muito recurso nestes 
kits e esse excesso pode intimidar. 
Acredito que se deve ensinar lógica programável focado no objeto a ser programado (CPLD e FPGA). Por isso, 
sou adepto das PCBs de FPGA e CPLD mínimas. Elas possuem apenas os circuitos integrados básicos para 
alimentação do chip, cristais osciladores, conectores ligados direto nos pinos do CI, e memória de 
configuração (dispensável porque FPGA e CPLD têm memória de programação interna). 
Um kit FPGA mínimo (com FPGA Cyclone IV – EP4CE6) custa menos de US$ 30 pela Internet, e um Kit CPLD 
(MAX II EPM240) custa menos de US$ 12. Muitos alunos podem comprar um kit assim, apesar de a burocracia 
brasileira dificultar a importação, mesmo de valores abaixo de US$ 50. Tais kits mínimos podem ser usados 
para fazer trabalhos de conclusão de curso e até mesmo para aplicações profissionais. 
Acreditando que estudantes devem ter acesso a kits de PDLs para criar protótipos em casa, solicitei a alguns 
alunos que ajudassem a criar kits mínimos. O resultado foi a confecção de placas de alta qualidade, com os 
arquivos desenvolvidos no CAD Eagle, livres de royalties para quem quiser criar seu próprio kit FPGA. 
Apostila: Dispositivos Lógicos Programáveis e Verilog - Prof. João Ranhel 
 
2 
Geralmente fazemos lotes de placas de circuito impresso (PCBs) e o custo de produção de cada PCB tem sido 
entre 1 e 2 dólares sem os componentes. Usamos um CI FPGA que custa menos de US 18. As listas de 
materiais estão disponíveis, portanto, o aluno pode montar sua própria FPGA. Evidentemente, é mais em 
conta fazer um pedido de uma placa pronta em um site no exterior. 
Nesta apostila vamos descrever como realizar as aulas práticas em um kit mínimo e no kit DE2-115 da Terasic. 
A ideia é sintetizar os circuitos nos FPGAs, ou seja, transformar os projetos em circuitos físicos na placa. As 
linguagens HDL permitem simulação, parte importante da cadeia de projeto digital. Técnicas de simulação 
serão objeto aprofundado em outra disciplina; por enquanto, nosso foco será síntese de circuitos. Nessa 
disciplina, sinais de entrada para FPGA serão fornecidos por chaves, botões ou teclados simples, e saídas 
serão LEDs ou displays de 7-segmentos. 
 Aprenderemos simular e sintetizar circuitos no software EDA (Electronic Design Automation – programa 
assistente de projetos eletrônicos) Altera/Intel Quartus (versão Quartus II ou Quartus Prime). O aluno pode 
baixar a versão livre e sem custo desse programa para utilização em seu computador pessoal. Quem utilizar 
o kit mínimo precisa de um adaptador USB-JTAG (USB-Blaster da Altera/Intel) para programar FPGAs. 
O comportamento do CI FPGA/CPLD/SoC será descrito por uma linguagem de descrição de hardware (HDL – 
hardware description language) e, dentre algumas linguarens para esse fim escolhemos a Verilog por ser 
hoje um padrão na indústria, além de mais simples e mais indicada para um primeiro contato com HDL. 
Pode parecer aumento de complexidade ensinar “descrição” (ou “configuração”) de hardware logo no 
primeiro contato com eletrônica digital; mas a prática tenha mostrado que não. É fato que os alunos devem 
aprender uma nova linguagem; porém, montar “tabelas” verdade, extrair delas “equações” booleanas (ou 
seja, leis matemáticas), transformar equações em “diagramas eletrônicos” são partes de um processo 
contínuo que tem agora uma nova forma de representação: a HDL. Ou seja, HDL é apenas outra forma de 
representar o mesmo circuito, e que facilita muito para o engenheiro fazer alterações no projeto. 
A apostila é um texto guia sobre PLDs, sobre o básico de Verilog, e o uso dos kits em laboratório, tanto DE2-
115 quanto os kits míninos. Um livro para aprofundar nesses assuntos é imprescindível. O aluno que ler a 
apostila no início do curso (ESTI002-17 Eletrônica Digital) provavelmente não compreenderá aspectos 
técnicos descritos na explicação dos PLDs (próxima seção), tais como memória ROM, blocos lógicos 
programáveis, Look-Up Table, multiplex e decodificadores, nem flip-flops e somadores, além de outros. Não 
se preocupem porque ao final do curso todos esses conceitos terão sido abordados. Dessa forma, ao reler 
esta parte da apostila após ter cursado a disciplina o aluno deverá estar confortável e entender cada aspecto 
técnico da evolução e construção dos PLDs atuais. 
 
João Ranhel 
Junho de 2019 
 
Apostila: Dispositivos Lógicos Programáveis e Verilog - Prof. João Ranhel 
 
3 
1. Lógica Programável 
 
Dispositivos Lógicos Programáveis (PLDs – programmable logic devices) são componentes eletrônicosutilizados para construir sistemas digitais. Introduzidos na década de 1980, estes circuitos surgiram para 
atender a demanda crescente na complexidade dos sistemas digitais, diminuir e simplificar placas de circuito 
impresso (PCBs), reduzir consumo de energia, aumentar velocidade de operação, entre outras. 
 
CI discreto monolíticos Programable Logic Device (FPGA) 
(imagens modificadas da internet) 
Ao contrário de um circuito integrado (CI) discreto com portas ou blocos lógicos, cuja função é fixa, um PLD 
NÃO tem função prefixada quando é fabricado; assim, é o usuário/criador do sistema digital que configura o 
PLD determinando sua funcionalidade. Por hábito, essa “configuração” é chamada “programação” de PLDs; 
mas não deve ser confundida com os programas tradicionais de computadores. O que o usuário descreve é 
um hardware, e o que o programador de computador faz é criar uma sequência de instruções que um 
processador executará passo a passo. 
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 geral, um ASIC é prototipado 
primeiro em PLDs, e assim que a funcionalidade do sistema é comprovada, cria-se um ASIC a partir da 
descrição de hardware usada na prototipagem, com os devidos ajustes para mudança de implementação. 
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 reconfiguradas. Apesar de custarem mais que os ASICs 
por unidade, 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, para muitos projetos os PLDs são os circuitos finais. Em 
comparação com outras tecnologias de circuitos integrados digitais (por exemplo, discretos), os dispositivos 
de lógica programável apresentam um ciclo de projeto menor e custos reduzidos. 
Os PLDs podem, atualmente, ser classificados em três tipos de circuitos: CPLDs (complex programmable logic 
device), FPGAs (Field Programmable Logic Arrays), e SoCs (Systems on Chips – que são FPGAs associadas a 
microprocessadores em um único chip. CPLDs são mais simples que FPGAs e são utilizados 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, ou seja, na falta de energia a configuração permanece. 
Apostila: Dispositivos Lógicos Programáveis e Verilog - Prof. João Ranhel 
 
4 
FPGAs permitem implementar sistemas lógicos de grande complexidade por terem 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; mas, 
principalmente, porque possuem blocos de memória interna configurável de acordo com a necessidade do 
usuário – por exemplo, é possível configurar memória RAM de porta dupla (dual-port RAM). Existem CIs 
FPGAs com configuração não volátil, mas a maioria utiliza RAM estática para programação/configuração, que 
é volátil e perdem a configuração ao serem desligados. Portanto, uma característica marcante dos FPGAs é 
que precisam ser reconfigurados cada vez que são desligados. Essa reconfiguração pode ser feita de várias 
maneiras diferentes: automaticamente, após o reset, pelo próprio CI FPGA que lê os bits de configuração 
numa memória externa; ou por um microprocessador externo que envia os bits para dentro do CI FPGA; ou 
ainda via uma porta especial chamada JTAG, que consiste em um conjunto de pinos do FPGA que permitem 
programação e debugging serial. 
Vamos trabalhar com os CIs FPGA da Altera / Intel. Portanto, vamos explicar o que há dentro de uma família 
de FPGAs especificas chamada CYCLONE IV. 
 
1.1 Evolução da lógica programável 
Antes de surgirem os CIs de lógica programável (PLDs) as placas de circuito eletrônicas (PCBs) só continham 
CIs discretos que eram interligados por trilhas de cobres nas placas. Isso ocupa espaço na placa porque cada 
CI dedicado tinha seu encapsulamento. Os primeiros CIs foram encapsulados na forma dual-inline package 
(DIP – ainda existentes). Eles atravessam as PCBs e são soldados do outro lado da placa, limitando a 
quantidade de componentes na PCB. Um avanço foi o surgimento dos CIs para montagem de superfície que 
não exigem a perfuração da placa, portanto o lado oposto da placa pode também ter componentes. Mas, o 
que se mostrava mais necessário é que CIs não precisassem ser encapsulados e seus módulos funcionais 
pudessem ser apenas reconfigurados para se obter melhor uso do espaço, da energia, etc. Assim, a indústria 
de componentes eletrônicos passou a pensar em criar CIs que não tivessem funções pré-definidas como os 
discretos, e sim, que fossem circuitos programáveis ou reprogramáveis. A ideia é que qualquer função lógica 
pode ser obtidas a partir de portas AND, OR, NOT interligadas internamente, e não do lado de fora de um CI 
discreto. O avanço de tecnologias de integração de transistores permitiu gradativamente a construção de CIs 
dessa natureza. 
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 nas memórias do tipo ROM. Antes das PLD's serem inventadas, as 
memórias ROM/PROM foram utilizadas para implementar lógica combinatória. Considere uma ROM com m 
entradas (m linhas de endereço) e n saídas (n 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}. Pode-se obter as seguintes combinações com essas entradas (ou, os seguintes endereços 
de memória): �̅��̅�𝐶̅ + �̅��̅�𝐶 + �̅�𝐵𝐶̅ + �̅�𝐵𝐶 + 𝐴�̅�𝐶̅ + 𝐴�̅�𝐶 + 𝐴𝐵𝐶̅ + 𝐴𝐵𝐶. 
Apostila: Dispositivos Lógicos Programáveis e Verilog - Prof. João Ranhel 
 
5 
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, com m=3={A,B,C} e n=8{D0, D1, D2, D3, D4, D5, D6, D7}, em D0 
poderia ser gravar: {1 + 0 + 0 + 1 + 1 + 0 + 0 + 0} que significa que, no bit D0 , seria obtida a seguinte função: 
𝑫𝟎 =�̅��̅�𝐶̅ + 0 + 0 + �̅�𝐵𝐶 + 𝐴�̅�𝐶̅ + 0 + 0 + 0. 
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, tornando a ROM um dispositivo lógico disponível 
para aplicações variadas. O inconveniente é que as ROMs ficam com grande parte de seu circuito inativo e 
sem função, além de serem mais lentas que os circuitos convencionais, de consumirem mais energia, de não 
permitirem implementação de lógica sequencial sem componentes externos. Por esses motivos, 
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 era atender uma 
demanda de engenharia que precisava de lógica combinacional programável para minimizar espaços nas 
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 a sigla (o acrônimo) PLA(Programmable Logic Array) 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, mas não possuíam registradores/memória. A ideia do PLA é ilustrada na figura 2: 
http://pt.wikipedia.org/wiki/Texas_Instruments
http://pt.wikipedia.org/wiki/National_Semiconductor
Apostila: Dispositivos Lógicos Programáveis e Verilog - Prof. João Ranhel 
 
6 
 
Fig. 2: arranjo típico do PLA: ambas, a matriz AND e a matriz OR são programáveis (imagem do manual - National). 
Este tipo de circuito era difícil de ser programado devido ao fato do projetista ter que escolher tanto os 
termos que produziam os produtos (AND) quanto os termos da soma (OR). Extrair o melhor dos CIs requeria 
dos projetistas realizar simplificações dos circuitos desejados, o que resultava em pouca economia de tempo 
de projeto. Simplificação de circuito era um processo manual que requeria grande involvimento intelectual 
e atenção dos projetistas, resultando muitas horas de desenvolvimento de engenharia. 
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. Ainda com limitações, os PLAs foram os primeiros 
passos no sentido da criação de lógica programável que efetivamente diminuiam espaços nas placas, 
melhoravam o desempenho em velocidade e em consumo de energia. 
 
• PAL - (Programmable Array Logic – ou Matriz lógica programável) 
No início de 1978, a fabricante Monolithic Memories, Inc (MMI) introduziu um dispositivo diferente dos PLAs, 
com uma arquitetura mais simples porque omitia a matriz programável OR, ou seja, a matriz OR está pré-
configurada. Esse dispositivo ficou conhecido pelo acrônimo PAL (Programmable Logic Arrays). O novo 
arranjo torna os componentes mais rápidos, menores e mais baratos, e o projetista deveria optar apenas 
pelo tipo de arranjo de saída que desejava. Os PAL possuíam ainda flip-flops (ver Fig. 3) incorporados às 
matrizes OR, que podiam ser programados para criar circuitos sequenciais e máquinas de estados finitos 
(FSM) sem auxílio de circuitos discretos externos. 
Em certo sentido o 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 internos no 
chip, usados para programar o componente. Os componentes PAL 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. A primeira função das linguagens 
seria documentar circuitos digitais, mas logos viu-se que era possível usar HDL para simular circuitos digitais 
em computador. Nessa época, algumas linguagens passaram a oferecer opções de síntese de circuitos; ou 
Apostila: Dispositivos Lógicos Programáveis e Verilog - Prof. João Ranhel 
 
7 
seja a capacidade de converter o texto da descrição do circuito em configuração (ou programação) dos 
circuitos integrados recém criados. 
 
Fig. 3: circuito PAL PLUS 16R4 da Philips: a matriz AND é programável e a matriz OR é fixa. Note-se a presença de flip-
flops, apropriados para criação de FSM (imagem do manual Philips). 
• GAL - (Generic Array Logic) 
Com o sucesso dos PALs, em 1985 a Lattice Semiconductor expandiu a ideia criando os circuitos conhecidos 
como GAL (Generic Array Logic), que tem as mesmas propriedades lógicas dos PAL mas podem ser apagadas 
e reprogramadas. Estes circuitos se mostraram úteis no estágio de prototipagem de projetos, quando alguns 
erros lógicos costumam surgir. Os GAL podem ser programados e reprogramados usando um programador 
PAL ou usando um circuito especializado, embutido em alguns chips. Um componente similar, o PEEL 
(programmable electrically erasable logic), foi produzido pela ICT1. 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. 
 
Elementos Lógicos Programáveis: 
A Altera/Intel 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. O principal conceito introduzido neste tipo de tecnologia é a LUT (Look-up Table). Uma 
LUT (tabela de consulta) é composta de um multiplexador (MUX) ( ver figura 4) associado a um registrador 
de deslocamento (SR: shift-register). Os bits em paralelo na saída do SR são ligados a um MUX. 
 
1 Fonte: http://pt.wikipedia.org/wiki/Dispositivo_l%C3%B3gico_program%C3%A1vel (17/09/2014) 
http://pt.wikipedia.org/wiki/Dispositivo_l%C3%B3gico_program%C3%A1vel
Apostila: Dispositivos Lógicos Programáveis e Verilog - Prof. João Ranhel 
 
8 
 
 
 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. 
Com esse arranjo, a saída F do MUX é selecionada em função das entradas (A e B – no exemplo da Fig. 4). 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 no shift-register. Por exemplo, no esquema da Fig. 4, para obter a equação 𝐹 = 𝐴. 𝐵 + �̅�. �̅� 
precisamos gravar os bits “1001” nos flip-flops do SR (cujas saídas se tornam as entradas I1...I4 do mux). Para 
obter a função 𝐹 = 𝐴 ⊕ 𝐵 (função XOR) precisamos gravar os bits “0110” nos flip-flops do registrador de 
deslocamento (𝑋𝑂𝑅 = �̅�. 𝐵 + 𝐴. �̅�). 
Associado às LUTs colocam-se entradas adicionais (geralmente ligadas a portas XOR para criar somadores e 
subtratores em cascata) e um ou mais flip-flops do tipo D para reter dados; ou seja, para facilitar a criação 
de lógica sequencial. A esse conjunto de blocos lógicos funcionais a Altera/Intel dá o nome de Logical 
Elements (LE), ou elementos lógicos, como pode ser visto na Fig. 5. Outro nome comum é Configurable Logic 
Block (CLB), usado pela Xilinx, outra fabricante de FPGAs. Os blocos de lógica configurável (CLB) são os blocos 
fundamentais na construção das tecnologias atuais de FPGA e CPLDs. 
 
 Fig. 5: Esquemático de um bloco lógico configurável composto de umaLUT, um flip-flop e um multiplex de saída. 
A complexidade dos elementos lógicos varia entre tecnologias, 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 um CPLD da Altera. 
Apostila: Dispositivos Lógicos Programáveis e Verilog - Prof. João Ranhel 
 
9 
 
 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 da 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. 
Relativamente, PALs e GALs são construídos pequenos, com 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) 
O acrônimo CPLD (Complex Programmable Logic Devices) define uma classe de componentes que contém o 
equivalente a vários PALs integrados no mesmo chip. Esses PALs podem internamente ser interligados por 
meio de barramentos (conjunto de fios paralelos que possuem transistores fazendo o papel de chaves que 
os interligam). Dentro de um único chip CPLD pode ter centenas ou milhares de elementos lógicos (LE) 
programáveis, que podem ser interconectados por barramentos programáveis implementados no chip. 
CPLDs podem assim substituir milhares de portas lógicas e/ou blocos lógicos vendidos em CIs discretos. E os 
barramentos programáveis podem fazer o papel de milhares de trilhas de cobre nas PCBs – ou centenas e 
milhares de fios nos protoboards! 
Alguns CPLDs 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. Devemos lembrar que 
para a lógica interna do CI executar alguma função no mundo externo é preciso disponibilizar pinos no chip 
para conexão de entrada e/ou saída dos sinais lógicos. Com o aumento da complexidade os chips têm cada 
vez mais pinos para conexão externa – hoje da ordem de centenas, mais de mil, e até >2000 pinos.2 
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. Essa técnica é conhecida como In-Circuit Serial 
 
2_https://www.xilinx.com/support/documentation/user_guides/ug1099-bga-device-design-rules.pdf 
http://www.aetpcb.com/aet/net_resources/help/BGA_Breakouts_and_Routing.pdf 
 
https://www.xilinx.com/support/documentation/user_guides/ug1099-bga-device-design-rules.pdf
http://www.aetpcb.com/aet/net_resources/help/BGA_Breakouts_and_Routing.pdf
Apostila: Dispositivos Lógicos Programáveis e Verilog - Prof. João Ranhel 
 
10 
Programming (ICSP). O CPLD contém um circuito que decodifica os dados seriais e configura o chip. Alguns 
fagricantes usam nome proprietário para o sistema de configuração dos chips com essa metodologia; e.g. a 
Lattice chama (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, que é um padrão 
estabelecido pelo IEEE. Foi dito que o CPLD é programado via serial, esta é a razão por termos utilizado um 
registrador de deslocamento (SR ou shift-register) na representação dos bits de configuração da LUT na Fig. 
4. Na verdade, os bits de configuração de um CPLD ou FPGA (tanto os das LUTs quanto os que configuram os 
barramentos e interconexões) são introduzidos nos chips serialmente, e percorrem um longo registrador de 
deslocamento 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 (imagem do manual Altera). 
Os CPLDs modernos são muito utilizados para fazer pontes entre barramentos (bus-bridge) em PCBs 
complexas, quando há diferenças entre tipos de barramentos num sistema. Podem ainda ser utilizados para 
fornecer lógica complementar para FPGAs, ou em substituição a circuitos que usariam centenas de circuitos 
integrados discretos. 
Atualmente (05/2017) é possível comprar uma placa (kit) de desenvolvimento CPLD em sites da internet por 
≈ US$ 10,00; como a placa da figura 8. O CI sozinho custa em torno de US$ 7,50, mas comprado aos milhares 
o preço cai consideravelmente. Os 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) do chip (EPM240 Altera MAX II CPLD) são ligados a quatro barras de pinos 
duplos (latch connectors). Por meio desses pinos o usuário tem acesso aos pinos do chip que podem ser 
configurados para entrada, saída, bidirecionais; facilitando ao usuário configurar o circuito como queira. Por 
esse motivo, essas placas de PCB são apropriadas para criar protótipos rápidos. 
Apostila: Dispositivos Lógicos Programáveis e Verilog - Prof. João Ranhel 
 
11 
 
Fig. 8: kit EPM240 Altera MAX II CPLD. O kit custa ~ US$ 10,50 3. Baseado no CPLD EPM240 possui: 240 elementos 
lógicos LEs, 192 macro células, 80 pinos I/O, opera até 340 MHz (foto divulgação da internet). 
Uma vez tendo terminado um protótipo, o usuário poderá optar por criar sua própria placa (usando o chip 
do kit), ou incorporar o kit em seu projeto final – ganhando tempo. Para vários projetos de conclusão de 
curso estes kits são mais que suficientes. 
 
• FPGA (Field Programmable Gate Array) 
A sigla FPGA (Field Programmable Gate Array) se referem a uma família de CIs reprogramáveis que usam 
conjuntos de elementos lógicos (LEs, descritos anteriormente) como unidades básicas para construção da 
lógica configurável. 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. Associe-se a isso a integração em grande escala permitindo que 
um chip possua milhares e até milhões de LEs semelhantes aos da Fig. 6. 
Na tecnologia da família de FPGAs Cyclone V a Altera/Intel chamou de ALM (adaptive logic modules) cada 
elemento lógico programável (LUT + 4 registradores + adders + lógica adicional), com mostrado na Fig. 9. 
 
3 http://www.dx.com/pt/p/altera-max-ii-epm240-cpld-development-board-214282 (em 10/05/2017) 
http://www.dx.com/pt/p/altera-max-ii-epm240-cpld-development-board-214282
Apostila: Dispositivos Lógicos Programáveis e Verilog - Prof. João Ranhel 
 
12 
 
Fig. 9: ALM (adaptive logic modules) são os elementos lógicos programáveis na família Cyclone V da Altera. Cada ALM 
possui 4 registradores, 2 LUTs com 6 entradas, 8 MUXs e lógica adicional. 
Os ALMs são os componentes-base na construçãodos LAB (logic array block) e MLABs. Os LABs são os blocos 
de arranjo lógicos que abrigam os primeiros arranjos de ALMs, como na Fig. 10 abaixo. 
 
Fig. 10: Estrutura dos LAB (logic array block) na família Cyclone V. LABs e MLABs formados por vários ALMs agrupados. 
MLABs são LABs que podem ser usados como memória RAM. Note as estruturas de interconecção entre blocos lógicos 
na forma de barramentos em colunas e linhas, todos programáveis, ou seja, cada uma das milhares de vias nesses 
barramentos possui um transistor que faz o papel de chave, ligando ou desligando entrada ou saída do LAB às vias. 
Apostila: Dispositivos Lógicos Programáveis e Verilog - Prof. João Ranhel 
 
13 
Além de possuirem as estruturas de blocos lógicos programáveis e barramentos que os interconectam, as 
FPGAs possuem também subsistemas ou circuitos complexos 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, circuitos nos FGPAs avançados possuem PLLs (Phase 
Locked Loop) que permitem multiplicar e dividir o clock de entrada globalmente pelo chip, gerando duty-
cicles variados e compensando atrasos na propagação de sinais. 
• 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 implementar operações aritméticas no hardware em 
alta velocidade, facilitando implementação de processamentos de sinais digitais (DSPs). 
• Bloco de memória RAM – internamente os chips FPGAs possuem RAM estática de alta velocidade, a maioria 
com suporte a dual-port RAM. Note-se que há diferença entre a memória de programação do FPGA (que são 
bits que programam as LUTs, os elementos lógicos, e as interconexões de barramento) e a memória RAM 
implementada no FPGA (que são bits disponíveis para uso como memória de rascunho pelos circuitos que o 
FPGA estiver executando). 
É possível comprar um kit FPGA atualmente (Fig. 10) por valores como ~US$ 27,00 (05/2017)4. Um circuito 
integrado FPGA hoje, com 6.000 LEs pode custar em torno de US$ 12,00 ou US$ 18,00 dependendo da versão. 
Por outro lado, há CIs FPGA especializados que custam até US$ 20.000,00 ou mais por CI. 
 
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 disponíveis para o 
usuário usar para input ou output de seu projeto (foto divulgação no site DX na internet). 
Uma tendência também é embutir microprocessadores (µP) dentro dos CIs FPGAs, criando os chamados SoC 
(System on Chips). Esse componente permite aproveitar o melhor dos dois mundos: a flexibilidade de rodar 
software nos µPs, dentro de um 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 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 
 
4 http://www.dx.com/pt/p/coreep4ce6-ep4ce6e22c8n-altera-cyclone-iv-cpld-fpga-development-core-board-w-full-io-
expanders-297718 
http://www.dx.com/pt/p/coreep4ce6-ep4ce6e22c8n-altera-cyclone-iv-cpld-fpga-development-core-board-w-full-io-expanders-297718
http://www.dx.com/pt/p/coreep4ce6-ep4ce6e22c8n-altera-cyclone-iv-cpld-fpga-development-core-board-w-full-io-expanders-297718
Apostila: Dispositivos Lógicos Programáveis e Verilog - Prof. João Ranhel 
 
14 
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, por exemplo, ou 
uma trilha a ser feita na PCB. Só para dar um exemplo, se um FPGA tiver 2 milhões de bits de configuração e 
o usuário gastasse 1 segundo para ligar cada bit, ele levaria ~556 horas contínuas para ligá-los; ou ~ 23 dias 
contínuos sem parar, contando que nenhum erro foi feito. 
Fica evidente a necessidade da assistência de um computador para realizar tal tarefa. Para isso foram criadas 
as ferramentas Electronic Design Automation (EDA ou ECAD), que fazem a “automação do projeto 
eletrônico”. O programa EDA da Altera/Intel no qual o usuário descreve o hardware de seu projeto é o 
QUARTUS II ou o Quartus Prime (ou versão mais atual). 
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). Os arquivos de descrição em HDL são introduzidos no 
QUARTUS. As duas linguagens mais conhecidas para descrição de hardware são VHDL e Verilog. Outras 
linguagens com recursos mais avançados estão ganhando corpo ultimamente, como o SystemVerilog e 
SystemC. A linguagem Verilog será usada em nossas aulas práticas descritas adiante 
• JTAG (Joint Test Action Group) 
Já na 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 estudar e 
solucionar o problema o IEEE (Institute of Electrical and Electronics Engineers) criou um grupo de trabalho que 
ficou conhecido como Joint Test Action Group. Este grupo criou um padrão, denominado IEEE 1149.1, que 
define uma ferramenta para testes de Cis e PCBs, 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 chip; ou seja, os núcleos lógicos do CIs ficam desconectados do 
mundo externo. O boundary-scan permite também desconectar as trilhas externas da PCB da lógica interna; 
portanto, uma trilha da placa pode ser isolada. 
 
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. 
Mais ainda, o sistema de chaveamento implementado em cada pino do 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). 
Apostila: Dispositivos Lógicos Programáveis e Verilog - Prof. João Ranhel 
 
15 
Para que essa funcionalidade fosse implementada, os CIs com JTAG possuem pinos adicionais dedicados, e 
podem ser conectados em cadeia. Dessa forma, é possível deslocar bits na cadeia de forma a ‘ler’ o estado 
de cada pino isolado nos CI da cadeia. Por exemplo, pode-se excitar uma trilha e verificar se osinal chega 
apenas nos pinos aos quais ela está ligada, verificando se há rompimento ou curto nas trilhas. 
Por outro lado, se é possível desconectar os CIs e excitá-los internamente, então é possível usar o boundary 
scan para pelo menos dois outros propósitos: gravar bits na lógica interna do chip e verificar o status desses 
bits. Ou seja, pode-se configurar ou programar os chips JTAG com os CIs conectados às PCBs. Por outro lado, 
pode-se ler os bits dentro do chip, então, é possível usar o JTAG como ferramenta de depuração (debugging) 
lendo o status de qualquer bit dentro do chip. A Fig. 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 TCK e TMS em paralelo, enquanto TDI e 
TDO 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 (Fig. 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. Isso 
forma a cadeia boundary-scan que permite testar a placa, programá-la, e debugar projetos (imagem da internet) 
Vamos utilizar o terminal JTAG da placa para configurar o kit FGPA/CPLD, por isso é preciso um adaptador 
serial que converta a saída do PC para a entrada JTAG do kit. O adaptador USB-Blaster (Fig. 13) da Altera 
serve para esse fim. Ele vem com dois cabos: (a) um que se conecta à USB do PC e ao conversor de níveis; e 
(b) um flat-cable JTAG (10 pinos) que é conectado ao conversor de níveis e ao conector JTAG da placa. 
 
Fig. 13: Adaptador JTAG da Altera (USB-Blaster): o cabo preto é conectado na USB do PC e ao conversor de níveis – a 
caixa USB-Blaster. O flat-cable é conectado à caixa e no terminal JTAG da placa (foto divulgação da internet). 
Apostila: Dispositivos Lógicos Programáveis e Verilog - Prof. João Ranhel 
 
16 
2. LINGUAGEM DE DESCRIÇÃO DE HARDWARE (HDL) 
 
Como já foi dito, existem duas linguagens de descrição de hardware mais utilizadas atualmente: VHDL e 
Verilog. Vamos utilizar a última por entender que ela está mais próxima do padrão que se utiliza na indústria 
e no desenvolvimento de CIs; embora VHDL também seja uma linguagem eficiente e seja bastante utilizada 
na Academia e em projetos militares. A principal vantagem da modelagem de circuitos por linguagem 
descritiva, quando comparada à modelagem por captura de esquemático, é que em HDL o projeto se torna 
independente da plataforma de desenvolvimento (IDE) na qual se está trabalhando. Veremos a plataforma 
Quartus, mas um projeto descrito em HDL pode ser perfeitamente portado para ISE Design Suite – Xilinx, ou 
para IDE Vivado – Xilinx, ou qualquer outra IDE. 
 
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 Verilog. Durante o processo o projetista pode verificar sintaxe, etc. e garantir que cada 
arquivo de código gerado está descrito corretamente. Geralmente, cada arquivo Verilog descreve um 
circuito, um bloco lógico, um pequeno 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 global – 
algo mais complexo. Um arquivo deve descrever como os vários arquivos Verilog estão interligados – ou seja, 
deve existir um arquivo também em Verilog que descreve a estrutura global do projeto. 
O fluxo de projeto pode ser visto na Fig. 14. Após descrever em Verilog os blocos que fazem parte do sistema 
(Fig. 14 System Design) o usuário pode e deve verificar a funcionalidade do projeto (bloco no canto superior 
direito: Functional Simulation, Design Rule Checking e RTL View). A fase de simulação de projetos é 
importante porque é mais fácil simular e observar a resposta do circuito primeiro dentro do computador do 
que completar o processo, gravar os bits de programação no FPGA e então executar o processamento da 
informação em hardware. Sem contar que o processo de debugging (depuração) no hardware é menos 
flexível do que no computador, usando excitação e verificação virtual. Durante o processo de simulação e 
verificação é possível ver graficamente no computador o comportamento e as respostas dos blocos circuitos 
e blocos descritos. É possível analisar tanto em nível de sinal lógico individual quanto no nível da transferência 
de pacotes de dados entre registradores (RTL). 
 
Fig. 14: Fluxo de criação de um projeto em HDL (retirado manual Quartus II) 
Na sequência do fluxo do projeto, o usuário deve impor as restrições ao circuto desejado, ou seja, deve 
configurar quais pinos físicos do CI receberá quais sinais eletrônicos, que na descrição de hardware foram 
Apostila: Dispositivos Lógicos Programáveis e Verilog - Prof. João Ranhel 
 
17 
tratados por nomes abstratos. Por exemplo, na descrição do circuito podemos chamar um sinal de LED_01 
e, para fazer esse LED acender temos que restringir esse sinal a um pino específico do FPGA (pino ao qual foi 
ligado esse LED). Ainda nessa fase o usuário pode fazer análises de performance aproximada e consumo, 
ambas baseadas em simulação (Fig. 14 – I/O Assignment & Analysis). 
Na sequência do fluxo o usuário deve fazer a síntese propriamente dita (RTL Synthesis). O programa EDA irá 
rotear as funções desejadas dentro do dispositivo escolhido (Place & Route Process). O programa vai então 
gerar um arquivo que é uma sequência de bits ‘1’s e ‘0’s respeitando o que foi descrito (a função que deve 
ser executada) associada aos pinos físicos do FPGA, para o dispositivo escolhido, ou seja, aquele CI FPGA 
escolhido (e.g. Cyclone IV EP4CE6E22C8N ou Cyclone V SoC—5CSXFC6D6F31C6N). 
Depois que o programa EDA realizou essa “compilação”, é possível enviar essa sequência de bits para o FPGA, 
esse processo é melhor definido como a gravação do arquivo configurador no dispositivo, mas, dentro dos 
EDAs esse processo é chamado “programação do FPGA”. 
Projetistas já em estágio avançados podem editar os locais da distribuição de funções na planta (fabric) do 
chip (Chip Editor). Podem também analisar por meio de simulações as áreas de dissipação de energia no 
FPGA de forma mais realística. Podem ainda analisar a temporização dos sinais de forma estimada e mais 
realista, perto do efeito real que a propagação de sinais terá no FPGA, embora esses processos consumam 
muito tempo. Para essas finalidades, os projetistas 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. 
É possível também utilizar o JTAG e outras ferramentas de software para fazer debugging do hardware 
sintetizado no CI, direto na PCM (Fig. 14 In-System Verification). 
Esse é o fluxo 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 é 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. 
 
Apostila: Dispositivos Lógicos Programáveis e Verilog - Prof. João Ranhel 
 
18 
• Verilog (Verilog Hardware Description Language – Verilog HDL) 
Verilog foi uma das primeiras linguagens para descrição de hardware (HDL) a ser inventada ( 1983/84, para 
a Gateway Design Automation, comprada pela Cadence Design Systems). Inicialmente a linguagem era 
proprietária, e tinha por objetivo descrever circuitos e permitir simulações; mais tarde, também lhe foi 
acrescentada a síntese de circuitos. Verilog foi posteriormente tornada não-proprietária. Diante do avanço 
da linguagem VHDL na época, a Cadence tornou a linguagem aberta para padronização, transferindo-a para 
domínio público subordinada à Open Verilog International (OVI – hoje Accellera). Posteriormente, submetida 
ao IEEE a linguaghem tornou-se o padrão (IEEE Standard 1364-1995), também conhecido por Verilog-95. Seis 
anos mais tarde, extensões foram submetidas para padronização no IEEE a fim de suprir deficiências 
encontradas pelos usuários na versão original, e se tornaram o padrão IEEE Standard 1364-2001, conhecido 
como Verilog-2001. 
Verilog-2001 foi um importante avanço em relação ao Verilog-95 e tornou-se a versão dominante de Verilog 
com suporte da maioria dos pacotes de software comerciais para a automação de projetos eletrônicos EDA. 
A mais recente revisão é Verilog 2005 (IEEE Standard 1364-2005) que é uma atualização do padrão anterior, 
SystemVerilog é um superconjunto de Verilog-2005, com novas características e capacidades para auxiliar o 
projeto e a sua verificação. A partir de 2009, SystemVerilog e a linguagem Verilog fundiram-se no padrão 
SystemVerilog 2009 (IEEE Standard 1800-2009). 
Sintaxe de Verilog: 
Os criadores dessa linguagem preferiram uma sintaxe familiar à da linguagem de programação C. Estruturas 
de controle de fluxo ( "if", "while" ) são constantemente encontradas nos código Verilog. A diferença básica 
entre o Verilog e “C” está na estruturação do código. Enquanto C é baseada no paradigma procedural, Verilog 
é estruturada em blocos “begin / end”, se caracterizando em uma linguagem modular, como veremos. 
Paralelismo temporal: 
Verilog difere das linguagens de computador (como “C”) pela maneira como é executada. Verilog (assim 
como VHDL) não segue os padrões lineares que as linguagens de computação usam. Um circuito Verilog 
consiste na separação hierárquica de módulos que contém conexões e registradores. Em outras palavras, 
pense que Verilog descreve circuitos que funcionam em paralelo. Há também a possibilidade de descrever 
processos sequenciais em Verilog. Processos sequenciais e paralelos definem o comportamento dos módulos 
em Verilog. Processos sequenciais são executados dentro de blocos "begin / end". Todos os demais processos 
são executados de forma paralela (são circuitos). Por outro lado, mesmo os blocos sequenciais são 
executados simultaneamente (em paralelo) com os outros módulos. Ou seja, o interior de um bloco “begin / 
end” é sequencial mas dois blocos/módulos são paralelos. 
Quais as vantagens de se utilizar Verilog? 
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; Dificuldade em encontrar pessoal treinado para 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. Você não aprende uma 
Apostila: Dispositivos Lógicos Programáveis e Verilog - Prof. João Ranhel 
 
19 
lingua natural, como português, primeiro pela sintaxe; você aprende com a prática e o uso. Vamos usar o 
mesmo método aqui, vamos mostrar Verilog pela prática. Contudo, em conjunto, vamos analisar alguns 
aspectos da sintaxe básica de Verilog. 
Lembre-se de uma coisa primordial: quando você está trabalhando em um HDL você não está PROGRAMANDO 
computadores, no sentido de fazer um programa em “C” ou “Assembly”, você está DESCREVENDO um hardware. 
Há vários livros sobre Verilog, um que indico é Verilog by Example: a Concise Introduction for FPGA Design; 
Blaine C Readler, 2011 – Full Arc Press (www.readler.com) . 
Há vários tutoriais e apostilas na Internet. Sugiro o site: http://www.asic-world.com/verilog/index.html para 
consulta rápida e tutoriais. 
Para quando você estiver utilizando Verilog profissionalmente, consulte o manual do IDE que você estiver 
usando quanto ao estilo de codificação apropriado para o IDE. A Altera/Intel tem um manual do IDE (ex: 
Quartus II Handbook Volume 1: Design and Synthesis ) e nele há um capítulo intitulado Recommended HDL 
Coding Styles. Consulte o manual para ver se o estilo escolhido corresponde à melhor prática no IDE. 
 
• VERILOG HDL (uso prático, regras e sintaxe) 
• Comente (ou documente) seus projetos. É boa prática de programação/descrição comentar um projeto 
para descrever detalhes que no momento que você escreve estão claros para mas que podem ser esquecidos. 
Comente também para facilitar a outra pessoa ler o seu texto. Inserimos comentários no código Verilog da 
mesma forma com em linguagem “C”, ou seja, entre os marcadores /* comentários em várias linhas */ e, numa 
mesma linha usamos // comentário. Por exemplo: 
 
Fig 15. Exemplo de código em Verilog – cabeçalho e comentários 
Da linha 1 até a linha 24 na Fig. 15 há um comentário que começa com /* e termina na linha 24 com */. Tudo o que 
está em verde na figura é comentário, ou seja, o compilador Verilog ignora. É uma boa prática colocar um cabeçalho 
nos arquivos de projeto para você se lembrar posteriormente do que se trata aquele projeto. Insira detalhes sobre 
como configurar o circuito, quais os requisitos fundamentais para funcionar, etc. 
Na linha 33 do código tem (ao final da linha, depois do “;”) um marcador “//” e um comentário sobre o que é o 
parâmetro W_KTE. O compilador Verilog ignora tudo o que está escrito após o // até o próximo caracter carriage 
return (CR), que marca o final da linha (quando você dá um ENTER para saltar para linha seguinte). Note que as linhas 32 
http://www.asic-world.com/verilog/index.html
Apostila: Dispositivos Lógicos Programáveis e Verilog - Prof. João Ranhel 
 
20 
e 34 também estão verdes (são linhas de comentário) porque começam com //. A linha 35 também tem um 
comentário ao final, depois do //, para o leitor se lembrar o que é o parâmetro Add_1. 
• Verilog é case sensitive, isso significa que o nome de uma variável declarada em letras maiúsculas é 
diferente do nome idêntico com letras minúsculas. Em Verilog, a variável varX é diferente de outra definida 
como VarX, que é diferente de VARX e de varx; 
• A linguagem Verilog tem algumaspalavras reservadas. Todas as palavras-chave da linguagem devem estar 
em letras minúsculas no texto. Por exemplo, na linha 33 e 35 temos a palavra-chave parameter que aparece 
em azul. As palavras-chave são reservadas e não podem ser utilizadas para outra finalidade. 
• Espaços em branco são utilizados para melhor legibilidade do código, ou para separar variáveis, palavras-
chave, operadores e parâmetros. Você não pode usar espaço dentro do nome de uma variável, por exemplo. 
Assim, “Add 1” não é um nome de variável/parâmetro válido. Nesse caso, é recomendado o uso do underline 
("_"), como pode ser visto em W_KTE (linhas 33, Fig. 15) e Add_1 (linha 35, Fig. 15). 
• Como outras linguagens, uma atribuição, comando ou declaração em Verilog termina com “;” – como nas 
linhas 33 e 35 da Fig. 15. Nesse caso, o enunciado começa com a palavra-chave parameter e termina com o 
“;”. O ponto e vírgula é entendido pelo compilador como terminação da linha (em vez do CR ou Enter). Em 
outras palavras, o compilador Verilog entende todos os caracteres como pertencente a uma linha até 
encontrar um ponto e vírgula; 
• Verilog NÃO aceita caracteres com acento (só nos comentário, porque não faz parte do código/texto 
Verilog). Um identificador (variável, porto, nome de sinal/fio ou bus) tem que começar com uma letra. 
• As seguintes palavras são reservadas (veja lista com as funções no apêncide 1): 
Palavras reservadas - Verilog 
always assign automatic begin 
case casex casez cell 
config deassign default defparam 
design disable edge else 
end endcase endconfig endfunction 
endgenerate endmodule endprimitive endspecify 
endtable endtask event for 
force forever fork function 
generate genvar if ifnone 
incdir include initial inout 
input instance join liblist 
library localparam macromodule module 
negedge noshowcancelled output parameter 
posedge primitive pulsestyle_ondetect pulsestyle_onevent 
reg release repeat scalared 
showcancelled signed specify specparam 
strength table task tri 
tri0 and tri1 triand,wand trior, wor trireg unsigned 
use vectored wait while 
wire 
Nos códigos Verilog descrevemos um circuito como um módulo. Um módulo é descrito entre duas palavras-
chave: "module" e "endmodule". A palavra module é necessária e, depois de module temos o nome do 
módulo. As figuras Fig. 16 e Fig. 17 mostram um projeto simples em Verilog, descrito em um único módulo. 
O mesmo projeto foi descrito em dois estilos diferentes e as diferenças são explicadas adiante. 
OBS 1: Um módulo é sinônimo de um “arquivo”, então o nome do módulo é o mesmo do nome do arquivo. 
Ou seja, o nome do arquivo deve ser o nome do módulo seguido pelo “.v” que identifica um arquivo Verilog. 
OBS 2: Nas prática adotamos uma pasta para cada projeto; assim, o nome da pasta deve ser o mesmo nome 
do projeto. Como alguns projetos possuem apenas um módulo, vamos usar também o nome do módulo 
principal igual ao do projeto. Ou seja, acostume-se a criar uma pasta com o mesmo nome do módulo principal 
em Verilog, que será salvo dentro dessa pasta com a extensão “nome_do_módulo.v”. Para ficar claro: 
Apostila: Dispositivos Lógicos Programáveis e Verilog - Prof. João Ranhel 
 
21 
Um projeto cria um comparador de 4 bits. O nome do projeto pode ser Comparador_4_bits. Assim, criamos 
uma pasta .\Comparador_4_bits\ e dentro dela colocaremos o arquivo Verilog Comparador_4_bits.v; e 
ainda, o nome do módulo Verilog dentro desse arquivo será definido assim: 
module Comparador_4_bits (...); 
... (aqui entra a descrição do módulo) 
endmodule 
Note que as duas figuras (Fig.16 e Fig.17) contém códigos que começam com a palavra module e em seguida 
o nome do módulo: Simples_IN_OUT. Ambos os códigos terminam com endmodule. Entre essas duas 
palavras-chave escrevemos o comportamento do circuito que chamamos Simples_IN_OUT. 
 
Fig.16 – Um módulo simples escrito em Verilog no estilo do Verilog-95 
 
Fig.17 – O mesmo projeto de módulo simples escrito em Verilog no estilo do Verilog-2001 
Circuitos têm entradas e saídas de sinais, assim, depois do nome do módulo descreve-se quais são os sinais 
que entram e saem do módulo. Isso é feito em uma seção chamada port list, que está dentro de parêntesis 
( ); logo depois do nome do módulo. Num esquema geral fica: 
 
module nome_do_módulo ( port list ); 
 
... (aqui entra a descrição do módulo) 
 
endmodule 
module nome_do_módulo 
 ( 
 port list 
 ); 
... (aqui entra a descrição do módulo) 
endmodule 
Apostila: Dispositivos Lógicos Programáveis e Verilog - Prof. João Ranhel 
 
22 
Os dois textos mostram o esquema geral do “esqueleto” de um módulo. Note que após o nome é possível 
inserir CR e espaços para melhorar a leitura, como na coluna da direita. O compilador entende que a linha 
Verilog começou com module e terminou no final do port list com o “;”, como no exemplo da esquerda. 
Observe nas Figs. 16 e 17 que depois do ”(“ que abre o port list temos uma lista separada por vírgulas com 
os nomes dos sinais: in_A, in_B, in_C, out_1, out_2. Trata-se da lista dos fios/sinais que entram e saem 
do módulo. Como foi dito, em inglês denomina-se port list, que numa tradução mais adequada seria “portos”, 
ou o local onde se ancoram os fios/sinais de entrada e saída do módulo. Não é bom usar “portas” de entrada 
e saída para não confundir com portas lógicas. 
Na versão Verilog-95 é obrigado listar os portos (Fig. 16) e depois de fechar o port list com “);” deve-se definir 
a direção do sinal: entrada, saída, ou bidirecional. Ou seja, define-se a direção dos ports usando comandos, 
com palavras-chave: input , output e inout; como nas linhas 19, 20, 21, 23, 24 da Fig. 16. 
 Para facilitar a escrita, da versão 2001 em diante o Verilog incorporou o estilo de escrita (Fig. 17) com a 
definição das direções dos ports (input , output e inout) na própria declaração da lista. Note que a linha 9 
inicia com input e, por ser uma lista, basta separar as entradas (iguais) por vírgula. A linha 10 (Fig. 17) inicia 
com output, que quebra a lista input e informa ao compilador que, a partir dali, a lista indica saídas. Observe 
que depois de declarar out_2 não há mais vírgulas e sim o fechamento da lista com “);”. 
Até esse ponto o leitor sabe que criamos um módulo, demos nome a ele, e definimos quais são os portos 
pelos quais os sinais entram e saem do módulo. Ou seja, definimos uma caixa preta, demos o nome a ela, e 
dissemos o que entra e o que sai dessa caixa. 
Nas linhas 26 e 27 da Fig. 16, e nas linhas 13 e 14 da Fig. 17, o código define o comportamento do circuito – 
ou seja, o que o circuito deve fazer. Em outras palavras, nestas linhas dizemos para caixa preta o que ela deve 
aplicar aos sinais de entrada e em quais saídas ela deve gerar os resultados desejados. 
Verilog suporta a descrição de circuitos em níveis diferentes de abstração. Três deles são importantes: 
✓ Nível da porta (gate level) 
✓ Nível comportamental (behavioral level) 
✓ Nível de Transferência de Registo (register transfer level) 
No primeiro (gate level), as características do módulo (da caixa preta) são descritas por links lógicos e algumas 
propriedades temporais. Os sinais são discretos e só podem ter valores lógicos definidos (‘0’, ‘1’, ‘X’, ‘ ‘Z’). Os 
valores ‘0’ e ‘1’ são os estados lógicos 0 ou 1, o valor ‘X’ indica que o valor “não importa” (pode ser ‘0’ ou ‘1’, 
tanto faz); e ‘Z’ é o estado de alta impedância do circuito 3-state, que veremos mais tarde no curso. As 
operações utilizáveis são primitivas lógicas predefinidas (AND, OR, NOT, etc.). Usar modelagem no nível de 
portas pode não ser uma boa idéia para qualquer tipo de projeto, porque é o mais baixo nível. 
O segundo nível de descrição de circuitos (behavioral level), descreve um sistema por algoritmos 
concorrentes. Em outras palavras, o projetista descreve o comportamento do circuito, e não como as portas 
e circuitos lógicos se interligam. Cada algoritmo em si é sequencial,o que significa que são num conjunto de 
instruções executadas uma após a outra. Contudo, cada bloco comportamental funciona em paralelo tanto 
com os circuitos combinacionais (gate level) quanto com outros blocos comportamentais. 
No terceiro nível (Register-Transfer Level ou RTL) os projetos especificam as características de um circuito 
por operações de transferência de dados entre os registradores. Um sinal de clock explícito é usado. O design 
RTL contém limites de sincronização exatos: as operações estão planejadas para ocorrer em determinados 
momentos. Em outras palavras, a descrição em RTL define como os dados fluem dentro de um circuito e 
quais operações são realizada (e em que sequência) sobre eles. 
Os circuitos das figuras Fig.16 e Fig.17 estão codificados no nível gate level. Veremos os outros tipos em 
momento mais apropriado. O circuito/módulo descrito em Verilog nas figuras 16 e 17 é representado na Fig. 
18 na forma de diagrama esquemático com portas lógicas. 
Apostila: Dispositivos Lógicos Programáveis e Verilog - Prof. João Ranhel 
 
23 
 
Fig.18 – Esquema do circuito Simples_IN-OUT descrito nas figuras 16 e 17. 
A palavra assign em Verilog é reservada para definir lógica combinacional, ou seja, uma atribuição direta 
resultado da combinação de sinais. Na linha 26 Fig.16 (ou 13 Fig.17), descreve-se que o sinal out_1 (saída) 
recebe o resultado da conexão das (entradas) in_A, in_B, e in_C, por meio de uma porta lógica AND. O 
símbolo “&” define a operação lógica AND, que deve ser executada entre os operandos: in_A, in_B, in_C. 
Em álgebra booleana essa linha Verilog seria escrita: 𝐨𝐮𝐭_𝟏 = 𝐢𝐧_𝐀 • 𝐢𝐧_𝐁 • 𝐢𝐧_𝐂 . 
No caso da linha 27 Fig.16 (ou 14 Fig.17), descreve-se que o sinal out_2 recebe o resultado da conexão dos 
sinais in_A OR in_B OR (o sinal in_C invertido). O símbolo “|” no código quer dizer que a operação lógica 
OR deve ser executada entre os operandos: as entradas in_A, in_B. O símbolo “~” define um operador 
unário (aplicado apenas a um operando: a entrada in_C). Porém, o operador “|” entre (in_B|~in_C) 
determina que, depois de invertida, a entrada in_C também se liga à porta OR. Em álgebra booleana: 𝐨𝐮𝐭𝟐 =
 𝐢𝐧𝐀 + 𝐢𝐧𝐁 + 𝐢𝐧_𝐂̅̅ ̅̅ ̅̅ . Veja no Apêndice 2 a tabela dos operadores da linguagem Verilog. 
Muitas vezes os circuitos digitais representam valores digitais usando mais de um fio em paralelo, ou seja, 
vetores (chamados de barramentos, ou bus). Verilog permite facilmente que você defina um porto como 
vetor usando a seguinte notação: 
 
Fig.19 – declaração de vetores em Verilog. 
A palavra assign em Verilog No exemplo (a) o estilo usado é Verilog-95 e no exemplo (b) o estilo é Verilog-
2001, mas ambos definem que os sinais/ports D são de entrada e que possuem 8 bits. O compilador 
entenderá que há um fio chamado D7 e decresce o nome dos fios seguintes até D0. A linha define o vetor de 
entrada cujos fios/sinais individuais são denominados {D7, D6, D5, D4, D3, D2, D1, D0}. Na linha abaixo, nos 
exemplos (a) e (b), temos a declaração de um vetor de saída de 8 bits, cujo nome é D_OUT e os sinais 
individuais serão {D_OUT7, D_OUT6, D_OUT5, D_OUT4, D_OUT3, D_OUT2, D_OUT1, D_OUT0}. Em Verilog 
podemos executar comandos com o vetor inteiro ou com sinais (os fios) individuais, por exemplo: 
 
Fig.20 – exemplo de uso de vetores dentro do corpo módulo. 
A linha 1 na Fig. 20 descreve um comando de atribuição direta do vetor de entrada D para o vetor D_OUT. 
Isso significa que o fio D7 foi ligado diretamente ao fio D_OUT7, o fio D6 foi ligado diretamente ao fio 
D_OUT6, e assim sucessivamente até D0 ligado diretamente ao D_OUT0. 
Apostila: Dispositivos Lógicos Programáveis e Verilog - Prof. João Ranhel 
 
24 
A linha 2 Fig. 20 faz uma atribuição direta do valor binário ‘0’ ao sinal D_OUT0. O índice do sinal dentro de 
um vetor é definido dentro de um colchete. Por exemplo, na linha 3 da Fig. 20 temos um comando de 
atribuição direta do valor ‘1’ lógico ao bit (ao fio, ao sinal) D_OUT[6]. 
Valores estáticos (numeric literals) em Verilog são sempre representados usando um formato específico. A 
seguir alguns exemplos de como declarar valores estáticos: 
Var = 3’b101; // 3 bits, forma binária, explicitamente o número 5 = “101”b 
Var = 4’d13; // vals decimais não precisam formatar; mas, 4’d13 explicita o num 13 em 4 bits 
Var = 12’h3FA; // valor em 12 bits, hexadecimal e o conteúdo é 3FA = 1018 = 11 1111 1010b 
Vamos supor agora que você tenha um circuito descrito pela seguinte equação booleana e você precisa 
descrevê-lo em Verilog: 𝐨𝐮𝐭𝟏 = 𝐢𝐧𝐀| ( 𝐢𝐧𝐁 • 𝐢𝐧𝐂) | ( 𝐢𝐧_𝐀 • 𝐢𝐧_𝐂̅̅ ̅̅ ̅̅ ) . E esquema desse módulo é: 
 
Fig.21 – Esquema do circuito Simples_IN_OUT_2 descrito a figura 22. 
Note que temos duas ligações internas (fio1 e fio2) no circuito que não são portos (não são entradas nem 
saída do módulo). Esses dois sinais são ao mesmo tempo saída na porta AND e entrada na porta OR. Para 
fazermos as ligações desses sinais precisamos descrever para o compilador que esses fios (wires) serão 
usados antes de usá-los na descrição do circuito. A Figura 22 mostra a descrição desse circuito em Verilog. 
 
Fig.22 – Descrição do módulo com sinais intermediários, codificação do circuito da figura 21. 
As linhas 13 e 14 do código mostrado na Fig.22 declaram dois fios (wires) que serão usados depois nas linhas 
16 e 17. A palavra-chave para declarar sinais intermediários é wire – literalmente, fio. Em circuitos 
eletrônicos existem dois tipos de sinais – um que não tem memória ( wire ) e outro tipo que memoriza o 
sinal por um tempo indeterminado ( reg ), como veremos adiante. Sinais tipo reg também precisam ser 
declarados antes de serem usados. Sinais não memorizáveis (wire) trafegam no circuito por meio de fios e 
são saídas e entradas ao mesmo tempo. Sinais memorizáveis são armazenados em registradores e possuem 
um sentido de propagação do sinal. 
 
Apostila: Dispositivos Lógicos Programáveis e Verilog - Prof. João Ranhel 
 
25 
Agora que já sabemos como criar um módulo, como descrever seus portos de entrada e de saída, e como 
descrever como o circuito deve responder – fizemos isso no nível de portas lógicas – vamos mostrar como 
descrever o que o módulo faz por meio da descrição do comportamento dos sinais (behavioral level). Para 
isso, vamos introduzir novos conceitos de Verilog e usaremos a figura seguinte para isso. 
Note que na apostila (e nos códigos das práticas) escolhemos usar o estilo de definição de ports do Verilog-
2001 por ser menos “verborrágico” – o texto fica menor. O leitor deve se lembrar que outros códigos Verilog 
podem apresentar o texto na formatação antiga, ou mesmo o leitor pode optar por usá-lo. 
Os circuitos combinacionais, como o que foi feito até o momento, geram uma saída assim que as entradas 
se alteram (descontados atrasos internos). Já os circuitos com memória terém o estado do sinal até que um 
evento (geralmente chamado clock) force o circuito a mudar sua saída. Essa classe de circuitos é chamada 
lógica sequencial, e é importante em eletrônica digital porque permitem que os circuitos sejam descritos em 
função de seu comportamento no tempo. No curso de ED esse tipo de circuito é descrito na segunda parte 
do curso. O bloco que é sinônimo de lógica sequencial em Verilog é o bloco de construção iniciado com a 
palavra-chave always, por isso conhecido como always Block. O código a seguir mostra a construção de um 
circuito chamado registrador (latch) que memoriza um valor de 8 bits. 
O leitor não precisa se preocupar em entender como o latch faz isso, apenas procure entender a função do 
always block, porque o funcionamento de registradores será ensinado posteriormente, e vamos executar 
algumas práticas nesse sentido. 
 
Fig.23 – exemplo de uso do bloco always – construindo um registrador. 
Neste trecho de código temos várias novidades, vamos nos ater a elas. Onome do módulo é Registrador e 
os portos do módulo são 3 sinais de entrada de controle (clk, reset, ena); um conjunto de fios (um vetor) por 
onde entra um byte no módulo (vetor D de 8-bits: D7...D0), e finalmente um conjunto de fios por onde saem 
os sinais memorizados no módulo (vetor de saída Q de 8-bits Q7...Q0). Este vetor é diferente porque em sua 
declaração tem a palavra-chave reg, determinando que esse tipo de sinal é um sinal que exibe um circuito 
flip-flop, que memoriza o sinal digital. Não é necessário (se usar não causa erro) usar a palavra wire nos 
portos do tipo wire porque o compilador assume por default. Contudo, todos os portos memorizáveis 
precisam ser declarados com reg, da forma como está na linha 14 da Fig. 23. 
Apostila: Dispositivos Lógicos Programáveis e Verilog - Prof. João Ranhel 
 
26 
Até aqui não há muita novidade porque o leitor já viu a declaração de ports anteriormente, e não precisa se 
preocupar com o fato de não saber ainda o que é um flip-flop – ele será explicado a seu tempo. Vamos 
continuar a descrição do módulo porque o objetivo é entender sua forma de construção. 
A palavra-chave always (linha 17 Fig.23) define um bloco funcional que começa a ser descrito na linha 18, 
com a palavra-chabe begin, e este bloco termina na linha 29, com a palavra-chave end. Entre essas duas 
linhas o projetista descreve o comportamento do circuito. 
Note que há uma palavra begin na linha 21 e um end na linha 23, assim como há um begin na linha 26 e 
um end na linha 28. Begin marca o começo de um conjunto (ou bloco) de comandos ou atribuições e end 
determina o final desse bloco. Assim, o par da linha 21 a 23 marca um bloco e o par das linhas 26 a 28 marcam 
outro bloco. Eles estão “aninhados” (nested) dentro de um begin-end maior, do bloco always, que começa 
na linha 18 e termina na 29. Se o número de begin-end não corresponder, ou seja, se para cada begin não 
houver um end, o compilador indicará erro. 
Seguido à palavra always (linha 17 Fig.23) vemos “@(posedge clk)”, que se lê: at positive edge of clk. 
Todo bloco always tem uma lista de eventos que o disparam. No caso descrito na linha 17 Fig.23 o evento 
que dispara o bloco always é uma subida (posedge) do sinal clk. Se o projetista desejar a descida do sinal 
clk, deve usar a palavra-chave negedge em vez de posedge; escrito: “@(negedge clk)”. 
Em qualquer dos casos significa que o bloco always só será executado quando ocorrer o evento descrito 
neste complemento. Se mais de um evento deve disparar o bloco always, este evento deve estar listado 
dentro do parêntesis. Nesse caso, usa-se um operador lógico: “@(posedge clk or negedge reset)”. 
Neste exemplo, eventos em dois sinais disparam o bloco always: quando ocorrer uma subida do sinal clk ou 
quando ocorrer uma descida do sinal reset. 
Em outras palavras, no caso do exemplo da Fig. 23, o circuito lógico que está descrito a partir do begin da 
linha 18, até o end na linha 29, será “atualizado” toda vez que ocorrer uma subida do sinal clk. Então, o que 
vemos dentro desses limites é uma estrutura if - then - else, como a já conhecida da linguagem “C”. Mas, 
atente para o fato de você descrever um circuito eletrônico em Verilog, e não um software. Aprendemos em 
computação que um IF {condição} THEN {comando 1} ELSE {comando 2} é executado assim: a CPU testa a 
condição e se ela for verdadeira ela executa o conjunto/sequência {comando 1}, caso contrário, a CPU 
executa o conjunto/sequência {comando 2}. Porém, não temos uma CPU no circuito digital que estamos 
descrevendo, a descrição não é um programa de computador. 
O que ocorre é que o compilador de Verilog transforma a estrutura if - then - else em um circuito físico 
(sintetizável). Como isso é feito será detalhado durante o curso de Eletrônica Digital. Não se preocupe se 
você ainda não sabe como funciona o MUX, você aprenderá durante o curso; apenas entenda o exemplo 
para se ter uma ideia do que ocorre e como o compilador pode criar o circuito if - then - else: 
 
Fig.24 – exemplo de uma possível forma de síntese da estrutura IF em um MUX 
No MUX, a variável a controla a seleção entre I0 ou I1. O sinal que entra em I0 saírá em Y quando a=0, e o 
sinal de I1 saírá em Y quando a=1. Este MUX pode ser usado para sintetizar a linha de código: 
if (a==1) assign Y = I1; else assign Y = I0; 
Apostila: Dispositivos Lógicos Programáveis e Verilog - Prof. João Ranhel 
 
27 
O que o compilador faz é conectar o sinal que chamamos “a” no fio de seleção do MUX, e os fios que 
chamamos I0 e I1 nas entradas do MUX. A saída do circuito será o sinal Y. O que fizemos ao escrever a linha 
de código no Verilog foi transformar uma semântica humana (uma estrutura lógica se isso faça isso, senão, 
faça aquilo) em um formato que o Verilog transforma num circuito eletrônico. O compilador faz esse papel, 
desde que a estrutura if - then - else seja escrita corretamente. Note que foi escrito uma linha de 
comando e os marcadores de bloco begin e end não foram escritos. Quando se tem apenas um comando 
ou atribuição entre o if e o else não é necessário usar os marcadores begin e end . 
Voltando ao circuito descrito na Fig.23, vimos que a cada subida de clk o if será executado; então, se o reset 
estiver em zero, a condição (!reset) é verdade (=1) e o circuito executa a porção IF (linhas 21 a 23) . Por outro 
lado, se reset estiver em nível lógico ‘1’ a inversão de reset (!reset) transforma a condição em falsa. Isso quer 
dizer que a porção else será executada (linas 26 a 28). 
A porção if se reduz à linha 22 ( Q <= 8’b0; ) que traduzindo quer dizer: cada bit do registrador Q memoriza 
nível lógico ‘0’, ou seja o registrador inteiro será zerado. Portanto, 𝒓𝒆𝒔𝒆𝒕̅̅ ̅̅ ̅̅ ̅̅ faz com que o registrador seja 
zerado. O operador <= será explicado em práticas futuras, mas para adiantar, ele é usado nas atribuições 
que criam memorização nos registradores. 
Na sequência, se reset=1 então a porção else será executada: e ela testa se o sinal ena é verdadeiro (ou 
seja, se ena=1). Se a condição for falsa (se ena=0), o circuito executará nada – tudo entre o if e o else 
(linha 20 à 28 /fig. 23) será ignorado por não gerar nenhuma condição verdadeira (reset=1 e ena=0). 
Contudo, se a condição for verdadeira (ena=1) então a porção else se reduz à linha 27 ( Q <= D; ) que 
traduzindo quer dizer: cada bit do vetor D será copiado no respectivo bit do vetor/registrador Q; ou seja, o 
registrador Q memorizará o conteúdo do vetor de entrada D. Note que Verilog sabe que deve copiar D0 em 
Q0, D1 em Q1 e assim por diante até D7 em Q7. Esperto isso não?! 
Resumindo o que o bloco always faz: a cada subida do clk ele testa se reset=0. Se for, o registrador Q será 
zerado. Se reset não for zero, o circuito testa o sinal ena, se ena=1 o circuito copia o dado D (D0...D7) da 
entrada do módulo para o registrador Q (A0...Q7) que é também uma saída do módulo. Porém, se ena=0 e 
reset=1 o bloco always faz nada. Isso se repete toda vez que o clk subir! 
O que temos de direfente no módulo Registrador em relação ao módulo Simples_IN_OUT é que o módulo 
Registrador foi descrito por meio do comportamento que desejamos do circuito, em vez de descrever como 
as portas lógicas são conectadas, que foi como feito no Simples_IN_OUT. 
Isto é o básico que alguém precisa saber para começar a lidar com Verilog. Todos esses passos serão repetidos 
durante o curso, nas aulas prática. Não vamos nos atentar demasiado para nuances da linguagem e da 
sintaxe. Vamos apenas descrever circuitos que serão sintetizados para o kit FPGA para guardarmos os 
conceitos teóricos ensinados em sala de aula. 
A seguir descrevemos o básico das placas e kits com os quais vamos fazer as práticas para nos familiarizarmos 
com os recursos (chaves, botões, LEDs, Displays, etc.) que a placa ou o kit contém, em que pinos do FPGA 
esses fios/sinais estão fisicamente conectados, e qual os CIs