tutorial_fpga_vhdl

Prévia do material em texto

VII - SEMANA DA ENGENHARIA 
PUCRS 
 
 
 
 
MINICURSO 2 
 
 
 
DISPOSITIVO LÓGICOS PROGRA-
MÁVEL (FPGA) E LINGUAGEM DE 
DESCRIÇÃO DE HARDWARE (VHDL) 
 
 
 
 
 
 
 
 
ELABORADO E MINISTRADO PELO 
ENGENHEIRO ANDERSON ROYES TERROSO 
 
 
 
 
PORTO ALEGRE, SETEMBRO DE 1998 
 
1 INTRODUÇÃO ................................................................................................................................... 3 
1.1 DISPOSITIVOS LÓGICOS PROGRAMÁVEIS FPGA ............................................................... 3 
1.1.2 DEFINIÇÃO DE BLOCOS LÓGICOS:................................................................................ 4 
1.1.3 DEFINIÇÃO DE ROTEAMENTO ......................................................................................... 5 
1.1.3 DEFINIÇÃO DE IOB´S ......................................................................................................... 7 
1.2 CIRCUITOS PROGRAMÁVEIS EPLD ....................................................................................... 7 
2 LINGUAGEM DE DESCRIÇÃO DE HARDWARE (VHDL) ....................................................... 8 
2.1 O QUE É VHDL?........................................................................................................................... 8 
2.2 O QUE SIGNIFICA VHDL? ......................................................................................................... 8 
2.3 O QUE É UMA LINGUAGEM DE DESCRIÇÃO DE HARDWARE? ........................................ 8 
2.4 BREVE HISTÓRICO .................................................................................................................... 8 
2.4.1 LINHA CRONOLÓGICA....................................................................................................... 9 
2.5 VANTAGENS E DESVANTAGENS DE SE UTILIZAR VHDL............................................... 10 
3 COMPONENTES DE UM PROJETO VHDL ............................................................................... 11 
3.1 PACKAGE (PACOTES) ............................................................................................................. 13 
3.2 ENTITY (ENTIDADE) ............................................................................................................... 14 
3.2.1 TIPO DE PORTAS............................................................................................................... 14 
3.2.2 TIPOS DE SINAIS ............................................................................................................... 14 
3.3 ARCHITECTURE (ARQUITETURA) ....................................................................................... 15 
3.3.1 ARQUITETURA SIMPLES .................................................................................................. 15 
3.3.2 ARQUITETURA CONCORRENTE...................................................................................... 16 
3.4 CONFIGURATION (CONFIGURAÇÃO) ................................................................................. 18 
4 SEMÂNTICA DA LINGUAGEM VHDL....................................................................................... 19 
4.1 ELEMENTOS LÉXICOS ............................................................................................................ 19 
4.1.1 COMENTÁRIOS .................................................................................................................. 19 
4.1.2 IDENTIFICADORES ........................................................................................................... 19 
4.1.3 TIPOS DE DADOS NÃO LÓGICOS ................................................................................... 20 
4.1.4 EXPRESSÕES E OPERADORES ........................................................................................ 21 
5 COMANDOS SEQÜENCIAIS......................................................................................................... 22 
5.1 ATRIBUIÇÃO DE VARIÁVEIS ................................................................................................ 22 
5.2 ATRIBUIÇÃO DE SINAIS ......................................................................................................... 24 
5.3 COMANDO WAIT...................................................................................................................... 26 
5.4 COMANDO IF THEN ELSE....................................................................................................... 26 
5.5 COMANDO LOOP FOR - WHILE ............................................................................................. 31 
5.6 COMANDO NEXT ..................................................................................................................... 32 
5.7 COMANDO EXIT....................................................................................................................... 32 
5.8 COMANDO CASE...................................................................................................................... 33 
5.9 COMANDO NULL ..................................................................................................................... 34 
5.10 COMANDO RETURN .............................................................................................................. 34 
6 ESPECIFICANDO A ESTRUTURA DE UM SISTEMA ............................................................. 35 
7 ALGUNS EXEMPLOS DE IMPLEMENTAÇÕES EM VHDL................................................... 38 
8 BIBLIOGRAFIA ............................................................................................................................... 43 
 
1 INTRODUÇÃO 
 
 
 O rápido desenvolvimento dos recursos de concepção de circuitos in-
tegrados, tanto na área de processos quanto na área de CAD, tornou possí-
vel o aparecimento de dispositivos com Lógica Programável. Tais dispositivos 
permitem aos usuários implementar circuitos complexos sem a necessidade 
do uso de onerosos recursos de fundição em sílicio. 
 A primeira utilização destes circuitos é naturalmente nos projetos de 
prototipagem. Tendo em vista que grande parte destes circuitos podem ser 
reprogramados, o seu uso nas fases preliminares de projeto possibilita uma 
grande economia de tempo e dinheiro. 
 A medida em que os dispositivos de Lógica Programável tornam-se 
cada vez mais densos e rápido, o processo de concepção de projetos eletrô-
nicos se beneficia destes circuitos fazendo com que o tempo de projeto seja 
reduzido em muitos dias. Assim sendo, devido à grande complexidade dos 
projetos capazes de ser implementados em lógica programável, tais circuitos 
passam a ser utilizados em projetos industriais como substituto dos circuitos 
ASIC (Application Specific Integrated Circuits). 
 
1.1 DISPOSITIVOS LÓGICOS PROGRAMÁVEIS FPGA 
 
 FPGA (Field Programmable Gate Array) são circuitos programáveis 
compostos por um conjunto de células lógicas ou blocos lógicos alocados 
em forma de uma matriz. Em geral, a funcionalidade destes blocos assim 
como o seu roteamento, são configuráveis por software. A palavra Field indi-
ca que a configuração do circuito pode ser feita pelo usuário final sem a ne-
cessidade da utilização de recursos de foundries. Na Figura 1.1, está de-
monstrado a estrutura de uma FPGA. 
 
FIGURA 1.1: A estrutura de uma FPGA. 
 
1.1.2 DEFINIÇÃO DE BLOCOS LÓGICOS: 
 
As funções lógicas são implementadas no interior dos Blocos Lógicos. 
Em algumas arquiteturas os Blocos Lógicos possuem recursos seqüenciais 
tais como flip-flop ou registradores. O fabricante Xilinx chama seu Bloco Lógi-
co de CLB (Configurable Logic Block), conforme a Figura 1.2. Enquanto que a 
Actel usa o termo LM (Logic Modules), já a Altera utiliza o termo LE (Logic 
Element) para as séries 8000 e 10000 e Macrocell paraas séries 5000, 7000 
e 9000. 
 
FIGURA 1.2: A estrutura de uma FPGA. 
 
1.1.3 DEFINIÇÃO DE ROTEAMENTO 
 
A interconexão entre os blocos é feita através de uma rede de duas 
camadas de metal. A conexões físicas entre os fios são feitas ora com tran-
sistores de passagem controlados por bits de memória (PIP) ora com chaves 
de interconexão (Switch Matrix). 
Os recursos de roteamento da série XC3000 da Xilinx possuem: 
• Conexões Globais: formam uma rede de interconexão em linha e 
colunas de cinco fios de metal cada, que se ligam através de chaves 
de interconexão. Esta rede circunda os blocos lógicos (CLB´s) e os 
blocos de E/S (IOB´s); 
• Matrizes de Conexão (Switch Matrix): são chaves de interconexão 
que permitem o roteamento entre os Blocos Lógicos através das 
Conexões Globais (Figura 1.3). Estas conexões são programáveis 
na fase de roteamento automático, executada pelo software de pro-
jeto do fabricante ou manualmente com o uso de uma ferramenta de 
software chamada Edinet. 
 
CLB
SB
SBSB
SB 1 2
3
4
56
7
8
Switch Box
 
FIGURA 1.3:Representação de um Switch Box. 
 
• Conexões Diretas: são conexões entre CLB´s vizinhos e permitem 
conectar blocos com menor atraso, pois não utilizam os recursos 
globais de roteamento. 
• Linhas Longas: são conexões que atravessam todo o circuito sem 
passar pelas switch matrix e são utilizadas para conectar sinais lon-
gos e com restrições de skew entre múltiplos destinos (Figura 1.4) 
 
 
FIGURA 1.4: Roteamento de uma FPGA. 
 
1.1.3 DEFINIÇÃO DE IOB´S 
 
Os blocos de E/S possuem buffer tristate e um flip-flop para os sinais 
da saída. O sinal de saída pode ser invertido por programa assim como o si-
nal de controle do tristate (Figura 1.5) 
 
FIGURA 1.5: Representação de um IOB da família XC 3000 da XILINX 
 
1.2 CIRCUITOS PROGRAMÁVEIS EPLD 
 
EPLD (EPROM Programmable Logic Devices) são componentes que 
possuem transistores EPROM para possibilitar sua programação. Os transis-
tores EPROM são usados para forçar valores nas entradas dos blocos lógi-
cos, ou seja, enquanto eles não são programados em seu estado OFF, a 
word line pode forçar valores para o bit line, ora fechando o circuito entre o 
dreno e a fonte do transistor, ora abrindo o circuito entre dreno e a fonte. 
 
 
2 LINGUAGEM DE DESCRIÇÃO DE HARDWARE 
(VHDL) 
 
2.1 O QUE É VHDL? 
 
VHDL é uma forma de se descrever, através de um programa, o comporta-
mento de um circuito ou componente digital. 
 
2.2 O QUE SIGNIFICA VHDL? 
 
Very Hight Speed Integrated Circuit 
Hardware 
Description 
Language 
 
Linguagem de Descrição de Hardware com ênfase em Circuitos Integra-
dos de altíssima velocidade. 
 
2.3 O QUE É UMA LINGUAGEM DE DESCRIÇÃO DE HARD-
WARE? 
 
Uma linguagem de descrição de hardware descreve o que um sistema 
faz e como. Esta descrição é um modelo do sistema hardware, que será exe-
cutado em um software chamado simulador. Um sistema descrito em lingua-
gem de hardware pode ser implementado em um dispositivo programável 
(FPGA - Field Program Gate Array), permitindo assim o uso em campo do 
seu sistema, tendo a grande vantagem da alteração do código a qualquer 
momento. 
 
2.4 BREVE HISTÓRICO 
 
A idéia da criação de uma linguagem de descrição de hardware partiu 
do Departamento de Defesa dos Estados Unidos da América (DoD). As for-
ças armadas americanas, compravam grande quantidade de placas de circui-
tos impressos, sendo que muitas delas compostas de circuitos integrados de 
aplicação específica (ASIC - Application Specific Integrated Circuits). 
Como era comum, empresas da área de eletrônica, mudarem de área ou tro-
car de ramo, necessitava-se garantir a reposição das peças durante a vida 
útil das placas, com isso o DoD iniciou o desenvolvimento de uma linguagem 
padrão de descrição de hardware. 
 
2.4.1 LINHA CRONOLÓGICA 
 
1968: foram desenvolvidas as primeiras linguagens de descrição de hardwa-
re, porém em 1970 tinha-se inúmeras linguagens com sintaxe e semântica 
incompatíveis; 
1973: surge o primeiro esforço de padronização da linguagem, comandado 
pelo projeto CONLAN (CONsensus LANguage), cujo o objetivo principal era: 
definir formalmente uma linguagem de multi-nível com sintaxe única e semân-
tica igual. Paralelamente, iniciou-se outro projeto financiado pelo DoD cujo o 
objetivo era criar uma linguagem de programação. 
1983: em janeiro de 1983, foi publicado o relatório final do projeto CONLAN. 
Neste mesmo ano, também foi publicado o relatório final do projeto DoD, que 
deu origem a linguagem ADA. Em março de 83, o DoD começou o programa 
VHSIC, afim de melhorar a tecnologia de concepção, engenharia e constru-
ção nos EUA. Participaram deste projeto a IBM, Intermetrics e Texas Instru-
ments. 
1986: a Intermetrics desenvolveu um compilador e um simulador. Além disso 
foi criado um grupo de padronização da IEEE para VHDL. 
1988: primeiros softwares são comercializados. 
1991: recomeçou-se um novo processo de padronização, cujo o objetivo era 
a coleta e análise de requisitos, definição dos objetivos e a especificação das 
modificações à linguagem. 
1992: as modificações propostas foram avaliadas e votadas. 
1993: um novo padrão é publicado, chamado VHDL-93, padronizado IEEE 
Std 1164-1993. 
1997: em dezembro de 97 foi publicado o manual de referência da linguagem 
VHDL. 
 
2.5 VANTAGENS E DESVANTAGENS DE SE UTILIZAR VHDL 
 
A descrição de um sistema em VHDL apresenta inúmeras vantagens, tais 
como: 
• Intercâmbio de projetos entre grupos de pesquisa sem a necessidade 
de alteração; 
• Permite ao projetista considerar no seu projeto os delay´s comuns aos 
circuitos digitais; 
• A linguagem independe da tecnologia atual, ou seja, você pode desen-
volver um sistema hoje e implementá-lo depois; 
• Os projetos são fáceis de serem modificados; 
• O custo de produção de um circuito dedicado é elevado, enquanto que 
usando VHDL e Dispositivos Programáveis, isto passa a ser muito me-
nor; 
• Reduz consideravelmente o tempo de projeto e implementação. 
 
Quanto as desvantagens, apenas uma é relevante: 
• VHDL não gera um hardware otimizado; 
3 COMPONENTES DE UM PROJETO VHDL 
 
A estrutura de um programa VHDL, baseia-se em 4 blocos: 
 
PACKAGE 
ENTITY 
ARCHITECTURE 
CONFIGURATION 
 
• PACKAGE são declarados as constantes, tipos de dados, sub-programas; 
• ENTITY declaração dos pinos de entrada e saída; 
• ARCHITECTURE define as implementações do projeto; 
• CONFIGURATION define as arquiteturas que serão utilizadas. 
 
 Abaixo está representado a estrutura de um programa descrito em 
VHDL. 
 
LIBRARY IEEE; 
USE IEEE.STD_LOGIC_1164.all; 
USE IEEE.STD_LOGIC_UNSIGNED.all; 
 
 
 
PACKAGE 
(BIBLIOTECAS) 
 
ENTITY exemplo IS 
PORT ( 
 
 < descrição dos pinos de entrada e saída > 
 
 ); 
END exemplo; 
 
 
 
 
 
ENTITY 
(PINOS DE I/O) 
ARCHITECTURE teste OF exemplo IS 
BEGIN 
 PROCESS( <pinos de entrada e signal > ) 
 
 BEGIN 
 
< descrição do circuito integrado > 
 
 END PROCESS; 
END teste; 
 
 
 
 
ARCHITECTURE 
(ARQUITETURA) 
 
 
LIBRARY IEEE; 
USE IEEE.STD_LOGIC_1164.all; 
USE IEEE.STD_LOGIC_UNSIGNED.all; 
entity placa is 
port ( 
a : in bit_vector( 6 downto 0); 
b : out bit_vector( 6 downto 0) 
 ); 
end placa; 
architecture TTL of placa is 
signal pino_1 bit; 
signal pino_2 bit; 
signal pino_3 bit; 
signal pino_4 bit; 
 
begin 
CI_X : process( a ) 
begin 
<descrição do processo> 
end process CI_Y; 
 
CI_Y : process( a ) 
begin 
<descrição do processo> 
end process CI_Z; 
end TTL; 
 
 
 
 
 
FIGURA 2.1: Apresentação de um programa em VHDL e o sua representação 
em hardware.3.1 PACKAGE (PACOTES) 
 
Os pacotes (biblioteca) contém uma coleção de elementos incluindo 
descrição do tipos de dados (relacione com os includes da Linguagem C). 
Pacotes usados normalmente: 
IEEE.std_logic_arith – funções aritméticas 
IEEE.std_logic_signed – funções aritméticas com sinal 
IEEE.std_logic_unsigned – funções aritméticas sem sinal 
IEEE.std_logic_1164 – std_logic e funções relacionadas 
ALTERA.maxplus2 – declaração de todas as macro-funções e mega-
funções. 
 
Como utilizá-los: 
LIBRARY <nome_da_biblioteca> e/ou 
USE <nome_da_biblioteca>.all 
 
OBS. 1: .all significa que todos os elementos da bibliotecas devem ser 
utilizados, caso não seja acrescentado .all deve-se especificar os ele-
mentos que serão utilizados. 
REGRA GERAL => COLOQUE SEMPRE .all 
 
3.2 ENTITY (ENTIDADE) 
 
3.2.1 TIPO DE PORTAS 
 
IN = porta de entrada; 
OBS.: não pode receber atribuição de valor dentro do programa. 
OUT = porta de saída; 
OBS.: não pode ser utilizado como entrada para outro circuito. 
INOUT = porta de entrada e saída; 
BUFFER = porta de saída que pode ser atualizada por mais de uma fonte; 
LINKAGE = o valor da porta pode ser lido e atualizado. 
EX.: 
Entity <nome> is 
port ( 
 sinal_controle : in <tipo>; 
 parcela_1 : in <tipo>; 
 parcela_2 : out <tipo> 
 ); 
end <nome>; 
 
3.2.2 TIPOS DE SINAIS 
 
<tipo> => bit, bit_vector, std_logic, std_logic_vector, boolean, real, 
bit assume valor ‘0’ ou ‘1’ x : in bit; 
bit_vector vetor de bits. x : in bit_vector(7 downto 0); ou x : in bit_vector(0 to 7);
std_logic 
std_logic_vector vetor de bits. x : in std_logic_vector(7 downto 0); 
Boolean assume valores true ou false (verdadeiro ou falso) 
Real 
 
3.3 ARCHITECTURE (ARQUITETURA) 
 
 Arquitetura pode ser definida como sendo a(s) implementação(ões) do 
projeto. Na figura 3.1, temos uma placa mãe de um PC, por exemplo, onde 
está faltando o chip, considere que a interface entre o chip e o meio externo 
seja idêntica. Na figura 3.2, foi colocado um chip, com toda a arquitetura do 
projeto. 
 
Figura 3.1 Figura 3.2 
 
 
3.3.1 ARQUITETURA SIMPLES 
 
 A arquitetura simples contém apenas um processo, ou seja, apenas 
um bloco. 
Architecture topologia_arquitetura of teste is 
 
begin 
 process ( a, b) 
 
 variable temp : bit; 
 
 begin 
 
 temp := a and b; 
 z <= temp xor a; 
 
 end process; 
end topologia_arquitetura; 
 
 
 
3.3.2 ARQUITETURA CONCORRENTE 
 
 A arquitetura concorrente é uma forma mais complexa de descrever 
um sistema, geralmente apresenta várias processos dentro de uma arquitetu-
ra. 
 No programa 1 e 2, temos uma arquitetura com três processos, po-
dendo ser ou não idependentes. Estes processos são executados em parale-
lo, porém os processos só serão executados se algum sinal (A, B ou C) tiver 
seu estado alterado. Novamente tem-se um ganho de processamento. 
 
Programa 1 Programa 2 
 
 
Architecture topologia_arquitetura of teste is 
 
begin 
 
signal temp1 : bit; 
signal temp2 : bit; 
 
 processo_1 : process ( a, b, temp1 ) 
 
 variable temp3 : bit; 
 
 begin 
 
 temp1 <= ‘0’; 
 temp2 := a and b; 
 z <= temp1 xor temp2; 
 
 end process process_1; 
 
 processo_2 : process ( a, b, temp1, temp2 ) 
 
 variable temp3 : bit; 
 
 begin 
 
 temp2 <= ‘1’; 
 temp3 := a and temp1; 
 w <= temp3 xor temp2; 
 
 end process process_2; 
end topologia_arquitetura; 
 
O exemplo acima, apresenta algumas características, tais como: 
1. Uma arquitetura com dois processos, que serão executados 
2. paralelamente; 
2. Os dois processos possuem variáveis com mesmo nome, mas is-
to não influência no processamento; 
 
 
 
3.4 CONFIGURATION (CONFIGURAÇÃO) 
 
uma mesma entity pode ter várias arquiteturas. 
Exemplo: 
configuration nome_da_config of contador is 
for estrutural 
for all: Tflip_flop 
use entity work.Tflip_flop(comp); 
end for; 
for all: inversor 
use entity work.Tflip_flop(comp); 
end for; 
end for 
end nome_da_config 
4 SEMÂNTICA DA LINGUAGEM VHDL 
 
 
4.1 ELEMENTOS LÉXICOS 
 
4.1.1 COMENTÁRIOS 
 
Comentários em VHDL são iniciados por dois hífens adjacentes (--), podendo 
ser estendido até o final da linha. 
Exemplo 1: 
 
-- a linha que você colocar como comentário, deverá colocar antes de 
-- iniciá-la dois hífens adjacentes. 
 
Exemplo 2: 
 
A <= B and C; -- esta operação realiza a and de B com C e o resultado é 
 -- colocado em A 
 
 
4.1.2 IDENTIFICADORES 
 
Quando se escreve um programa em VHDL, deve-se tomar certos cui-
dados, com os identificadores, abaixo segue uma tabela apresentando alguns 
identificadores válidos e inválidos. 
 
 
IDENTIFICADORES VÁLIDOS 
 
• palavras seguidas do caracter underline _ Ex.: teste_padrao, input_1_x 
• não é sensivel a LETRA MAIÚSCULA e minúscula Ex.: SOMA = soma 
• nome com underline são diferentes de nomes sem underline. Ex.: Teste_Padrao 
≠ TestePadrao 
 
 
IDENTIFICADORES INVÁLIDOS 
 
• uso de palavras reservadas da linguagem com outras finalidades 
identificador começando com número => 7AB 
• uso do caracter @ Ex.: A@B 
• o caracter underline no fim de um identificador Ex.: soma_ 
• o uso de dois caracteres underlines seguidos Ex.: IN__1 
 
 
 
4.1.3 TIPOS DE DADOS NÃO LÓGICOS 
 
• BIT: assume valores ‘0’ e ‘1’, bit_vector é um conjunto de bits. Ex.: 
“010001” 
• Boolean: assume valores true ou false 
• Real: sempre com ponto decimal. Ex.: -3.2, 4.56, 6.0, -2.3E+2 
• Inteiros: não é possível realizar conversão sobre inteiros. Ex.: 3, 546, -349 
• Physical: representam uma medida física: voltagem, capacitância, tempo 
Tipos pré-definidos: fs, ps, ns, um, ms, sec, min, hr. 
• Intervalos: permite determinar um intervalo de utilização dentro de um de-
terminado tipo. 
range <valor_menor> to <valor_maior> 
range <valor_maior> downto <valor_menor> 
• Array: em VHDL um array é definido como uma coleção de elementos to-
dos do mesmo tipo. 
Abaixo seguem alguns exemplos de array: 
 
type word is array (31 downto 0) of bit; 
type memory is array (address) of word; 
type transform is array (1 to 4, 1 to 4) of real; 
type vector is array (integer range<>) of real; 
type string is array (positive range<>) of character 
 
Ex.: 
type b is array (1 to 5) of character; 
(‘t’, ‘e’,’s’,’t’,’e’) 
(1 =>’t’, 5 => ‘e’, 2 => ’e’, 3 => ‘s’, 4 => ‘t’) 
(3 => ‘s’, 2 => ‘e’, 5 => ‘e’, others => ‘t’) 
 
• Record: semelhante a “struct” da Linguagem C, ou seja, é uma coleção 
de elementos de tipos diferentes. 
 
type instruction is record 
Mneumonico : String; 
Code : Bit_vector( 3 downto 0);; 
Ciclos : integer; 
end record; 
 
signal Instr1: instruction; 
 
Instr1.Mneumonico : “or reg1, reg2” 
Instr1. Code : “0010” 
Instr1.Ciclos : 3 
 
4.1.4 EXPRESSÕES E OPERADORES 
 
4.1.4.1 OPERADORES LÓGICOS 
 
 Os operadores lógicos são: and, or, nand, nor, xor, xnor e not. 
 
4.1.4.2 OPERADORES NUMÉRICOS 
 
 Os operadores numéricos são: soma (+), subtração (-), multiplica-
ção (*), divisão (/), módulo (mod), remanescente (rem - ex.: 6 rem 4 = 2), 
expoente (**), valor absoluto (abs). 
 
4.1.4.3 OPERADORES RELACIONAIS 
 
 Os operadores relacionais são; igual (=), diferente (/=), menor do 
que (<), menor ou igual (<=), maior do que (>), maior ou igual (>=). 
 
4.1.4.4 OPERADORES DE DESLOCAMENTO 
 
OperadoresExemplo 
sll - shift left logical 01101001 => 11010010 (acrescenta 0 no bit - sign.) 
srl - shift right logical 01101001 => 01101001 (acrescenta 0 no bit + sign.) 
sla - shift left arithmetic 01101001 => 11010011 (repete o bit - sign.) 
sra - shift right arithmetic 01101001 => 00110100 (repete o bit + sign.) 
rol - rotate left logical 01101001 => 11010010 (desloca todos bits para esq.) 
ror - rotate right logical 01101001 => 10110100 (desloca todos bits para dir.) 
 
4.1.4.5 OPERADOR DE CONCATENAÇÃO 
 
 Esta operação consiste em criar um novo vetor a partir de dois vetores 
já existentes, por exemplo: 
dado1 : bit_vector(0 to 7); 
 [01011011] 
dado2 : bit_vector(0 to 7); 
 [11010010] 
novo_dado : bit_vector(0 to 7); 
novo_dado <= (dado1(0 to 1) & dado2(2 to 5) & dado1(6 to 7)); 
 [01010011] 
 
5 COMANDOS SEQÜENCIAIS 
 
Nesta seção será apresentado alguns comandos sequenciais que o VHDL 
dispõe, são eles: 
atribuição à variáveis comando next 
atribuição à sinais comando exit 
comando wait comando null 
comando if-then-else comando return 
comando loop for- while comando case 
 
5.1 ATRIBUIÇÃO DE VARIÁVEIS 
 
Note que a passagem de parâmetros é realizada utilizando :=. 
Interpretação do programa abaixo: 
Na linha 15 o bit menos significativo do vetor C receberá “um” e o outro “ze-
ro”, 
Nas linhas 16 e 17 foram utilizados operadores booleanos; 
Nas linhas 18 e 19, utilizou-se o operador & para realizar a concatenação (vi-
de SEMÂNTICA DA LINGUAGEM); 
Na linha 20, o bit menos significativo do vetor D será igual a “0” enquanto que 
o outro “1”; 
Na linha 21 o vetor W teria os seguintes valores após a operação: [1G00], 
onde G é o valor dele mesmo. 
Na linha 22, DATA será todo preenchido com 0’s. 
1 architecture topologia_arquitetura of teste is 
2 signal A, B, J : bit_vector(1 downto 0); 
3 signal E, F, G : bit; 
4 begin 
5 
6 process ( A, B, E, F, G, J) 
7 
8 variable C, D, H, Y : bit_vector(1 downto 0); 
9 variable W, Q : bit_vector(3 downto 0); 
10 variable Z : bit_vector(7 to 0); 
11 variable X : bit; 
12 variable DATA : bit_vector(31 downto 0); 
13 
14 begin 
15 C := “01”; 
16 X := E nand F; 
17 Y := H or J; 
18 Z(0 to 3) := C & D; 
19 Z(4 to 0) := (not A) & (A nor B); 
20 D := (‘1’, ‘0’); 
21 W := (2 downto 1 => G, 3 => ‘1’, others => ‘0’); 
22 DATA := (others => ‘0’); 
23 end process; 
24 end topologia_arquitetura; 
 
A função de uma variável dentro de um processo serve para intermediar valo-
res. 
OBS. 1: A variável (VARIABLE) só pode ser utilizada dentro do processo em que foi 
criada; 
OBS. 2: Ela poderá assumir os mesmo tipos descritos anteriormente; 
OBS. 3: Sempre que for passado algum parâmetro para uma variável, estes devem 
ser do mesmo tipo. 
OBS. 4: Note que a passagem de valores para uma variável é através de := e para 
pinos de saída a atribuição é feita com <= 
Outro exemplo: Note que a atualização da variável é automática. Este exem-
plo apresenta as etapas de simulação de um programa em VHDL, acompanhe cada 
bloco (horizontalmente). 
D <= 2; 
process (C, D) 
variable Av, Bv, Ev : integer := 0; 
begin 
Av := 2; 
Bv := Av + C; 
Av := D +1; 
Ev := Av * 2; 
A <= Av; 
B <= Bv; 
E <= Ev; 
end process; 
A = 1 
B = 1 
C = 1 
D = 2 
E = 1 
 
process (C, D) 
variable Av, Bv, Ev : integer :=0; 
begin 
Av := 2; 
Bv := Av + C; 
Av := D +1; 
Ev := Av * 2; 
A <= Av; 
B <= Bv; 
E <= Ev; 
end process; 
A = 1 Av = 0
B = 1 Bv = 0
C = 1 
D = 2 
E = 1 Ev = 0
 
process (C, D) 
variable Av, Bv, Ev : integer := 0; 
begin 
Av := 2; 
Bv := Av + C; 
Av := D +1; 
Ev := Av * 2; 
A <= Av; 
B <= Bv; 
E <= Ev; 
end process; 
A = 1 Av = 2
B = 1 Bv = 0 
C = 1 
D = 2 
E = 1 Ev = 0
process (C, D) 
variable Av, Bv, Ev : integer := 0; 
begin 
Av := 2; 
Bv := Av + C; 
Av := D +1; 
Ev := Av * 2; 
A <= Av; 
B <= Bv; 
E <= Ev; 
end process; 
A = 1 Av = 2 
B = 1 Bv = 3 
C = 1 
D = 2 
E = 1 Ev = 0 
process (C, D) 
variable Av, Bv, Ev : integer := 0; 
begin 
Av := 2; 
Bv := Av + C; 
Av := D +1; 
Ev := Av * 2; 
A <= Av; 
B <= Bv; 
E <= Ev; 
end process; 
A = 1 Av = 3
B = 1 Bv = 3 
C = 1 
D = 2 
E = 1 Ev = 0
process (C, D) 
variable Av, Bv, Ev : integer := 0; 
begin 
Av := 2; 
Bv := Av + C; 
Av := D +1; 
Ev := Av * 2; 
A <= Av; 
B <= Bv; 
E <= Ev; 
end process; 
A = 1 Av = 3 
B = 1 Bv = 3 
C = 1 
D = 2 
E = 1 Ev = 6
 
5.2 ATRIBUIÇÃO DE SINAIS 
 
A passagem de parâmetros para sinais se dá com o uso de <=. 
Interpretação do programa abaixo: 
Na linha 11, inicialmente A vale 0, após 20ns o valor de A é alterado para 1 e 
após 40ns, retorna a ser 0; 
Na linha 12 e linha 13, são operações lógicas; 
Na linha 14, o processo é semelhante ao da linha 11, entretanto os dados 
agora são do tipo inteiro. 
1 architecture teste of topologia_arquitetura is 
2 signal A, B, C : bit; 
3 signal D: integer; 
4 begin 
5 
6 process ( A, B, C, D) 
7 
8 variable L, M, N, Q bit; 
9 
10 begin 
11 A <= ‘0’, ‘1’ after 20ns, ‘0’ after 40ns 
12 B <= not L; 
13 C <= ((L andM) xor (N nand Q)); 
14 D <= 3, 5 after 20ns, 7 after 40ns, 9 after 60ns; 
16 
17 end process; 
18 end topologia_arquitetura; 
 
OBS. 1: Note que a atribuição a um sinal é feita através de <=; 
OBS. 2: Houve uma atribuição ao SIGNAL dentro do processo, isto não 
implica em dizer que em outro processo eu possa utilizá-lo atribuindo 
outro valor, ou seja, ele poderá ser utilizado por outro processo, mas 
não poderá receber uma atribuição de valores; 
OBS. 3: O signal deve ser passado ao processo, como mostra o exem-
plo. 
 
Outro exemplo: Neste exemplo, fica bem claro a diferença entre uma variável 
e um sinal, ou seja, todos os sinais só serão atualizados no final do processo, 
enquanto que a variável é atualizada sempre que usada. Novamente, acom-
panhe a simulação do programa passo-a-passo (horizontalmente). 
 
D <= 2; 
 
process (C, D) 
begin 
A <= 2; 
B <= A + C; 
A <= D +1; 
E <= A * 2; 
end process; 
 
 
A = 1 
B = 1 
C = 1 
D = 1 
E = 1 
 
 
process (C, D) 
begin 
A <= 2; 
B <= A + C; 
A <= D +1; 
E <= A * 2; 
end process; 
 
 
A = 1 
B = 1 
C = 1 
D = 2 
E = 1 
 
 
process (C, D) 
begin 
A <= 2; 
B <= A + C; 
A <= D +1; 
E <= A * 2; 
end process; 
 
 
A = 1 A <= 2 
B = 1 
C = 1 
D = 2 
E = 1 
 
 
process (C, D) 
begin 
A <= 2; 
B <= A + C; 
A <= D +1; 
E <= A * 2; 
end process; 
 
 
A = 1 A <= 2 
B = 1 B <= A + C
C = 1 
D = 2 
E = 1 
process (C, D) 
begin 
A <= 2; 
B <= A + C; 
A <= D +1; 
E <= A * 2; 
end process; 
 
 
A = 1 A <= D + 1 
B = 1 B <= A + C 
C = 1 
D = 2 
E = 1 
process (C, D) 
begin 
A <= 2; 
B <= A + C; 
A <= D +1; 
E <= A * 2; 
end process; 
 
 
A = 1 A <= D + 1 
B = 1 B <= A + C
C = 1 
D = 2 
E = 1 E <= A * 2; 
process (C, D) 
begin 
A <= 2; 
B <= A + C; 
A <= D +1; 
E <= A * 2; 
end process; 
 
 
A = 1 A <= 3 
B = 1 B <= 2 
C = 1 
D = 2 
E = 1 E <= 2;
process (C, D) 
begin 
A <= 2; 
B <= A + C; 
A <= D +1; 
E <= A * 2; 
end process; 
 
 
A = 3 
B = 2 e não 3 
C = 1 
D = 2 
E = 2 e não 6 
 
 
Qual a diferença entre o SIGNAL e a VARIABLE? 
1. O signal pode ser utilizado por qualquer processo pertencente aquela 
arquitetura, enquanto que a variável é interna ao processoe, 
2. A atualização da variável é imediata, enquanto que o signal só é atuali-
zado no final do processo. 
 
 
5.3 COMANDO WAIT 
 
Este comando tem a finalidade de causar uma suspensão do processo 
declarado ou procedimento. O comando wait pode ser utilizado de quatro 
formas diferentes, são elas: 
1 wait until <conditional>; wait until CLK’event and CLK = ‘1’; 
2 wait on <signal_list>; wait on a, b; 
3 wait for <time>; wait for 10ns; 
4 wait; wait; 
 
Interpretação da tabela acima: 
Na linha 1, o comando wait until implica que a operação está suspensa até 
(until) que haja uma transição (‘event) e (and) o CLK seja igual a 1, ou seja, 
está aguardando uma borda de subida; 
Na linha 2, o comando wait on suspende a operação até que a e b sejam i-
gual a 1; 
Na linha 3, suspende a operação por 10ns; 
Na linha 4, suspende a operação. 
 
5.4 COMANDO IF THEN ELSE 
 
Existem inúmeras formas de se utilizar if-then-else(elsif), abaixo se-
gue um quadro explicativo do if-then-else e ao lado dois exemplos simples. 
O próximo quadro apresenta um exemplo usando este comando e o comando 
anterior (wait). 
MODELO 
if condição_1 then 
 <comandos> 
elsif condição_2 then 
 <comandos> 
else 
<comandos> 
end if; 
exemplo 1: 
if ( A = ‘0’) then 
 B <= “00”; 
else 
 B <= “11”; 
end if; 
exemplo 2: 
if (CLK’event and CLK =’1’) then 
 FF <= ‘0’; 
elsif (CLK’event and CLK =’0’) then 
 FF <= ‘1’; 
elsif (J = ‘1’) and (K=’1’) then 
 FM <= ‘1’; 
end if; 
 
 
1 architecture topologia_arquitetura of teste is 
2 signal CLK : bit; 
3 signal SEL : bit_vector(1 downto 0); 
4 begin 
5 process 
6 begin 
7 if (SEL = “00”) then 
8 wait until CLK’event and CLK = ‘1’; 
9 elsif SEL = “01” then 
10 wait for 60ns; 
11 else 
12 null; 
13 end if; 
14 end process; 
15 end topologia_arquitetura; 
 
-----------------------------------------------------------------------------------------------------------
- 
-- * * * * * Comentários * * * * * 
-- O programa deve receber o nome de lab1.vhd 
-----------------------------------------------------------------------------------------------------------
- 
 
library IEEE; 
use ieee.std_logic_1164.all; 
 
entity lab1 is 
port ( controle : in bit; 
 parcela_1 : in bit_vector( 3 downto 0); 
 parcela_2 : in bit_vector( 3 downto 0); 
 soma_total : out bit_vector( 4 downto 0); 
 mult_total : out bit_vector( 7 downto 0) 
 ); 
end lab1; 
 
architecture logica of lab1 is 
 
begin 
 process ( controle, parcela_1, parcela_2) 
 begin 
 
 if (controle = ‘1’ ) then 
 soma_total <= parcela_1 + parcela_2; 
 else 
 mult_total <= parcela_1 * parcela_2; 
 end if; 
 
 end process; 
end logica; 
 
 
-----------------------------------------------------------------------------------------------------------
- 
-- * * * * * Comentários * * * * * 
-- O programa deve receber o nome de lab2.vhd 
-----------------------------------------------------------------------------------------------------------
- 
 
library IEEE; 
use ieee.std_logic_1164.all; 
 
entity lab2 is 
port ( controle : in bit; 
 parcela_1 : in bit_vector( 3 downto 0); 
 parcela_2 : in bit_vector( 3 downto 0); 
 soma_total : out bit_vector ( 4 downto 0); 
 mult_total : out bit_vector ( 7 downto 0); 
 operacao_and : out bit_vector ( 3 downto 0); 
 operacao_xor : out bit_vector ( 3 downto 0) 
 ); 
end lab2; 
 
architecture logica of lab2 is 
 
begin 
 
soma : process ( controle, parcela_1, parcela_2 ) 
 begin 
 
 if (controle = ‘1’ ) then 
 soma_total <= parcela_1 + parcela_2; 
 else 
 mult_total <= parcela_1 * parcela_2; 
 end if; 
 
 
 end process soma; 
 
operacao_logica : process ( controle, parcela_1, parcela_2 ) 
 begin 
 
 if ( controle = ‘1’ ) then 
 operacao_and <= parcela_1 and parcela_2; 
 else 
 operacao_xor <= parcela_1 xor parcela_2; 
 end if; 
 
 end process operacao_logica; 
end logica; 
 
-----------------------------------------------------------------------------------------------------------
- 
-- * * * * * Comentários * * * * * 
-- O programa deve receber o nome de lab3.vhd 
-----------------------------------------------------------------------------------------------------------
- 
 
library IEEE; 
use ieee.std_logic_1164.all; 
 
entity lab3 is 
port ( controle : in bit; 
 parcela_1 : in bit_vector( 3 downto 0); 
 parcela_2 : in bit_vector( 3 downto 0); 
 soma : out bit_vector( 4 downto 0); 
 multiplicacao : out bit_vector( 7 downto 0) 
 ); 
end lab3; 
 
architecture logica of lab3 is 
 
signal soma_total : bit_vector ( 4 downto 0); 
signal mult_total : bit_vector ( 7 downto 0); 
 
begin 
 process ( controle, parcela_1, parcela_2) 
 begin 
 
 if (controle = ‘1’ ) then 
 soma_total := parcela_1 + parcela_2; 
 else 
 mult_total := parcela_1 * parcela_2; 
 end if; 
 
 soma <= soma_total; 
 multiplicacao <= mult_total; 
 
 end process; 
 
end logica; 
 
5.5 COMANDO LOOP FOR - WHILE 
 
<label opcional>: for <parâmetros> in <valor_final> loop 
<seqüência de comandos> 
end loop <label opcional>; 
 
 
OBS.: O PARÂMETRO NÃO PODE TER SEU VALOR ALTERADO EM HIPÓ-
TESE ALGUMA DENTRO DO LOOP FOR 
 
 O exemplo abaixo, apresenta de que forma pode ser utilizado o co-
mando LOOP-FOR. 
 
1 process (A) 
2 
3 begin 
4 variable Z : bit_vector( 3 downto 0); 
5 A <= 2; 
6 Z := “0000”; 
7 for i in 0 to 3 loop 
8 if(A = i) then 
9 Z(i) := ‘1’; 
10 end if; 
11 end loop; 
12 end process; 
 
Note que este loop será realizado 4 vezes, independentemente da 
condição IF-THEN. O funcionamento deste programa baseia-se na atribuição 
de 1 na posição Z(2) quando i for igual a A, ou seja, 2.. 
 
 Usando o loop While 
 
1 2 
 
 Na figura 1, o processo aguarda até que clk seja igual a 1, enquanto 
isso ele fica parado. Quando o clk for igual a 1 (figura 2), então o processo 
entra no loop while. Este loop aguarda até que o Level seja igual 1, enquanto 
isso ele fica no loop while Level = ‘1’ loop => end loop (figura 3). 
 
3 4 
 
Quando Level for igual a 1, então ele incrementa o contador (figura 4). 
 
 
5.6 COMANDO NEXT 
 
O comando NEXT é utilizado para terminar prematuramente execução 
de uma iteração do tipo while, for ou um loop infinito. 
 
process(A) 
begin 
Z <= “0000”; 
for i in 0 to 3 loop 
next when A/=i; 
Z(I) <= ‘1’; 
end loop; 
end process; 
 
 
5.7 COMANDO EXIT 
 
exit => utilizado para terminar um while, for; 
exit <label_loop> => termina o laço e desloca para o label; 
exit <label_loop> when <condição> => termina o laço quando (when) condi- 
 ção é satisfeita; 
 
 
5.8 COMANDO CASE 
 
 O comando case seleciona a execução que ocorrerá de uma lista de 
alternativas. 
 
porta_programável : process (Mode, PrGIn1, PrGIn2) 
 begin 
 case Mode is 
when “000” => PrGOut <= PrGIn1 and PrGIn2; 
when “001” => PrGOut <= PrGIn1 or PrGIn2; 
when “010” => PrGOut <= PrGIn1 nand PrGIn2; 
when “011” => PrGOut <= PrGIn1 nor PrGIn2; 
when “100” => PrGOut <= not PrGIn1; 
when “101” => PrGOut <= not PrGIn2; 
when others => PrGOut <= ‘0’ 
end case; 
end process porta_programavel; 
porta_programável : process (Mode, PrGIn1, PrGIn2) 
 begin 
 case Mode is 
when “000” => PrGOut<= PrGIn1 and PrGIn2; 
when “001” => PrGOut <= PrGIn1 or PrGIn2; 
when “010” => PrGOut <= PrGIn1 nand PrGIn2; 
when “011” => PrGOut <= PrGIn1 nor PrGIn2; 
when “100” => PrGOut <= not PrGIn1; 
when “101” => PrGOut <= not PrGIn2; 
when others => PrGOut <= ‘0’ 
end case; 
end process porta_programavel; 
porta_programável : process (Mode, PrGIn1, PrGIn2) 
 begin 
 case Mode is 
when “000” => PrGOut <= PrGIn1 and PrGIn2; 
when “001” => PrGOut <= PrGIn1 or PrGIn2; 
when “010” => PrGOut <= PrGIn1 nand PrGIn2; 
when “011” => PrGOut <= PrGIn1 nor PrGIn2; 
when “100” => PrGOut <= not PrGIn1; 
when “101” => PrGOut <= not PrGIn2; 
when others => PrGOut <= ‘0’ 
end case; 
end process porta_programavel; 
 
5.9 COMANDO NULL 
 
 O comando null é frequentemente utilizado com o comando case, a 
última opção do case ficaria com null. Similar ao null da Linguagem C. 
 
 
5.10 COMANDO RETURN 
 
 Utilizado em funções, tem a finalidade de retornar um valor. 
 
6 ESPECIFICANDO A ESTRUTURA DE UM SISTE-
MA 
 
 Neste capítulo será apresentado uma outra forma de detalhamento de 
um sistema, visando obter um sistema compacto, sem a necessidade de re-
petição de processos. Para isso, é necessário o uso de component e port 
map. 
 O component é exatamente a descrição de um componente, ou seja, 
define-se anteriormente sua topologia, permitindo assim o uso repetidas ve-
zes. 
 O port map é um mapeamento deste componente em um sistema 
maior. 
 
EX.: Suponha que você tenha um sistema composto por cinco compo-
nentes, mas de dois tipos diferentes, por exemplo 7408 e 7404. A Figura 
6.1, apresenta esta situação, porém ao invés de um CI completo, vamos 
supor que tenha somente uma porta lógica. 
 
 
 
 
FIGURA 6.1: Exemplo de um sistema 
 
Note que a placa acima possui cinco blocos internos, que são representados 
por dois componentes. O primeiro passo é modelar estes componentes, o 
programa 1 apresenta esta modelagem e o programa 2 modela o segundo 
componente. 
Já o programa 3, modela os cinco blocos dentro da placa. Note que a instru-
ção 
 
component componente_and 
 port( a: in bit; b : in bit; c : out bit); 
end component; 
 
está chamando o componente and anteriormente modelado. Já a instrução 
 
 and1 : componente_and port map (a => in1, b => in2, c => s1); 
 
mapeia o bloco (componente and) na placa. Todos os blocos precisam ser 
nomeados na placa dentro da placa. 
 
Programa 1: descreve o componente inversor; 
Programa 2: descreve o componente and; 
Programa 3: descreve um sistema utilizando estes dois componentes; 
 
 
 
Programa 1 Programa 2 
--------------------------------------------------------- 
-- Arquivo componente_inv.vhd 
-- Modelo do inversor 
--------------------------------------------------------- 
 
library IEEE; 
use IEEE.std_logic_1164.all; 
 
entity componente_inv is 
port( 
 x : in bit; 
 y : out bit 
 ); 
end componente_inv; 
 
architecture arquitetura_inv of componen-
te_inv is 
 
 begin 
 y <= not x; 
end arquitetura_inv; 
 
--------------------------------------------------------- 
-- Arquivo componente_and.vhd 
-- Modelo da porta AND 
--------------------------------------------------------- 
 
library IEEE; 
use IEEE.std_logic_1164.all; 
 
entity componente_and is 
port( 
 a : in bit; 
 b : in bit; 
 c : out bit 
 ); 
end componente_and; 
 
architecture arquitetura_and of com-
ponete_and is 
 
 begin 
 c <= a and b; 
end arquitetura_and; 
 
 
Programa 3 
------------------------------------------------------ 
-- Arquivo componente_sistema.vhd 
-- Modelo da porta AND 
------------------------------------------------------ 
 
library IEEE; 
use IEEE.std_logic_1164.all; 
 
entity componente_sistema is 
port( 
 in1 : in bit; 
 in2 : in bit; 
 in3 : in bit; 
 in4 : in bit; 
 out1 : out bit 
 ); 
end componente_sistema; 
 
architecture arquitetura_sistema of componente_sistema is 
 
component componente_and 
 port( a: in bit; b : in bit; c : out bit); 
end component; 
 
component componente_inv 
 port( x: in bit; y : out bit); 
end component; 
 
signal s1, s2, s3, s4 : bit; 
 
 begin 
 and1 : componente_and port map (a => in1, b => in2, c => s1); 
 and2 : componente_and port map (a => in3, b => in4, c => s2); 
 and3 : componente_and port map (a => s3, b => s4, c => out1); 
 inv1 : componente_inv port map (x => s1, y => s3); 
 inv2 : componente_inv port map (x => s2, y => s4); 
end arquitetura_sistema; 
 
 
7 ALGUNS EXEMPLOS DE IMPLEMENTAÇÕES EM 
VHDL 
 
 
 A seguir são apresentado três exemplos utilizando a Linguagem de 
Descrição de Hardware (VHDL). 
 O primeiro deles é a implementação de uma ULA (Unidade Lógica A-
ritmética). A estrutura é igual aos exemplos anteriores, na entity foi declarado 
4 sinais: controle, operando_a, operando_b e saída. Então, a interface do sis-
tema é definida por estes pinos de I/O . 
 Logo a seguir, está estruturada a arquitetura da ULA, de forma que a 
palavra de controle seleciona o tipo de operação que será realizada, para is-
so foi utilizado if-then-else. 
 A Figura 7.1, apresenta a simulação feita no MAXPLUX II. Note que a 
saída está atrasada em relação ao sinal de controle, justificando o atraso ine-
rente as portas lógicas. 
 
---------------------------------------------------------------- 
-- Implementação de uma ULA. 
---------------------------------------------------------------- 
library IEEE; 
use IEEE.std_logic_1164.all; 
 
entity ula is 
port( 
 controle : in bit_vector(2 downto 0); 
 operando_a : in bit_vector(7 downto 0); 
 operando_b : in bit_vector(7 downto 0); 
 saida : out bit_vector(7 downto 0) 
 ); 
end ula; 
 
architecture estrutura of ula is 
 
begin 
 
 process (controle, operando_a, operando_b) 
 begin 
 if (controle = "000") then 
 saida <= operando_a and operando_b; 
 elsif (controle = "001") then 
 saida <= operando_a or operando_b; 
 elsif (controle = "010") then 
 saida <= operando_a xor operando_b; 
 elsif (controle = "011") then 
 saida <= operando_a nor operando_b; 
 elsif (controle = "100") then 
 saida <= not(operando_a); 
 elsif (controle = "101") then 
 saida <= not(operando_b); 
 elsif (controle = "110") then 
 saida <= operando_a nand operando_b; 
 elsif (controle = "111") then 
 saida <= not(operando_a xor operando_b); 
 end if; 
 end process; 
end estrutura; 
 
 
FIGURA 7.1: Simulação da ULA. 
O próximo exemplo apresenta a implementação de um decodificador 3x8. Como no e-
xemplo anterior, a estrutura é a mesma, na entity são declarados os pinos de entrada e 
saída. Neste exemplo, utilizou-se o comando case para a implementação do decodifica-
dor. A Figura 7.2 apresenta a simulação do decodificador 3x8. 
 
--------------------------------------------------------------------- 
-- Implementação de um decodificador 3x8. 
--------------------------------------------------------------------- 
 
 
library IEEE; 
use IEEE.std_logic_1164.all; 
 
entity decodificador is 
port( 
 controle : in bit_vector(2 downto 0); 
 saida : out bit_vector(7 downto 0) 
 ); 
end decodificador; 
 
architecture estrutura of decodificador is 
 begin 
 process (controle) 
 begin 
 case controle is 
 when "000" => saida <= "00000001"; 
 when "001" => saida <= "00000010"; 
 when "010" => saida <= "00000100"; 
 when "011" => saida <= "00001000"; 
 when "100" => saida <= "00010000"; 
 when "101" => saida <= "00100000"; 
 when "110" => saida <= "01000000"; 
 when "111" => saida <= "10000000"; 
 end case; 
 end process;end estrutura; 
 
 
 
 
 
FIGURA 7.2: Simulação do decodificador 
Dispositvos Programáveis (FPGA) e Linguagem de Descrição de Hardware (VHDL) 
 
 
 Eng. Anderson Royes Terroso http://www.ee.pucrs.br/~terroso 41
Dispositvos Programáveis (FPGA) e Linguagem de Descrição de Hardware (VHDL) 
O próximo exemplo é bem simples, apresenta a implementação de um registrador 
de 12 bits, note que o processo só enviará os dados da entrada para a saída 
quando o clock for nível lógico um. A Figura 7.3, apresenta a simulação deste 
programa. 
 
----------------------------------------------------------------------- 
-- Implementação de um registrador de 12 bits. 
----------------------------------------------------------------------- 
 
library IEEE; 
use IEEE.std_logic_1164.all; 
 
entity reg12 is 
 port( 
 d : in bit_vector(11 downto 0); 
 clk : in bit; 
 q : out bit_vector(11 downto 0)); 
end reg12; 
 
architecture estrutura of reg12 is 
begin 
 process 
 begin 
 wait until clk = '1'; 
 q <= d; 
 end process; 
end estrutura; 
 
 
 
 
FIGURA 7.3: Simulação do registrador de 12 bits. 
 Eng. Anderson Royes Terroso http://www.ee.pucrs.br/~terroso 42
Dispositvos Programáveis (FPGA) e Linguagem de Descrição de Hardware (VHDL) 
8 BIBLIOGRAFIA 
 
 
Bostock, Geoff, FPGAs and programmable LSI : a designer's handbook. 
Oxford : Butterworth-Heinemann, 1996. 216p. 
 
Hachtel, Gary D. ; Somenzi, Fabio, Logic synthesis and verification algori-
thms. Boston : Kluwer Academic, 1996. 564p. 
 
Brown, Stephen D. et al. Field-programmable gate arrays. Boston : Kluwer 
Academic, 1992. 206p. 
 
Trimberger, Stephen M. (Ed). Field-programmable gate array technology. 
Boston : Kluwer Academic, 1994. 258p. 
 
Grünbacher, Herbert ; Hartenstein, Reiner W. (Ed.).Field-programmable gate 
arrays : architectures and tools for rapid prototyping. Berlin : Springer, 1993. 
220p. 
 
IEEE Workshop on FPGAs for Custom Computing Machines (1993 : 
Napa) Proceedings. ; Buell, Duncan A. ; Pocek, Kenneth L. (Ed.).Los Alami-
tos, CA : IEEE Computer Society Press, 1993. 212p. 
 
CHANG, K. C., Digital Design and Modeling with VHDL and Synthesis.IEEE 
Computer Society Press, 1997 
 
AIRIAU, R. et all. VHDL du langage à la modélisation. Presses Polytechni-
ques Universitaires Romandes, 1990. 
 
MAX+PLUS II & VHDL, Customer Training - ALTERA. 
 
MAX+PLUS II, Programmable Logic Development System - Getting Started. 
ALTERA, Version 6.0, 1995. 
 
VHDL Reference Guide, ACTIVE-VHDL Series Book1. ALDEC, 1998. 
 
 
INTERNET: 
 
ftp://ftp.cs.adelaide.edu.au/pub/VHDL 
http://www.altera.com 
http://www.aldec.com 
 
 Eng. Anderson Royes Terroso http://www.ee.pucrs.br/~terroso 43
	1 INTRODUÇÃO
	1.1 DISPOSITIVOS LÓGICOS PROGRAMÁVEIS FPGA
	1.1.2 DEFINIÇÃO DE BLOCOS LÓGICOS:
	1.1.3 DEFINIÇÃO DE ROTEAMENTO
	1.1.3 DEFINIÇÃO DE IOB´S
	1.2 CIRCUITOS PROGRAMÁVEIS EPLD
	2 LINGUAGEM DE DESCRIÇÃO DE HARDWARE (VHDL)
	2.1 O QUE É VHDL?
	2.2 O QUE SIGNIFICA VHDL?
	2.3 O QUE É UMA LINGUAGEM DE DESCRIÇÃO DE HARDWARE?
	2.4 BREVE HISTÓRICO
	2.4.1 LINHA CRONOLÓGICA
	2.5 VANTAGENS E DESVANTAGENS DE SE UTILIZAR VHDL
	3 COMPONENTES DE UM PROJETO VHDL
	3.1 PACKAGE (PACOTES)
	3.2 ENTITY (ENTIDADE)
	3.2.1 TIPO DE PORTAS
	EX.:
	3.2.2 TIPOS DE SINAIS
	3.3 ARCHITECTURE (ARQUITETURA)
	3.3.1 ARQUITETURA SIMPLES
	3.3.2 ARQUITETURA CONCORRENTE
	3.4 CONFIGURATION (CONFIGURAÇÃO)
	4 SEMÂNTICA DA LINGUAGEM VHDL
	4.1 ELEMENTOS LÉXICOS
	4.1.1 COMENTÁRIOS
	4.1.2 IDENTIFICADORES
	4.1.3 TIPOS DE DADOS NÃO LÓGICOS
	4.1.4 EXPRESSÕES E OPERADORES
	4.1.4.1 OPERADORES LÓGICOS
	4.1.4.2 OPERADORES NUMÉRICOS
	4.1.4.3 OPERADORES RELACIONAIS
	4.1.4.4 OPERADORES DE DESLOCAMENTO
	4.1.4.5 OPERADOR DE CONCATENAÇÃO
	5 COMANDOS SEQÜENCIAIS
	5.1 ATRIBUIÇÃO DE VARIÁVEIS
	5.2 ATRIBUIÇÃO DE SINAIS
	5.3 COMANDO WAIT
	5.4 COMANDO IF THEN ELSE
	5.5 COMANDO LOOP FOR - WHILE
	5.6 COMANDO NEXT
	5.7 COMANDO EXIT
	5.8 COMANDO CASE
	5.9 COMANDO NULL
	5.10 COMANDO RETURN
	6 ESPECIFICANDO A ESTRUTURA DE UM SISTEMA
	7 ALGUNS EXEMPLOS DE IMPLEMENTAÇÕES EM VHDL
	8 BIBLIOGRAFIA