UNIVERSIDADE_FEDERAL_DA_PARAIBA_CENTRO_D

Prévia do material em texto

UNIVERSIDADE FEDERAL DA PARAÍBA 
CENTRO DE CIÊNCIAS E TECNOLOGIA 
DEPARTAMENTO DE ENGENHARIA ELÉTRICA 
DISCIPLINA: ARQUITETURA DE SISTEMAS DIGITAIS 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Projeto de Sistemas Digitais na Atualidade 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Alexandre Scaico 
 
 
 
 
 
 
 
 
Campina Grande 
 
Dezembro/2000
Projeto de Sistemas Digitais na Atualidade pág. 2 
 A 
Alexandre Scaico Dezembro/2000 
SUMÁRIO 
 
 
1. INTRODUÇÃO...........................................................................................................................5 
2. A LÓGICA PROGRAMÁVEL...................................................................................................7 
2.1 - O que é a Lógica Programável? ...........................................................................................7 
2.2 - Memórias PROM.................................................................................................................7 
2.3 - Os Dispositivos Lógicos Programáveis (PLD) ....................................................................9 
2.4 - Arranjos Lógicos Programáveis.........................................................................................10 
2.4.1 - PLA..............................................................................................................................10 
2.4.2 - PAL..............................................................................................................................11 
2.5 - Arranjos de Portas Programáveis (Programmable Gate Array).........................................11 
2.5.1 - CPLD (Complex PLD) ................................................................................................12 
2.5.2 - FPGA (Field Programmable Gate Array)....................................................................13 
2.6 - Considerações finais ..........................................................................................................14 
2.7 - Bibliografia ........................................................................................................................15 
3. AS LINGUAGENS DE DESCRIÇÃO DE HARDWARE.......................................................16 
3.1 - Evolução dos sistemas digitais...........................................................................................16 
3.2 - Surgimento das HDL’s ......................................................................................................16 
3.3 - Fluxo Típico em um Projeto ..............................................................................................17 
3.4 - Importância das HDL’s......................................................................................................18 
3.5 - Tendências em HDL’s .......................................................................................................19 
3.6 - Bibliografia ........................................................................................................................19 
4. VERILOG HDL ........................................................................................................................20 
4.1 - O que é Verilog? ................................................................................................................20 
4.2 - Por que usar o Verilog HDL? ............................................................................................20 
4.3 - Popularidade do Verilog HDL...........................................................................................21 
4.4 - Aplicações do Verilog e outras linguagens HDL ..............................................................21 
4.5 - Limitações do Verilog........................................................................................................21 
4.6 - Níveis de abstração ............................................................................................................22 
4.7 - Nível comportamental x RTL ............................................................................................22 
4.8 - Conceitos principais da linguagem ....................................................................................23 
4.9 - Metodologias de projeto ....................................................................................................24 
4.10 - Estrutura dos módulos......................................................................................................24 
4.11 - Projeto hierárquico...........................................................................................................26 
4.12 - Instâncias..........................................................................................................................26 
4.13 - Representando hierarquia.................................................................................................27 
Projeto de Sistemas Digitais na Atualidade pág. 3 
 A 
Alexandre Scaico Dezembro/2000 
4.14 - Componentes de uma simulação......................................................................................28 
4.15 - Nomes hierárquicos .........................................................................................................29 
4.16 - Exemplos de módulos ......................................................................................................30 
4.16.1 - Meio somador ............................................................................................................30 
4.16.2 - Somador completo.....................................................................................................30 
4.17 - Conceitos básicos.............................................................................................................31 
4.18 - Convenções léxicas..........................................................................................................32 
4.18.1 - Espaços em branco ....................................................................................................32 
4.18.2 - Comentários...............................................................................................................32 
4.18.3 - Operadores.................................................................................................................32 
4.18.4 - Especificações de números........................................................................................32 
4.18.5 - Strings........................................................................................................................33 
4.18.6 – Identificadores e palavras-chave...............................................................................33 
4.19 - Tipos de dados .................................................................................................................33 
4.19.1 - Definição de valores ..................................................................................................33 
4.19.2 - Nets............................................................................................................................34 
4.19.3 - Registradores .............................................................................................................34 
4.19.4 - Vetores.......................................................................................................................34 
4.19.5 - Registros de tipos de dados integer, real e time ........................................................344.19.6 - Arrays ........................................................................................................................35 
4.19.7 - Memórias ...................................................................................................................35 
4.19.8 - Parâmetros .................................................................................................................35 
4.19.9 - Strings........................................................................................................................35 
4.20 - Módulos ...........................................................................................................................35 
4.21 - Portas................................................................................................................................37 
4.21.1 - Lista de portas............................................................................................................37 
4.21.2 - Declarações de portas ................................................................................................37 
4.21.3 - Regras de conexões de portas ....................................................................................38 
4.21.4 - Conectando portas a sinais externos..........................................................................39 
4.22 - Exemplos de estruturas de módulos.................................................................................40 
4.22.1 - Nível de portas lógicas ..............................................................................................40 
4.22.2 - Nível de fluxo de dados (RTL)..................................................................................41 
4.22.3 - Nível comportamental ...............................................................................................41 
4.23 - Bibliografia ......................................................................................................................42 
5. O VERILOG E A FERRAMENTA DE SÍNTESE LÓGICA DA ALTERA ...........................43 
5. 1 - Considerações iniciais.......................................................................................................43 
Projeto de Sistemas Digitais na Atualidade pág. 4 
 A 
Alexandre Scaico Dezembro/2000 
5.2 - Tipos de operadores ...........................................................................................................43 
5.2.1 - Operadores aritméticos ................................................................................................44 
5.2.2 - Operadores lógicos ......................................................................................................44 
5.2.3 - Operadores relacionais ................................................................................................45 
5.2.4 - Operadores de igualdade .............................................................................................45 
5.2.5 - Operadores Bitwise......................................................................................................45 
5.2.6 - Operadores de Redução ...............................................................................................45 
5.2.7 - Operadores de deslocamento .......................................................................................46 
5.2.8 - Operador de concatenação...........................................................................................46 
5.2.9 - Operador de replicação................................................................................................46 
5.2.10 - Operador Condicional................................................................................................46 
5.3 - Definição de constantes .....................................................................................................47 
5.4 - Estruturas if-else e case......................................................................................................47 
5.4.1 - Estrutura if-else............................................................................................................47 
5.4.2 - Estrutura case...............................................................................................................48 
5.4.3 - Outras estruturas ..........................................................................................................48 
5.5 - Controle de Eventos...........................................................................................................48 
5.6 - Lógica Combinacional .......................................................................................................49 
5.6.1 - Atribuições contínuas ..................................................................................................49 
5.6.2 - Construções always .....................................................................................................49 
5.7 - Lógica seqüencial...............................................................................................................50 
5.7.1 – Implementando registradores......................................................................................50 
5.7.2 - Implementando contadores..........................................................................................51 
5.8 - Bibliografia ........................................................................................................................52 
6. A PLACA FPGA E A FERRAMENTA MAX+PLUS II .........................................................53 
6. 1 - Considerações iniciais.......................................................................................................53 
6.2 – A placa de desenvolvimento .............................................................................................53 
6.3 – A ferramenta de síntese lógica Max+Plus II .....................................................................55 
6.3.1 – Utilizando o Max+Plus II............................................................................................57 
6.4 – Realização dos testes na placa...........................................................................................61 
6.5 – Bibliografia........................................................................................................................61 
 
Projeto de Sistemas Digitais na Atualidade pág. 5 
 A 
Alexandre Scaico Dezembro/2000 
1. INTRODUÇÃO 
 
 
 
Para muito de nós, a realização de um projeto de um sistema digital consiste em 
determinarmos a função lógica que o sistema que queremos projetar deve apresentar como 
resposta aos estímulos recebidos, e então construirmos um circuito lógico complexo que execute 
essa função a partir de circuitos lógicos simples (portas OR, AND, XOR, Flip-flops, contadores, 
registradores, etc.). 
 
Mas, devido a complexidade dos sistemas atuais, esse tipo de projeto está se tornando 
inviável devido a vários problemas que o projeto a nível de portas lógicas acarreta, tais como: 
 
- Alto número de CI’s contendo os circuitos lógicos (portas lógicas) simples necessários; 
- Atraso global do sistema alto devido a contribuição individual dos atrasos de cada porta 
lógica individualmente; 
- Alto custo do projeto; 
- Necessidade de um grande layout físico para acomodar todos os componentes; 
- Alto consumo do sistema; 
- Possíveis erros de conexão e/ou maucontatos (confiabilidade do sistema); 
- Possíveis indisponibilidades dos circuitos necessários no mercado, acarretando em atraso na 
finalização dos projetos; 
- Necessidade de protótipos para testes, que acarreta em mais gastos. 
 
Junte a isso a evolução tecnológica que vem ocorrendo nos últimos 35 anos. Com a 
evolução, ocorreu um aumento na capacidade de processamento dos sistemas, e isso acarretou 
uma maior complexidade dos sistemas a serem projetados (e com isso um maior número de 
portas lógicas necessárias ao projeto). E também gerou uma maior escala de integração dos CI’s, 
que é a VLSI (Integração em Altíssima Escala). 
 
Então, com a inviabilidade de se efetuar os projetos digitais da maneira convencional 
(com portas lógicas), pesquisas foram implementadas a fim de se obter uma forma alternativa 
mais viável de se efetuar os projetos em dispositivos que contivessem milhares de portas lógicas 
internamente, e que essas portas pudessem ser programadas de acordo com a necessidade do 
projeto a fim de implementar a função desejada (ao invés de ter que interligar uma quantidade 
considerável de CI’s contendo portas lógicas, se usaria esse novo dispositivo). Esses estudos 
geraram a chamada lógica programável. 
 
 Com a lógica programável surgiram vários novos dispositivos passíveis de serem 
programados pelo projetista (seja enviando o projeto para a produtora dos dispositivos efetuar a 
programação ou programando-o o próprio projetista). E, com esses dispositivos surgiu a 
necessidade de uma nova forma de se projetar, pois as formas tradicionais de projetos baseados 
em tabelas da verdade, em softwares de projeto lógico a partir de portas lógicas (o Eletronic 
Workbech é um exemplo), entre outros, já não eram mais viável. 
 
 Dentre as novas técnicas que surgiram, a que despontou como a mais promissora é a 
“descrição de hardware”. Nesta modalidade de projeto, o projetista, com o auxílio do 
computador, descreve o hardware a ser projetado (o seu sistema digital) utilizando uma HDL 
(Hardware Description Language – Linguagem de Descrição de Hardware). Uma HDL é muito 
parecida com uma linguagem de programação de alto nível, como C ou Pascal. O projeto 
utilizando HDL se torna parecido com a programação, uma vez que o projetista inicialmente não 
Projeto de Sistemas Digitais na Atualidade pág. 6 
 A 
Alexandre Scaico Dezembro/2000 
se preocupa com a tecnologia que vai ser utilizada na implementação do projeto, e sim com a 
funcionalidade lógica do projeto. 
 
 Após a descrição ser feita, existem várias ferramentas de simulação para testar a 
funcionalidade do projeto antes de sua implementação. E isto é importante porque reduz 
drasticamente o tempo de testes, uma vez que não é necessária a construção de protótipos e que, 
na ocorrência de um erro ou mudança no projeto, é muito simples se modificar a descrição do 
sistema em HDL. 
 
 Ao término da etapa de teste é então escolhido o dispositivo que mais se adapte ao 
projeto (número de portas, tempo de resposta, etc.) e então utilizamos um software de síntese 
lógica, disponibilizado pelo fabricante do dispositivo, para convertermos a nossa descrição em 
HDL para um arquivo que contenha os dados necessários para a programação do dispositivo. E. 
uma vez realizada a programação, o dispositivo está pronto para ser utilizado. 
 
 Deve-se ressaltar que existem dispositivos programáveis que só podem ser programados 
uma única vez (que são os que o projetista envia a descrição para o fabricante programar), e os 
que podem ser reprogramados de acordo com a necessidade (que são os programáveis pelo 
projetista). 
Projeto de Sistemas Digitais na Atualidade pág. 7 
 A 
Alexandre Scaico Dezembro/2000 
2. A LÓGICA PROGRAMÁVEL 
 
 
 
2.1 - O que é a Lógica Programável? 
 
 Os componentes da lógica programável são dispositivos que possuem em sua lógica 
interna centenas (ou milhares) de portas lógicas, flip-flops e registradores; que são interligados 
internamente. Essas interconexões são os pontos programáveis da lógica. Podemos então 
programar essas conexões para permanecerem fechadas ou abertas, de acordo com a necessidade 
do projeto. 
 
Essas interconexões podem ser entendidas como fusíveis, que de acordo com a 
necessidade do projeto podem ou não ser queimados (desfazendo ou não a conexão entre portas 
lógicas). Essa “queima” é realizada pelo projetista, utilizando um software de programação do 
dispositivo. 
 
Existem vários tipos de dispositivos lógicos programável (PLD – Programmable Logic 
Devices), como os mostrados abaixo: 
 
- PLA 
- PAL 
- Dispositivos Lógicos Programáveis Complexos (CPLD) 
- Arranjo de Portas Programáveis em Campo (FPGA) 
 
Podemos também considerar as memórias PROM como dispositivos de lógica programáveis 
se elas forem utilizadas para implementar funções lógicas. 
 
 
2.2 - Memórias PROM 
 
 O conceito de programação de hardware (sistemas digitais) se materializou com a 
necessidade de se construir unidades de memória, cujo conteúdo fixo, não era perdido ao se 
desligar o sistema. Esta necessidade foi resolvida com a criação das memórias ROM, que 
vinham de fábrica com o seu conteúdo já determinado. Com a evolução surgiram as memórias 
PROM (ROM programável), cuja programação ocorria pela “queima” dos fusíveis internos 
(interconexões entre as portas lógicas básicas que compõem a PROM). 
 
 Temos na figura a seguir o modelo de um PROM. Ela internamente nada mais é que uma 
estrutura AND-OR, com a matriz AND fixa e a matriz OR programável. Então, podemos ver a 
matriz AND da PROM como um decodificador completo de endereços que pode ser programado 
a partir da matriz OR. Ao ser produzida, a PROM vem com todas as conexões internas. Para 
programá-la devemos aplicar níveis de tensão apropriados a fim de manter ou não a conexão de 
cada entrada de cada porta OR (“queimar” ou não os fusíveis internos). Só que uma vez feita a 
programação, ela não pode ser desfeita. Com a evolução, sugiram novos tipos de ROMs que 
solucionaram essa limitação das PROMs, que são as EPROMs apagáveis por radiação 
ultravioleta, e as PROMs apagáveis eletricamente (EEPROM). 
 
 
Projeto de Sistemas Digitais na Atualidade pág. 8 
 A 
Alexandre Scaico Dezembro/2000 
 
Fig.01 – Memória PROM de 8 x 2 bits 
 
 Então, podemos ver a PROM não apenas como uma memória apenas de leitura, mas 
também como um circuito combinatório genérico de n entradas e m saídas, cuja função lógica 
executada pode ser facilmente programável, como mostra a figura abaixo. 
 
 
 
Fig. 02 – PROM vista como um circuito combinatório 
 
 Mas o uso de PROMs como dispositivos programáveis apresentam algumas 
desvantagens, como por exemplo: 
 
- A memória não aproveita as vantagens das técnicas de minimização porque implementam 
diretamente a tabela da verdade; 
Projeto de Sistemas Digitais na Atualidade pág. 9 
 A 
Alexandre Scaico Dezembro/2000 
- Quando um sistema possui menos saída que o comprimentoda palavra da memória, temos 
porções de memória que não são utilizadas totalmente. 
 
Por isso, os pesquisadores se empenharam em produzir dispositivos melhores que as 
memórias para implementar projetos lógicos, esses componentes são chamados de Dispositivos 
Lógicos Programáveis (PLD – Programmable Logic Devices). 
 
 
2.3 - Os Dispositivos Lógicos Programáveis (PLD) 
 
 Dispositivos Lógicos Programáveis são dispositivos (circuitos integrados) configuráveis 
pelo usuário usados para implementar uma grande variedade de funções lógicas, tanto 
seqüenciais como combinacionais. PLDs podem implementar qualquer expressão booleana ou 
função construída a partir de estruturas lógicas. Sua programação é efetuada pelo usuário 
utilizando uma ferramenta computacional de síntese lógica fornecida pelo fabricante do 
dispositivo. 
 
 Podemos ter PLDs com pontos internos de programação permanentes ou reprogramáveis. 
Os pontos de programação são os “fusíveis” (conexões) que interconectam os elementos internos 
do PLD. É através da queima ou não desses “fusíveis” que programamos o dispositivo. 
 
 Devido a complexidade da estrutura interna dos PLDs, podemos dividi-los em duas 
categorias, como mostra a figura abaixo. E, em cada categoria temos os dispositivos mais 
representativos. 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Fig. 03 – Divisão dos PLDs 
 
 É importante destacar que esses componentes têm o objetivo central de oferecer a 
versatilidade, o baixo custo, a confiabilidade e a velocidade da microeletrônica em estruturas 
menos rígidas que as tradicionais. E, para que esses dispositivos sejam utilizáveis de maneira 
simples, os fabricantes oferecem programas de computador que, a partir de descrições 
simplificadas do circuito que se deseja projetar (em HDL), consegue-se gerar rapidamente a 
programação correta do dispositivo. Ressaltando-se que esses softwares, além de gerar o 
conteúdo a ser gravado (programado) no componente, oferecem recursos de simulação 
(verificação), documenta completamente o projeto e, ainda, gera roteiros de testes. 
 
 
 
 
PLD 
Arranjos 
Lógicos 
Programáveis 
Arranjos 
de Portas 
Programáveis 
PAL PLA FPGA CPLD 
Projeto de Sistemas Digitais na Atualidade pág. 10 
 A 
Alexandre Scaico Dezembro/2000 
2.4 - Arranjos Lógicos Programáveis 
 
 Os dispositivos que são arranjos lógicos programáveis possuem uma estrutura interna 
semelhante baseadas na estrutura interna AND-OR das PROMs. A estrutura consiste de um 
número de entradas ligadas a número de portas AND. As saídas das portas AND são conectadas 
as entradas de um número de portas OR, cujas saídas são as saídas do dispositivo. Nestes 
dispositivos podemos ter tanto as duas matrizes de portas programáveis, quanto apenas a matriz 
de portas AND programáveis. E isso gerou dois tipos de dispositivos: as PLAs e as PALs. Estes 
dispositivos, assim como as PROMs, só podem se programados um única vez. 
 
2.4.1 - PLA 
 
 A estrutura de uma PLA é muito semelhante a de uma PROM. Só que ela possui uma 
menor quantidade de portas AND (não formando um decodificador completo), e possuindo tanto 
a matriz de portas AND quanto a matriz de portas OR programáveis. Temos a seguir a estrutura 
típica de uma PLA. 
 
 
Fig. 04 – Estrutura típica de uma PLA 
 
 Possuindo as duas matrizes de portas programáveis, as PLAs possibilitam que o projetista 
implemente termos minimizados (que não utilizam todas as entradas), como mostra o diagrama 
simplificado abaixo (note que cada linha de entrada das portas AND representam todas as 
entradas disponíveis na portas, estando apenas em notação simplificada). 
 
 
Fig 05 – Implementação de uma função lógica usando PLA 
Projeto de Sistemas Digitais na Atualidade pág. 11 
 A 
Alexandre Scaico Dezembro/2000 
2.4.2 - PAL 
 
 Com o uso da PLA’s foram verificadas que existiam situações em que a flexibilidade da 
matriz OR programável era desnecessária, o que não justificava o uso da PLAs. Além disso, a 
existência das duas matrizes (AND e OR) programáveis acarretava uma grande propagação de 
atraso entre a entrada e a saída do dispositivo (além de uma maior custo do dispositivo). 
 
 Por causa disso foi-se criado um dispositivo baseado no PLA só que mais simples, que é 
o PAL. O PAL se assemelha ao PLA, tendo apenas a matriz de portas AND programável (a de 
portas OR é fixa). Temos a seguir a estrutura interna simplificada de uma PAL. 
 
 
Fig. 06 – Estrutura típica de uma PAL 
 
 Essa estrutura básica da PAL pode ser varia da em quatro alternativas básicas: 
 
- Combinatório; 
- Entrada/Saída Programada; 
- Saídas com registradores e realimentação; 
- Saídas com porta XOR. 
 
O PAL mais simples, o combinatório, tem as saídas iguais as somas de produtos, sem 
realimentação (o PAL da figura anterior). Os PALs mais complexos realimentam a saída de volta 
para a entrada, permitindo que a saída seja também uma entrada. Outra característica de PALs 
mais complexos e a existência de registradores na saída, que fornecem aos PALs a possibilidade 
de sintetizar circuitos seqüenciais síncronos. Um tipo de PAL bem complexo é o que dispõe de 
circuitos de saída que incorporam a porta XOR. Tais dispositivos são normalmente chamados de 
aritméticos porque são sempre necessários quando se quer sintetizar unidades aritméticas. 
 
 
2.5 - Arranjos de Portas Programáveis (Programmable Gate Array) 
 
 Os arranjos de portas programáveis são estruturas mais genéricas e versáteis que as 
baseadas na estrutura típica de um PROM (PAL, PAL ou a própria PROM). Nestas estruturas 
existem recursos de configuração e interligação mais genéricos que aqueles apresentados pelo 
rígido esquema baseado na estrutura AND-OR. Os fabricantes destes tipos de dispositivos 
garantem que com seu uso se consegue um fator de utilização de 80 a 90%, enquanto que com 
PALs, tipicamente, utiliza-se apenas cerca de 15% de seus componentes. 
 
Projeto de Sistemas Digitais na Atualidade pág. 12 
 A 
Alexandre Scaico Dezembro/2000 
 Inicialmente, assim como as PROMs, estes componentes só eram passíveis de uma única 
programação. Mas, com o desenvolvimento das técnicas de fabricação, surgiram as versões 
programáveis em campo (que podiam ser reprogramadas de acordo com as necessidades do 
projetista), dentre as quais podemos destacar os FPGAs e os CPLDs. 
 
 Devemos salientar que com o surgimento das versões programáveis em campo, as 
versões programadas na fábrica não deixaram de existir. Pois componentes programáveis em 
fábrica são sempre mais confiáveis, dispensam as etapas de programação e, dependendo do 
volume, são mais baratos. Devido a esses fatores é que os fabricantes oferecem versões 
programáveis em fábrica para os dispositivos programáveis em campo que dispõem. A idéia é 
que sempre que se necessitar de componentes para elevadas quantidades, utiliza-se o 
componente programável em campo para a construção dos protótipos, e uma vez terminado o 
projeto e assegurado que se disponha da programação correta do dispositivo, o fabricante poderá 
fornece-lo em versões programáveis de fábrica. 
 
2.5.1 - CPLD (Complex PLD) 
 
 De uma maneira genérica os CPLDs (ou EPLDs – Erasable Programmable Logic Device) 
podem ser vistos como dispositivos queagregam em sua estrutura vários PLDs (PLA ou PAL) 
interligados por conexões programáveis, como ilustra a figura a seguir. 
 
 
Fig. 07 – Visão genérica de um CPLD 
 
 Na realidade, sua estrutura interna é formada por centenas de macrocélulas programáveis, 
interligadas por conexões também programáveis (cada PLD da figura anterior seria, na verdade, 
uma macrocélula). Cada macrocélula é composta por uma matriz AND-OR (com a matriz AND 
programável e a OR fixa, como nos PALs) para implementar as funções lógicas combinacionais, 
cujas saídas ativam módulos de entrada/saída (compostos por flip-flops e realimentações com 
funções e interligações programáveis). Os pinos de E/S podem ser configurados como apenas 
saída, apenas entrada, ou entrada/saída. 
 
 Os CPLDs são programáveis em campo, e podem ser reprogramados quantas vezes seja 
necessário. 
 
 
 
 
 
PLD 
 
PLD 
 
PLD 
 
PLD 
Entradas Saídas 
Conexões Programáveis 
Projeto de Sistemas Digitais na Atualidade pág. 13 
 A 
Alexandre Scaico Dezembro/2000 
 2.5.2 - FPGA (Field Programmable Gate Array) 
 
 Os FPGAs (Field Programmable Gate Arrays – Arranjo de Portas Programáveis em 
Campo), em comparação com os PLDs, possuem uma arquitetura mais flexível baseada no 
conceito de blocos lógicos. Um bloco lógico (BL) consiste de um certo número de portas lógicas 
capazes de implementar uma grande variedade de funções lógicas dependendo de sua 
programação, e pode ou não conter registradores. Temos em detalhe, na figura abaixo, a 
estrutura interna de um BL típico do fabricante Xilinx, que consiste em dois registradores, um 
número de multiplexadores e uma unidade de função combinatória (para implementar as funções 
lógicas). 
 
 
Fig 08 – Estrutura de um Bloco Lógico da Xilinx 
 
 Tipicamente, os blocos lógicos de um FPGA são idênticos, e cada bloco pode ser 
programado individualmente para realizar um pedaço da lógica do projeto (decompondo a 
função lógica geral do projeto em funções menores que serão implementadas pelos blocos 
lógicos). A complexidade de um bloco lógico pode variar (não se limita a estrutura típica 
mostrada acima) consideravelmente entre diferentes FPGAs, indo desde um bloco de 
“granularidade fina” implementando uma ou duas funções lógicas de duas ou quatro variáveis, 
até blocos de “granularidade grossa” implementando diversas funções lógicas de quatro a dez 
variáveis. 
 
 Cada FPGA contém um grande número de blocos lógicos, tipicamente entre 50 e 250, e 
algumas vezes mais. Cada bloco lógico é conectado aos outros blocos lógicos e aos pinos de E/S 
por interconexões programáveis. Temos a seguir alguns exemplos de arquiteturas de FPGAs no 
que diz respeito ao blocos lógicos e as interconexões programáveis. 
 
 
 
Fig 09 – Exemplos de arquitetura de FPGAs com respeitos as interconexões entre blocos lógicos 
 
Projeto de Sistemas Digitais na Atualidade pág. 14 
 A 
Alexandre Scaico Dezembro/2000 
 Podemos entender as interconexões programáveis como um conjunto de fios e um 
conjunto de chaves programáveis entre esses fios. As chaves são programadas para conectar ou 
desconectar segmentos de fio, de forma a prover os caminhos de comunicação desejados. A 
figura a seguir mostra um exemplo. 
 
 
 
Fig. 10 – Exemplo de conexão entre Blocos Lógicos 
 
 
2.6 - Considerações finais 
 
 Como já foi dito, para efetuarmos um projeto utilizando os dispositivos explicados, 
necessitamos de uma nova técnica de projeto e de um software que permita realizar a 
programação (software de síntese lógica). 
 
 Para o caso da programação, cada dispositivo possui o seu próprio software (de síntese 
lógica) que é fornecido pelo fabricante. Resta, então, aprender uma nova técnica de projeto. E, 
como também já foi mencionado, a técnica mais promissora nos dias atuais é a “descrição de 
hardware”. Pois, além das linguagens de descrição de hardware estarem amplamente difundidas 
e serem de fácil aprendizado (já que se parecem com uma linguagem de programação de alto 
nível), os softwares de síntese lógica (que programam os dispositivos) aceitam o projeto em 
linguagem de descrição de hardware para fazerem a programação dos dispositivos. E, dentre as 
linguagens de descrição de hardware, a mais promissora nos dias atuais é o Verilog HDL. 
 
 Devemos salientar também que, para o usuário final, FPGA e CPLD podem ser vistas 
como o mesmo tipo de estrutura. A única diferença está na sua estrutura interna, mas o seu 
resultado final é o mesmo. O fato é que um dos grandes fabricantes, a Xilinx usa o nome FPGA, 
enquanto outro grande fabricante, a Altera, usa o nome CPLD. Tanto faz usar uma ou a outra 
(embora os fabricantes tentem mostrar que a sua estrutura interna é sempre melhor), que se 
obtém o mesmo resultado. Na prática, tanto os FPGAs quanto os CPLDs são conhecidos como 
FPGAs. 
 
 Existe atualmente uma nova tecnologia que permite usarmos um conceito chamado 
“cache lógica” com FPGAs. A cache lógica é um meio mais barato de se implementar lógica 
mais eficientemente. As funções ativas da aplicação que está sendo executada pelo FPGA podem 
ser reconfiguradas durante a execução, enquanto funções inativas são armazenadas em uma 
memória mais barata (um EPROM, por exemplo). Quando uma nova função é necessária, ela é 
buscada na memória e escrita sobre as antigas. Ou seja, as funções vão sendo buscadas a medida 
que são necessárias como em uma cache de computador. Essa técnica foi desenvolvida pela 
Projeto de Sistemas Digitais na Atualidade pág. 15 
 A 
Alexandre Scaico Dezembro/2000 
ATMEL Corporation e, segundo a ATMEL, com isso conseguimos um aumento muito grande da 
utilização do FPGA, pois estudos seus mostram que em um FPGA de 10000 com uma função 
que o utiliza por completo, apenas 2000 são utilizadas ao mesmo tempo. Então, utilizando essa 
tecnologia para fazer a cache das outras 8000 portas podemos implementar essa mesma função 
com um FPGA de 2000 portas (bem mais barato). 
 
 Finalizando, é interessante saber que os dispositivos reprogramáveis não existem apenas 
na área digital. Existem circuitos reconfiguráveis analógicos, os FPAAs (Field Programmable 
Analog Arrays); e os mistos (que misturam estruturam analógicas e digitais), os FPMAs (Field 
Programmable Mixed Arrays). 
 
 
2.7 - Bibliografia 
 
1. FREGNI, Edson e SARAIVA, Antonio M. “Engenharia do Projeto Lógico Digital” Ed. 
Edgard Blûcher LTDA, São Paulo, SP, 1995. 
 
2. SEALS, R. C. & WHAPSHOTT, G. F. “Programmable Logic – PLDs and FPGAs”. Ed. 
McGraw-Hill, USA, 1997. 
 
3. DEWEY, Allen M. “Analysis and Design of Digital Systems with VHDL”. Ed. ITP, Boston, 
MA, USA, 1997. 
 
4. WESTE, Neil H. E. & ESHRAGHIAN, Kamran. “Principles of CMOS VLSI Design – A 
System Perspective”. 2a Edition, Ed. Addison Wesley, Santa Clara, CA, USA, 1993. 
 
5. “Altera Data Book”. Altera Corporation, 1996. 
 
6. “Implement Cache Logic with FPGAs”. Aplication Note, Atmel Corporation, 1999. 
 
7. “Programmable Logic Devices”. (www.eeng.dcu.ie/~scaifer/csh/pld/pld.html} 
 
8. “FPGA Page”. (www.ele.auckland.ac.nz/students/chengms/fpga.htm) 
 
9. “FPGA Research at University of Toronto”. (www.eecg.toronto.edu\EECG\RESEARCH\FPGA.html) 
 
10. “FIPSOC: Field Programmable System on a Chip Family”.(www.sida.es\ftpsoc.htm) 
http://www.eeng.dcu.ie/~scaifer/csh/pld/pld.html
http://www.ele.auckland.ac.nz/students/chengms/fpga.htm
http://www.eecg.toronto.edu/EECG/RESEARCH/FPGA.html
http://www.sida.es/ftpsoc.htm
Projeto de Sistemas Digitais na Atualidade pág. 16 
 A 
Alexandre Scaico Dezembro/2000 
3. AS LINGUAGENS DE DESCRIÇÃO DE HARDWARE 
 
 
 
3.1 - Evolução dos sistemas digitais 
 
O projeto de sistemas digitais têm se desenvolvido rapidamente nos últimos 35 anos. Os 
circuitos digitais mais simples eram desenvolvidos com válvulas e transistores. Posteriormente 
foram criados os circuitos integrados, quando passou-se a existir uma maior preocupação com os 
espaços físicos ocupados por circuitos mais complexos. Os primeiros chips de circuitos 
integrados foram os chips SSI (Integração em Pequena Escala) onde um pequeno número de 
portas lógicas dividiam o mesmo espaço. 
 
Com o começo da sofisticação tecnológica, os projetistas desenvolveram circuitos com 
cerca de 100 portas (ou 100 transistores) em um mesmo chip. Esses chips foram chamados chips 
MSI (Integração em Média Escala). Com o surgimento do LSI (Integração em Larga Escala), os 
projetistas poderiam colocar milhares de portas em um único chip. 
 
Neste ponto, os projetos começaram a ficar muito complexos, e os projetistas acharam 
necessário automatizar todos os processos envolvidos nos projetos. E dessa forma, as técnicas de 
CAD (Projetos Auxiliados por Computador) começaram a ser desenvolvidas. Os projetistas de 
chip passaram a usar circuitos e técnicas de simulação lógica para verificar a funcionalidade de 
blocos de construção da ordem de 100 transistores (ou portas lógicas). Até esta data, os circuitos 
ainda eram testados sobre breadboards (protoboards) e o layout era feito no papel ou pelo 
controle manual de um computador gráfico. 
 
Com o surgimento da Tecnologia VLSI (Integração em Altíssima Escala), os projetistas 
passaram a projetar chips com mais de 100.000 transistores. Devido a complexidade desses 
circuitos já não era possível verificar o funcionamento desses circuitos sobre breadboard. 
Técnicas de auxílio por computador começaram a ficar indispensáveis na verificação e no 
projeto de circuitos digitais VLSI. Programas de computador para fazer automaticamente a 
divisão do espaço disponível e rotinas de layout de circuitos também começaram a se difundir. 
Os projetistas estavam agora construindo circuitos digitais ao nível de porta sobre terminais 
gráficos. Eles construíam pequenos blocos e então formavam blocos em um nível arquitetural 
mais alto a partir dos blocos mais simples. Esse processo continuaria até que se tivesse 
construído todo o circuito. Simuladores lógicos eram então usados para verificar a 
funcionalidade desses circuitos antes da fabricação do chip. Como os projetos foram ficando 
mais e mais complexos, os simuladores lógicos assumiram um importante papel nos processos 
do projeto. 
 
 
3.2 - Surgimento das HDL’s 
 
Ao longo do tempo, linguagens de programação (tais como FORTRAN, Pascal e C) 
foram desenvolvidas para descrever programas de computador. Também no campo de projetos 
digitais, os projetistas começavam a vislumbrar a necessidade de uma linguagem específica para 
descrever circuitos digitais. Surgiram, então, as Linguagens de Descrição de Hardware (HDLs). 
As HDLs podem descrever um sistema digital em vários níveis. Por exemplo, uma HDL pode 
descrever o layout dos fios, resistores e transistores sobre um chip de circuito integrado, ou seja, 
descrever o nível de layout. Ou ela pode descrever as portas lógicas e flip-flops em um sistema 
digital, ou seja, o nível de portas lógicas. Em um nível mais alto ela descreve os registradores e 
Projeto de Sistemas Digitais na Atualidade pág. 17 
 A 
Alexandre Scaico Dezembro/2000 
os vetores de transferência de informação entre os registradores. Este é chamado de nível de 
transferência entre registradores (RTL). Existe ainda o nível comportamental, em que se 
descreve apenas a funcionalidade do projeto sem se preocupar com detalhes de implementação. 
 
Ao contrário das linguagens seqüenciais (Pascal, FORTRAN, C, etc.), as HDL’s permitiram 
aos projetistas modelarem os processos concorrentes encontrados nos elementos de Hardware. 
Entre essas linguagens as que se tornaram mais populares foram a Verilog HDL e a VHDL. 
 
A Verilog HDL foi introduzida em 1985 pela Gateway Design System Corporation. Até 
maio de 1990, com a formação da Open Verilog International (OVI), a Verilog HDL era uma 
linguagem de propriedade da Cadence Design Systems, conglomerado que tinha o controle da 
Gateway Design System Corporation. 
 
A VHDL foi desenvolvida em 1983 pelo departamento de defesa americano (DOD) 
através de um programa chamado Very High Speed Integrated Circuits (VHSIC). Apesar de 
difícil de aprender, VHDL passou a ser um padrão aceito pelo IEEE em 1987. 
 
Atualmente ambos os padrões, Verilog e VHDL são amplamente aceitos pelos projetistas de 
sistemas digitais. 
 
 
3.3 - Fluxo Típico em um Projeto 
 
Um típico diagrama de fluxo de projetos de circuitos VLSI IC é mostrado na figura 
abaixo. 
 
Fig. 11 - Diagrama de fluxo típico de um projeto de um sistema digital 
 
O diagrama de fluxo acima é tipicamente usado para projetos que usam HDL’s. Em 
qualquer projeto, as especificações são definidas primeiro. As especificações descrevem de 
Especificações do Projeto
Descrições de procedimento
Descrições RTL (HDL)
Verificação Funcional de Testes
Síntese Lógica
Net List -- Nível-porta
Verificação lógica e teste
Plano de Fundo Automático
Layout físico
Verificação de layout
Implementação
Projeto de Sistemas Digitais na Atualidade pág. 18 
 A 
Alexandre Scaico Dezembro/2000 
forma abstrata a funcionalidade, interface, e toda a arquitetura do circuito digital a ser projetado. 
Neste ponto o projetista não precisa saber como implementar o circuito. A descrição de 
funcionamento é então criada para analisar o projeto em temos da funcionalidade, performance, 
submissão aos padrões e outras características de alto-nível. As descrições de funcionamento são 
manualmente convertidas para as descrições RTL em uma HDL. O projetista tem que descrever 
o fluxo de dados desejado no circuito digital. Deste ponto em diante, o processo é feito com o 
auxílio de ferramentas de CAD (Computer-Aided Design). 
 
As ferramentas de síntese lógica convertem a descrição RTL em uma descrição à nível de 
portas lógicas. O nível de portas lógicas é uma descrição do circuito em termos de portas e 
conexões entre elas. O nível de porta é a entrada para a ferramenta de rotas e distribuição física 
dos elementos, a qual cria o layout. O layout é verificado e então o chip é fabricado. 
 
A maior parte do tempo gasto no projeto de um circuito digital é concentrado na 
otimização manual da descrição RTL do circuito. Depois da descrição RTL concluída, 
ferramentas de CAD são usadas para assistir o projeto nos demais processos. Diminuindo-se o 
tempo gasto no nível RTL pode-se reduzir o tempo de projeto de anos para poucos meses. É 
também possível fazer mais interações no projeto em um curto período de tempo. 
 
Com essa finalidade, ferramentas de síntesecomportamental tem começado a surgir 
recentemente. Essas ferramentas podem criar descrições RTL a partir da descrição da 
funcionalidade do circuito (nível comportamental). Com o amadurecimento dessas ferramentas, 
os projetos de circuitos digitais estão se tornarão similares à programação em alto-nível de 
computadores. Os projetistas simplesmente implementarão o algoritmo com a HDL em um nível 
muito abstrato. As ferramentas de CAD ajudarão os projetistas a converterem as descrições de 
procedimento em um chip de circuito integrado. 
 
É importante notar que apesar das ferramentas de CAD conseguirem automatizar os 
processos e reduzirem o tempo de projeto, os projetistas serão ainda as pessoas que controlarão a 
performance dessas ferramentas. Além disso, se usadas impropriamente, essas ferramentas de 
CAD produzirão projetos ineficientes. Então torna-se necessário o uso de projetistas que 
entendam as nuances das metodologias de projeto, usando as ferramentas de CAD para obter um 
projeto otimizado. 
 
 
3.4 - Importância das HDL’s 
 
As HDL’s levam muita vantagem em relação aos projetos baseados apenas em esquemas 
tradicionais. 
 
• Os projetos podem ser descritos em um nível muito abstrato pelo uso de HDL’s. 
Projetistas podem escrever suas descrições sem escolha prévia de uma tecnologia 
específica de fabricação. Ferramentas de síntese lógica podem automaticamente 
converter os projetos para qualquer tecnologia de fabricação. Se uma nova tecnologia 
surgir, os projetistas não necessitam reprojetar seus circuitos. Eles simplesmente entram 
com as descrições RTL e/ou comportamental na ferramenta de síntese lógica (desde que a 
ferramenta suporte o nível de descrição usado) e ela então cria uma nova organização ao 
nível de porta, usando a nova tecnologia de fabricação. A síntese lógica otimiza o circuito 
na área e no tempo de processamento, adequando-o a nova tecnologia. 
• Através da descrição em HDL’s, a verificação funcional do projeto pode ser feita 
facilmente durante as etapas de projeto. Desde que projetistas trabalham em um nível 
Projeto de Sistemas Digitais na Atualidade pág. 19 
 A 
Alexandre Scaico Dezembro/2000 
mais alto de abstração (RTL ou comportamental), eles podem otimizar e modificar suas 
descrições até que seja alcançada a funcionalidade desejada. A maior parte dos bugs do 
projeto são eliminados nesse ponto. Isso causa uma redução significativa no tempo gasto 
no projeto. 
 
• Projetos com HDL’s são análogos a programas de computador. Uma descrição textual 
com comentários é uma forma fácil de desenvolver circuitos e retirar seus problemas. 
Eles também fornecem uma concisa representação do projeto comparado com os 
esquemas elétricos tradicionais. Esses esquemas tradicionais são altamente 
incompreensíveis para projetos muito complexos. 
 
HDLs são certamente uma tendência no futuro. Com o rápido aumento da complexidade 
dos circuitos digitais e com a sofisticação das ferramentas de CAD, HDLs provavelmente se 
tornarão o único método de projeto de grandes sistemas. 
 
 
3.5 - Tendências em HDL’s 
 
 A velocidade e complexibilidade dos circuitos digitais têm crescido rapidamente. Os 
projetistas têm projetado em níveis cada vez mais altos de abstração, se preocupando apenas com 
a funcionalidade dos circuitos e deixando os detalhes de implementação a cargo das ferramentas 
de CAD. Essas ferramentas por sua vez vem se tornando sofisticadas o suficientemente para 
fazerem implementações próximas do ótimo. 
 
Certamente a tendência atual é projetar em HDL em um nível alto de abstração (RTL ou 
comportamental) e empregar as ferramentas de síntese lógica para criar os nível de portas a partir 
do nível projetado. 
 
A síntese de funcionalidade surgiu recentemente. Com o melhoramento dessas 
ferramentas, os projetistas irão conseguir projetar diretamente em algoritmos o comportamento 
do circuito e então usar ferramentas de CAD para fazer a tradução e otimização nas demais fases 
do projeto. A modelagem do comportamento dos circuitos será usada mais e mais com o 
amadurecimento da síntese de funcionalidade. 
 
Técnicas de “verificação formal” também vêm aparecendo no horizonte. A verificação 
formal aplica técnicas de matemática formal para verificar a precisão das descrições em HDL e 
estabelecer equivalência entre o nível RTL (e/ou comportamental) e o nível de portas. Contudo a 
necessidade de descrever um projeto em HDL não irá desaparecer. 
 
Para circuitos de alta velocidade como microprocessadores, o nível de portas provido 
pelas ferramentas de síntese lógica não é ótimo. Nestes casos os projetistas misturam as 
descrições em nível de portas com as descrições em níveis mais abstratos para conseguir 
resultados melhores. Esta prática vai contra o paradigma de se projetar em alto-nível, mas 
mesmo assim, é muito utilizada pelos projetistas devido a ineficiência das ferramentas de CAD 
para esses circuitos de tempo crítico. 
 
 
3.6 - Bibliografia 
 
01. PALNIKTAR, Salmir. Verilog HDL – A Guide to Digital Design and Synthesis, Sun Soft 
Press, California, EUA, 1996. 
Projeto de Sistemas Digitais na Atualidade pág. 20 
 A 
Alexandre Scaico Dezembro/2000 
4. VERILOG HDL 
 
 
 
4.1 - O que é Verilog? 
 
O Verilog é uma das duas maiores HDL (Hardware Description Language – Linguagem 
de Descrição de Hardware) usadas pelos projetista de hardware na industria e mo meio 
acadêmico (a outra é o VHDL). Ela é usada para descrever o comportamento e a estrutura de 
uma parte de um hardware (ou ele todo), e é muito parecido com uma linguagem de 
programação de alto nível (C, para ser mais preciso). 
 
O Verilog foi desenvolvido entre 1984 e 1985 por Philip Moorby que necessitava de um 
meio simples, intuitivo e efetivo de descrever circuitos digitais para modelagem, simulação e 
análise. Em 1985 a linguagem se tornou propriedade da Gateway Design System Corporation, 
que posteriormente foi adquirida pela Cadence Design Systems Inc., que desenvolveu a 
linguagem. Até maio de 1990, quando foi criada a Open Verilog International (OVI), o Verilog 
era uma linguagem proprietária da Cadence. Com o OVI a Cadence se sentiu motivada a abrir a 
linguagem para domínio público com a expectativa que com isso aumentasse rapidamente a 
aceitação da linguagem, e com isso a procura por suas ferramentas de desenvolvimento para 
Verilog. 
 
 O padrão atual da linguagem Verilog é o IEEE1364 de dezembro de 1995. 
 
 
4.2 - Por que usar o Verilog HDL? 
 
Os sistemas digitais atuais são muito complexos. Em seus níveis de maior detalhamento, 
verificamos que eles consistem de milhões de elementos (transistores ou portas lógicas). Então, 
para sistemas digitais grandes, o projeto a nível de portas lógicas está morto. Por muitas décadas, 
esquemas lógicos serviram como a linguagem para projetos digitais. Porém hoje em dia a 
complexidade do hardware cresceu para um degrau no qual os esquemas lógicos não são mais 
usuais e mostram apenas uma teia de conexões e não a funcionalidade do projeto. Desde 1970, 
engenheiros de computação e engenheiros elétricos tem usado as HDL’s, das quais as 
proeminentes são o Verilog e o VHDL. Porém o Verilog é usado pela maioria dos 
desenvolvedores, dentre os quais os projetistas de empresas como a Sun Microsistems, Apple 
Computer e Motorola. 
 
A linguagem Verilog provê ao projetista digital a possibilidade de descrever um sistema 
digital em uma grande faixa de níveis de abstração, e, ao mesmo tempo, provê acessoa 
ferramentas de projeto por computador no auxílio ao projeto. 
 
O Verilog permite expressar o projeto em termos de estruturas comportamentais, 
deixando os detalhes da implementação para um estágio posterior do projeto. Uma representação 
abstrata ajuda o projetista a explorar alternativas de arquiteturas através de simulações e detectar 
falhas no projeto antes de começar um maior detalhamento do projeto. 
 
Após terminar os testes com o projeto em Verilog em um nível comportamental, existem 
ferramentas computacionais que compilam descrições em Verilog para uma descrição das 
máscaras de um CI VLSI, e então enviar essa descrição para uma fábrica de CI para o mesmo ser 
criado. Pode-se ainda converter uma descrição em Verilog em uma descrição para programar um 
Projeto de Sistemas Digitais na Atualidade pág. 21 
 A 
Alexandre Scaico Dezembro/2000 
FPGA (ou um ASIC, ou um PLD), onde o mesmo é testado e o projeto é aperfeiçoado para 
depois ser enviado para uma fábrica de CI. 
 
 
4.3 - Popularidade do Verilog HDL 
 
O Verilog tem se tornado uma linguagem de descrição de hardware padrão por oferecer 
características muito úteis aos projetistas digitais. Dentre as quais podemos destacar: 
 
• O Verilog é uma HDL de propósito geral que é fácil de aprender e usar. Sua sintaxe é 
similar a da linguagem de programação C. Projetistas com experiência de programação 
em C vão achar fácil aprender Verilog. 
• O Verilog permite que diferentes níveis de abstração sejam misturados em um mesmo 
modelo. Então, pode-se definir uma parte do hardware em termos de portas lógicas, outra 
em termos comportamentais, etc. 
• As ferramentas de síntese lógica mais populares suportam o Verilog. Isto torna o Verilog 
a linguagem de escolha dos projetistas. 
 
 
4.4 - Aplicações do Verilog e outras linguagens HDL 
 
As linguagens de descrição de hardware encontraram a sua principal aplicação em 
Dispositivos Lógicos Programáveis (PLD – Programmable Logic Devices) em vários níveis de 
complexidade, desde PLD’s simples até PLD’s complexos (CPLD – Complex PLD), e também 
nos FPGA’s (Field Programmable Gate Array). 
 
PLD’s são, de maneira simplificada, matrizes programáveis de estruturas de soma de 
produtos (AND-OR). São utilizados em circuitos onde não é exigida muita flexibilidade nem 
muita lógica seqüencial. Já os FPGA’s são dispositivos mais complexos, que consistem em 
vários blocos lógicos em que o projeto é realizado. Essa divisão em blocos e a composição dos 
mesmos varia de forma radical de fabricante para fabricante, não sendo aqui possível uma 
explicação genérica deste dispositivo. 
 
No caso específico do Verilog, temos que inicialmente (meio dos anos 80) ele era usado 
para o projeto de ASIC´s (usando ferramentas de síntese para automaticamente criar e otimizar a 
implementação). Atualmente, o Verilog também é usado (como já foi mencionando) nas áreas de 
FPGA’s e PLD’s (que são sua aplicação principal). 
 
Existem hoje em dia várias linguagens de descrição de hardware sendo utilizadas 
atualmente. As mais populares são a Abel, Palasm e Cupl (usadas para projetos de dispositivos 
com baixa complexidade), e a Verilog e VHDL (para grandes CPLD’s e FPGA’s). 
 
 
4.5 - Limitações do Verilog 
 
O Verilog é uma linguagem para projeto de sistemas digitais. Até o presente momento ele 
não suporta trabalhar com sistemas e sinais analógicos. 
 
O IEEE 1364 define apenas a linguagem Verilog e sua sintaxe, porém ele não descreve os 
diferentes estilos do Verilog e quando usá-los. 
Projeto de Sistemas Digitais na Atualidade pág. 22 
 A 
Alexandre Scaico Dezembro/2000 
Cada ferramenta de síntese suporta uma partição da linguagem Verilog (definida pelo 
fabricante da ferramenta) e não toda a linguagem. Com isso a vezes é necessário se adequar 
(alterar) o seu código (descrição em Verilog) para se usar determinada ferramenta de síntese. 
 
 
4.6 - Níveis de abstração 
 
Como já foi mencionado, uma descrição de um sistema digital em Verilog pode ser feita 
em vários níveis de abstração, que são os diferentes estilos de escrita em Verilog. A abstração 
define o nível de detalhamento necessário ao projeto, especificado por uma dada descrição 
desejada. Esses níveis de abstração são: 
 
1. Nível de Layout: É o nível mais baixo de abstração. O projeto neste nível é implementado em 
termos de chaves, nós de armazenamentos, e das interconexões entre eles. Este nível 
especifica as informações sobre o layout atual do projeto na pastilha de silício, e pode 
também especificar informações detalhadas sobre temporização e possíveis efeitos 
analógicos. 
 
2. Nível de portas lógicas: Em seguida ao nível de layout vem o nível de portas lógicas. Aqui o 
projeto é descrito como uma rede de portas lógicas e registradores, e das interconexões entre 
os mesmos. Projetar neste nível é similar a descrever um projeto em termos de diagrama 
lógico de portas lógicas. Já o layout e os efeitos analógicos são ignorados. No entanto, o 
projeto contém informações sobre a função, a arquitetura, a tecnologia e a temporização. 
 
3. Nível de Transferência de registros (RTL – Register Transfer Level): É também conhecido 
como nível de fluxo de dados. Nesse nível usamos um estilo estrito do Verilog que define 
cada registrador do projeto, e a lógica entre eles (o projeto especifica o fluxo dos dados). 
Aqui, o projetista está preocupado em como os dados fluem entre os registradores. O projeto 
contém informações sobre a arquitetura, mas não contém detalhes sobre a tecnologia. 
 
4. Nível Comportamental: Este é o nível mais alto de abstração. Aqui descrevemos a função do 
projeto sem especificar a arquitetura ou os registradores. O projeto pode ser implementado 
em termos do algoritmo do projeto desejado sem detalhes da implementação de hardware. 
Projetar neste nível é similar a programar em C. 
 
 
4.7 - Nível comportamental x RTL 
 
Como mostrado, existem quatro estilos distintos no Verilog. Os níveis de layout e de 
portas lógicas não são adequados para sistemas com um número considerável de elementos, 
sendo mais utilizados os níveis RTL e comportamental. 
 
Vamos ver os casos os casos em que um desses níveis (RTL e comportamental) é mais 
adequado que o outro: 
 
• A razão para o RTL ser tão importante é que a maioria das ferramentas de síntese que 
existem hoje requer que o código esteja escrito em RTL. E nesse nível o projetista ainda 
mantém controle sobre a arquitetura dos registradores do projeto. 
• Por outro lado, as ferramentas de síntese comportamental geram automaticamente 
arquiteturas de portas lógicas e de registradores direto de uma descrição comportamental 
Projeto de Sistemas Digitais na Atualidade pág. 23 
 A 
Alexandre Scaico Dezembro/2000 
em Verilog. Existem poucas ferramentas desse tipo e elas tendem a ser baseadas em 
VHDL. 
• Geralmente você precisa descrever seu projeto de FPGA ou PLD em RTL para usar as 
ferramentas de síntese disponíveis. 
• O nível comportamental é usado para criar estruturas de estímulos, para modelar partes 
padrão do projeto, ou para criar especificações simuláveis do seu sistema. 
 
Atualmente, as descrições são feitas utilizando conjuntamente os níveis RTL e 
comportamentalpara dar maior flexibilidade ao projetista. E pra isso os fabricante já dispõem de 
ferramentas de síntese lógica que suporta esses dois níveis de descrição (e também o de portas 
lógicas, se for necessário). 
 
 
4.8 - Conceitos principais da linguagem 
 
1. Concorrência 
Como o Verilog nos permite descrever hardware, ele também tem que ser capaz de descrever 
atividades que estão ocorrendo em paralelo (atividades concorrentes). 
 
Fig. 12 – Concorrência 
 
2. Estrutura 
Uma característica muito importante do Verilog é a capacidade de descrever estrutura ou 
hierarquia. Descrições de estrutura podem ser misturadas com descrições de comportamento. 
Também é possível ter apenas a descrição estrutural do projeto em Verilog ( que são as 
netlists do Verilog). 
 
 
Fig. 13 – Estrutura hierárquica 
 
3. Declarações de procedimentos 
Uma descrição em Verilog pode também conter declarações que executam um após o outro 
em seqüência como uma linguagem de software tradicional com C ou Pascal. Isso é 
conhecido como declarações de procedimento. 
 
4. Tempo 
O Verilog nos permite modelar o conceito de tempo, que claramente é uma parte muito 
importante da descrição de um sistema eletrônico. 
 
 
 
 
C
D
S 
A
B
Cin 
 
U1 
 
U2 
A
B 
CARRY U1 
SUM 
Projeto de Sistemas Digitais na Atualidade pág. 24 
 A 
Alexandre Scaico Dezembro/2000 
4.9 - Metodologias de projeto 
 
Existem 2 tipos básicos de metodologias para projetos digitais: metodologia de projeto 
“top-down” e a metodologia de projeto “botton-up”. 
 
Na metodologia “top-down” nós definimos o bloco de nível superior do projeto e 
identificamos os sub-blocos necessários para construir o bloco de nível superior. Subdividimos 
então os sub-blocos até chegarmos em células básicas (blocos que não podem ser subdivididos), 
como mostra a figura abaixo. 
 
 
Fig. 14 – Metodologia top-down 
 
Na metodologia “bottom-up” nós primeiro identificamos os blocos que possuímos e a 
partir deles construímos blocos maiores até chegarmos no bloco de nível superior, como mostra a 
figura abaixo. 
 
 
Fig. 15 – Metodologia bottom-up 
 
Usualmente usamos uma combinação dessas 2 metodologias. Especificamos o bloco de 
nível superior e vamos dividindo-o ao mesmo tempo em que identificamos os blocos que já 
possuímos e vamos agrupando-os para formar blocos maiores. 
 
 
4.10 - Estrutura dos módulos 
 
Agora vamos começar a ver como estruturamos o código em Verilog para fazer a 
representação de um projeto. Um projeto é formado a partir da construção de blocos, e no 
Verilog cada bloco é chamado de módulo. O módulo é o equivalente a um símbolo em um 
projeto baseado em esquema elétrico. 
 
A primeira coisa que temos que fazer quando desenvolvemos um bloco é dar a ele um 
nome único. Em seguida temos que definir as interfaces desse projeto e especificar quais são 
BS 
SB SB SB SB 
CB CB CB CB CB CB CB CB 
BS 
SB SB SB SB 
CB CB CB CB CB CB CB CB 
Projeto de Sistemas Digitais na Atualidade pág. 25 
 A 
Alexandre Scaico Dezembro/2000 
entradas, saídas ou portas bidirecionais. Nós temos que incluir informações sobre a 
funcionalidade que é implementada pelo bloco. 
 
Nós podemos ainda ter a necessidade de incluir blocos de nível inferior no projeto. Para 
isso temos que definir quais são esses blocos e como eles são interconectados. A esse processo 
dá-se o nome de hierarquia. 
 
O bloco abaixo sintetiza tudo o que foi enunciado. 
 
 
Fig. 16 – Estrutura de um módulo 
 
O módulo pode ser um elemento ou uma coleção de blocos de projeto de nível inferior. 
Tipicamente, os elementos são agrupados em módulos para prover uma funcionalidade comum 
que é usada em várias partes do projeto. Um modulo provê a funcionalidade necessária para o 
bloco de nível superior através de sua interface de portas (entradas e saídas), mas esconde a 
implementação interna. Isto permite ao projetista modificar o conteúdo de um módulo sem afetar 
o resto do projeto. 
 
Um modulo é declarado pela keyword module e seu término com a keyword endmodule. 
Todo módulo deve conter um identificador para o módulo (seu nome), o module_name, 
acompanhado de uma descrição das entradas e saídas do módulo, o module_terminal_list. Deve 
conter também a definição de quem é entrada/saída e a descrição de sua funcionalidade, o 
module_internals. 
 
 
module<module_name> 
. 
. 
. 
<module_internals> 
. 
. 
. 
endmodule 
 
 
O Verilog é uma linguagem tanto estrutural quanto comportamental. O conteúdo de cada 
módulo, como já foi explicado, pode ser definido em 4 níveis de abstração, dependendo da 
necessidade do projeto. O módulo se comporta identicamente com o ambiente externo 
independente do nível de abstração no qual é descrito (o conteúdo do módulo é invisível para o 
ambiente). Então, podemos mudar o nível de abstração que descreve o módulo sem a 
necessidade de mudanças no ambiente. 
 
O Verilog permite ao projetista misturar e casar os 4 níveis de abstração em um mesmo 
projeto. Se um projeto contém 4 módulos, o Verilog permite que cada modulo seja escrito em 
um nível de abstração diferente. 
Bloco X 
Bloco Y 
BlocoA 
f 
Entrada 1 
Entrada 2 
Saída 1 
Saída 2 
Projeto de Sistemas Digitais na Atualidade pág. 26 
 A 
Alexandre Scaico Dezembro/2000 
Quanto mais alto o nível de abstração, mais flexível e independente da tecnologia é o 
projeto. Quanto mais baixo o nível de abstração (aproximando do nível de layout), mais 
dependente da tecnologia e inflexível se torna o projeto. Considere a analogia com a 
programação em C e em Assembly. É fácil programar em uma linguagem de alto nível como o 
C, e o programa pode ser facilmente portado para qualquer máquina. No entanto, se o programa 
é em assembly, ele é escrito para uma máquina específica e não é facilmente portável para outra 
máquina. 
 
 
4.11 - Projeto hierárquico 
 
 A hierarquia de um projeto descreve a forma na qual ele é dividido em sub-blocos 
recursivamente até eventualmente chegarmos a um nível de célula básica. É importante entender 
hierarquia para se entender os conceito de projeto hierárquico. 
 
 
Fig. 17 – Projeto hierárquico 
 
 Acima temos o diagrama que mostra os sub-blocos que formam o bloco A e a sua 
hierarquia dentro do bloco. 
 
 As vantagens que obtemos ao fazer uso da hierarquia são: 
 
• Ao dividir o projeto em partes menores se torna mais fácil encontrar e depurar erros, já que o 
projetista irá lidar com pedaços menores de código. 
• Pedaços da lógica (sub-blocos) podem ser identificados e reusados em outras partes do 
projeto apenas instanciando ("chamando") o sub-bloco quando necessário. 
• Um projeto em blocos pode ser distribuído entre vários projetistas. 
 
 
4.12 - Instâncias 
 
Um módulo é um modelo, a partir do qual você pode criar objetos. Quando um módulo é 
chamado, o Verilog cria um objeto único a partir do modelo. Cada objeto tem seu próprio nome, 
variáveis, parâmetros e interfaces de E/S. O processo de criar um objeto a partir de um módulo 
modelo é chamado instanciação, e os objetos são chamados de instâncias. No exemplo abaixo 
(contador de 4 bits) o bloco de nível superior cria 4 instâncias do flip-flop T (T_FF) modelo, que 
por sua vez instância umD_FF e uma porta inversora. Observe que cada instância deve possuir 
um nome único. 
 
 Atente para o fato de que no Verilog é ilegal cascatear módulos (um dentro do outro), só 
é permitido instanciar. 
 
Bloco A 
Bloco X Bloco Y Bloco Z 
Bloco D Bloco E Bloco B Bloco C Bloco B Bloco D 
Projeto de Sistemas Digitais na Atualidade pág. 27 
 A 
Alexandre Scaico Dezembro/2000 
 
Fig. 18 – Contador de 4 bits 
 
Fig. 19 – Flip-flop D 
 
 Temos a seguir a descrição em Verilog. 
 
 module ripple_carry_ counter(q, clk, reset); 
 
 output [3,0] q; 
 input clk, reset; 
 
 T_FF tff0(q(0), clk, reset); // 1ª instância do T_FF 
 T_FF tff1(q(1), q(0), reset); // 2ª instância do T_FF 
 T_FF tff2(q(2), q(1), reset); // 3ª instância do T_FF 
 T_FF tff3(q(3), q(2), reset); // 4ª instância do T_FF 
 
 endmodule 
 
 module T_FF(q, clk, reset); 
 
 output q; 
 input clk, reset; 
 wire d; 
 
 D_FF dff0(q, d, clk, reset); // instância de D_FF 
 not n1(d, q) // a porta inversora é uma porta básica do Verilog 
 
 endmodule 
 
 
4.13 - Representando hierarquia 
 
 A hierarquia é representada pela instanciação. Instanciando blocos de níveis inferiores 
(sub-blocos) nós podemos usar sua funcionalidade, mas não precisamos descrever sua 
d 
q
D_FF clock 
reset 
q
q 
T_FF 
tff 0
q 
T_FF 
tff 0
q
T_FF 
tff 0
q 
T_FF 
tff 0
q0 q1 q2 q3 
clock 
reset 
Contador 
de 4 bits
Projeto de Sistemas Digitais na Atualidade pág. 28 
 A 
Alexandre Scaico Dezembro/2000 
funcionalidade neste nível. Podemos descrever o módulo de nível inferior em qualquer outro 
lugar. 
 
 No entanto isso significa que o módulo pode ter dois tipos de nomes: nomes de referência 
e nomes de instância. Para não gerar confusão vamos ver um exemplo de um somador completo 
feito a partir de dois meio somadores. Isso nós dá dois níveis de hierarquia. 
 
 
Fig. 20 – Estrutura hierárquica de um somador completo 
 
 Neste caso, o bloco meio somador, com nome de referência HALF_ADD é instanciado 
duas vezes. Então precisamos de dois nomes de instância U1 e U2 para distinguí-los. 
 
 
Fig. 21 – Instâncias em um somador completo 
 
 Tipicamente você vai instanciar o nível mais alto do seu projeto em um módulo de 
estímulo (que serve para testar a funcionalidade do projeto), que então passará a ser o seu bloco 
de nível superior. 
 
 
4.14 - Componentes de uma simulação 
 
Uma vez que um projeto ou parte dele é completado, é uma boa prática testá-lo. A 
funcionalidade do bloco projetado pode ser testada aplicando-se estímulos e checando os 
resultados. Nós chamamos o bloco que faz isso de módulo de estímulo. É uma boa prática 
manter o projeto e módulo de estímulo em arquivos separado e identificar os dois como fazendo 
parte de um mesmo projeto maior. 
 
Dois estilos de aplicação de estímulos são possíveis. No primeiro estilo o módulo de estímulo 
instancia o módulo do projeto e mando e recebe sinais do mesmo (o bloco de estímulo não 
possui nem entradas nem saídas). 
 
No segundo estilo, os blocos de estímulo e projeto são instanciados em um módulo de teste 
(novo bloco de nível superior). O bloco de estímulo então interage com o projeto através de suas 
interfaces. 
 
Temos a seguir um esquema ilustrativo desses dois estilos de simulação. 
 
 
 
somador completo
meio somadormeio somador
HALF_ADD 
U1 
HALF_ADD 
U2 
OR 
FULL ADD 
A 
B 
Cin
SUM 
CARRY 
Nomes de instância 
Projeto de Sistemas Digitais na Atualidade pág. 29 
 A 
Alexandre Scaico Dezembro/2000 
 
Fig. 22 – Estilos de simulação 
 
 
4.15 - Nomes hierárquicos 
 
Como foi visto o Verilog suporta uma metodologia de projeto hierárquico. Cada instância 
de um módulo é definida com um identificador (seu nome de instância). Cada identificador em 
particular tem uma posição única na hierarquia do projeto. Um nome hierárquico é uma lista de 
identificadores separados por pontos para cada nível de hierarquia. Então, cada identificador 
pode ser endereçado de qualquer lugar do projeto simplesmente especificando o nome 
hierárquico correspondente desse identificador. 
 
O módulo de nível superior é chamado de módulo raiz porque ele não é instanciado em 
nenhum lugar do projeto. Ele é o ponto de partida. Normalmente o módulo de nível superior é 
um módulo de estímulo (para testar o projeto). 
 
Para identificar o nome único de um identificador, comece do módulo de nível superior e 
trace o caminho através do projeto hierárquico até o identificador desejado. Para ficar mais claro 
esse processo, vamos considerar o exemplo abaixo, já visto anteriormente. 
 
 
Fig. 23 – Módulo de estímulo do somador completo 
 
Para essa simulação, o módulo ESTÍMULO é o módulo de nível superior. Como ele não é 
instanciado em parte alguma, ele é o módulo raiz. Os identificadores definidos nesse módulo são 
A, B, Cin, SUM e CARRY. Módulo raiz instancia U1 (com o identificadores a, b, L1 e L2) e U2 
(com os identificadores (L1, cin, sum L3), que são módulos do tipo HALF_ADD e uma porta 
básica OR (com os identificadores L2, L3, cr). Como a porta OR é um bloco básico do Verilog e 
só é usado uma vez não é necessário instanciá-la. A partir dai podemos identificar os nomes 
hierárquicos, que são: 
 
HALF_ADD 
U1 
HALF_ADD 
U2 
OR 
FULL ADD 
A 
B 
Cin 
SUM 
CARRY 
ESTÍMULO 
L1 
L2 
L3 
 
 
 
 
módulo projetado 
Bloco de estímulo 
(estímulos) 
(resultados) 
Bloco de teste 
módulo 
 
de 
 
estímulo 
módulo 
 
do 
 
projeto 
Projeto de Sistemas Digitais na Atualidade pág. 30 
 A 
Alexandre Scaico Dezembro/2000 
ESTÍMULO ESTÍMULO.FULL_ADD.HALF_ADD.U1 
ESTÍMULO.FULL_ADD ESTÍMULO.FULL_ADD.HALF_ADD.U2 
ESTÍMULO.FULL_ADD.A ESTÍMULO.FULL_ADD.HALF_ADD.U1.A 
ESTÍMULO.FULL_ADD.B ESTÍMULO.FULL_ADD.HALF_ADD.U1.B 
ESTÍMULO.FULL_ADD.Cin ESTÍMULO.FULL_ADD.HALF_ADD.U1.L1 
ESTÍMULO.FULL_ADD.SUM ESTÍMULO.FULL_ADD.HALF_ADD.U2.L1 
ESTÍMULO.FULL_ADD.CARRY ESTÍMULO.FULL_ADD.OR.CARRY 
 
A partir dai você pode identificar os outros nomes hierárquicos. 
 
 
4.16 - Exemplos de módulos 
 
Vamos agora mostrar 2 exemplos simples de módulos para mostrar de uma forma geral 
como uma descrição é feita no Verilog. 
 
4.16.1 - Meio somador 
 
 
Fig. 24 – Estrutura de um meio somador 
 
A palavra chave module define o começo de cada descrição de módulo e é seguida pela lista 
de portas. Após a lista de portas vem a declaração das portas. Cada porta é declarada com 
entrada, saída ou entrada/saída. Você pode especificar portas como barramento declarando que a 
porta tem um comprimento nas declarações de entrada ou saída. 
 
Finalizando descrevemos o comportamento do módulo. Neste caso temos duas atribuições de 
sinais: o resultado de "A xor B" é atribuído para a saída SUM, e o resultado de "A and B" e 
atribuído para a saída CARRY. 
 
A seguir temos o código em Verilog para esse módulo. 
 
module HALF_ADD(A, B, SUM, CARRY); 
output SUM, CARRY; 
input A, B; 
assign SUM=A^B; 
assing CARRY=A&B; 
endmodule