FPGA e VHDL: Conceitos e Comandos

Prévia do material em texto

DISPOSITIVO lógicos
PROGRAMÁ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................................................................................... 8
2 LINGUAGEM DE DESCRIÇÃO DE HARDWARE (VHDL) .................................................... 9
2.1 O QUE É VHDL? .................................................................................................................... 9
2.2 O QUE SIGNIFICA VHDL?.................................................................................................... 9
2.3 O QUE É UMA LINGUAGEM DE DESCRIÇÃO DE HARDWARE?..................................... 9
2.4 BREVE HISTÓRICO............................................................................................................... 9
2.4.1 LINHA CRONOLÓGICA................................................................................................ 11
2.5 VANTAGENS E DESVANTAGENS DE SE UTILIZAR VHDL........................................... 12
3 COMPONENTES DE UM PROJETO VHDL........................................................................... 13
3.1 PACKAGE (PACOTES)........................................................................................................ 16
3.2 ENTITY (ENTIDADE) ......................................................................................................... 17
3.2.1 TIPO DE PORTAS ......................................................................................................... 17
3.2.2 TIPOS DE SINAIS.......................................................................................................... 17
3.3 ARCHITECTURE (ARQUITETURA)................................................................................... 18
3.3.1 ARQUITETURA SIMPLES ............................................................................................. 18
3.3.2 ARQUITETURA CONCORRENTE................................................................................. 19
3.4 CONFIGURATION (CONFIGURAÇÃO).............................................................................. 21
4 SEMÂNTICA DA LINGUAGEM VHDL .................................................................................. 22
4.1 ELEMENTOS LÉXICOS ...................................................................................................... 22
4.1.1 COMENTÁRIOS ............................................................................................................ 22
4.1.2 IDENTIFICADORES...................................................................................................... 22
4.1.3 TIPOS DE DADOS NÃO LÓGICOS ............................................................................... 23
4.1.4 EXPRESSÕES E OPERADORES ................................................................................... 24
5 COMANDOS SEQÜENCIAIS.................................................................................................... 25
5.1 ATRIBUIÇÃO DE VARIÁVEIS ........................................................................................... 25
5.2 ATRIBUIÇÃO DE SINAIS.................................................................................................... 27
5.3 COMANDO WAIT................................................................................................................ 29
5.4 COMANDO IF THEN ELSE................................................................................................. 29
5.5 COMANDO LOOP FOR - WHILE ........................................................................................ 34
5.6 COMANDO NEXT ............................................................................................................... 35
5.7 COMANDO EXIT................................................................................................................. 35
5.8 COMANDO CASE................................................................................................................ 36
5.9 COMANDO NULL................................................................................................................ 37
5.10 COMANDO RETURN......................................................................................................... 37
6 ESPECIFICANDO A ESTRUTURA DE UM SISTEMA .......................................................... 38
7 ALGUNS EXEMPLOS DE IMPLEMENTAÇÕES EM VHDL................................................ 41
8 BIBLIOGRAFIA......................................................................................................................... 46
1 INTRODUÇÃO
O rápido desenvolvimento dos recursos de concepção de circuitos
integrados, 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
indica que a configuração do circuito pode ser feita pelo usuário final sem a
necessidade da utilização de recursos de foundries. Na Figura 1.1, está
demonstrado 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ógico 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 para as 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
transistores 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 blocosló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 projeto 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
longos 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
sinal 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
transistores EPROM são usados para forçar valores nas entradas dos blocos
lógicos, 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
comportamento de um circuito ou componente digital.
2.2 O QUE SIGNIFICA VHDL?
Very High Speed Integrated Circuit
Hardware
Description
Language
Linguagem de Descrição de Hardware com ênfase em Circuitos
Integrados de altíssima velocidade.
2.3 O QUE É UMA LINGUAGEM DE DESCRIÇÃO DE
HARDWARE?
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á
executado em um software chamado simulador. Um sistema descrito em
linguagem 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
circuitos 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
trocar 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
hardware, 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ântica 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
Instruments.
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
desenvolver 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
menor;
• 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 (
 
 );
END exemplo;
ENTITY
(PINOS DE I/O)
ARCHITECTURE teste OF exemplo IS
BEGIN
PROCESS( )
 BEGIN
 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
end process CI_Y;
CI_Y : process( a )
begin
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 e/ou
USE .all
OBS. 1: .all significa que todos os elementos da bibliotecas devem ser
utilizados, caso não seja acrescentado .all deve-se especificar os
elementos 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 is
port (
 sinal_controle : in ;
parcela_1 : in ;
parcela_2: out 
 );
end ;
3.2.2 TIPOS DE SINAIS
 => 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 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
determinado tipo.
range to 
range downto 
• Array: em VHDL um array é definido como uma coleção de elementos
todos 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 (), maior ou igual (>=).
4.1.4.4 OPERADORES DE DESLOCAMENTO
Operadores Exemplo
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: 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
valores.
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 ; wait until CLK’event and CLK = ‘1’;
2 wait on ; wait on a, b;
3 wait for ; 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
igual 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
segue 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
 
elsif condição_2 then
 
else
end if;
exemplo 1:
if ( A = ‘0’) then
 B* * * * * 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 : for in loop
end loop ;
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
comando LOOP-FOR.
1 process (A)
2
3 begin
4 variable Z : bit_vector( 3 downto 0);
5 A 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 utilizado para terminar um while, for;
exit => termina o laço e desloca para o label;
exit when => 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 PrGOut PrGOut PrGOut PrGOut PrGOut PrGOut PrGOut PrGOut PrGOut PrGOut PrGOut PrGOut PrGOut PrGOut PrGOut PrGOut PrGOut PrGOut PrGOut PrGOut 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
componente_inv is
begin
y-- 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
Aritmé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 sistema é 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
isso 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
inerente 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 saida saida saida saida saida saida saida saida