MINICURSO: TÓPICOS EM VHDL

Prof. Leonardo Augusto Casillo

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.
O que significa Linguagem de
Descrição de Hardware (HDL)?
Uma linguagem de descrição de hardware descreve o que um
sistema faz e como;

Um sistema descrito em linguagem de hardware pode ser

implementado em um dispositivo programável FPGA (Field
Programmable Gate Array) ou um dispositivo ASIC (Aplication
Specific Integrated Circuit), permitindo o uso em campo do
sistema;

Existem dezenas de HDLs:

◦ AHDL, VERILOG, Handel-C, SDL, ISP, ABEL …
Características do VHDL
– Linguagem concorrente. Todos os comandos ocorrem
simultaneamente (com exceção de processos)

– Permite, através de simulação, verificar o comportamento do

sistema digital;

– Permite descrever hardware em diversos níveis de abstração, por

exemplo:
 Algorítmico ou comportamental.
 Transferência entre registradores (RTL).

Hoje utilizada para SIMULAÇÃO e SÍNTESE

Características do VHDL
 VHDL é análogo a uma linguagem de programação

 VHDL provê mecanismos para modelar a concorrência e

sincronização que ocorrem a nível físico no hardware

 Projetar um sistema em VHDL é geralmente mais difícil que

escrever um programa para fazer a mesma coisa utilizando
uma linguagem de programação como C

 O código VHDL é executado em um simulador

◦ Não há um “executável”
Características do VHDL
Considerações importantes

1. VHDL NÃO É uma linguagem de

programação

2. O VHDL deve ser descrito após a

arquitetura, e não a arquitetura após o
VHDL.
Vantagens e Desvantagens do VHDL
• Vantagens
– time-to-market: Se há dez anos atrás um produto demorava 6 meses para ser desenvolvido,
mas permanecia no mercado por 2 anos, hoje um produto não permanece mais de 18 meses,
logo o seu desenvolvimento deve levar bem menos tempo.
– menor ciclo e custo de desenvolvimento: devido à eliminação de geração, manutenção de
esquemáticos e pela diminuição de erros de desenvolvimento pelo uso de simulação nos ciclos
iniciais do projeto;
– aumento de qualidade no desenvolvimento: VHDL facilita o rápido experimento com
diferentes arquiteturas e técnicas de implementação, e pela capacidade das ferramentas de
síntese otimizarem um projeto tanto para área mínima quanto para velocidade máxima; •
– evolução da tecnologia – Novos dispositivos surgem com mais capacidade e mais recursos
internos;
– gerenciamento do projeto – Projetos em VHDL facilitam a estruturação de componentes (top-
down), facilitam a documentação e são necessárias menos pessoas para desenvolver e verificar,
sendo também mais simples modificar o projeto;
– independente de tecnologia e fabricante: porém sabe-se que na prática não é independente de
ferramenta de síntese e de simulação.
Vantagens e Desvantagens do VHDL
• Desvantagens
– Mudança de cultura;
– Aprendizado e treinamento;
– Escolha de uma ferramenta de desenvolvimento;
– Circuito é menos otimizado que esquemático;
– Ferramentas de síntese ineficientes.
Conceitos necessários
– Algoritmos;
– Conceitos de linguagem de programação (para descrição
comportamental);
– Circuitos Digitais;
– Arquitetura de computadores;

Para descrições mais complexas:

– Linguagem Assembly;
– Microprocessadores;
– Sistemas embarcados.
Breve Histórico
- final de 1960: primeiras Linguagem de Hardware;
- 1973: projeto CONLAN (CONsensus LANguage);
- 1983: relatório final do CONLAN e a Linguagem ADA;
- 1983: DoD inicia programa VHSIC (participação da IBM,
Intermetrics e Texas Instruments;
- 1986: a Intermetrics desenvolve compilador e simulador, 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;
- 1992: modificações propostas foram avaliadas e votadas;
- 1993: um novo padrão é publicado, chamado VHDL-93;
- 1997: publicado o manual de referência da linguagem.
Ciclo de Projeto:
– Especificação: determinar requisitos e funcionalidade do
projeto.

– Codificação: descrever em VHDL todo o projeto, segundo

padrões de sintaxe.

– Simulação do Código-Fonte: simular o código em

ferramenta confiável a fim de verificar preliminarmente
cumprimento da especificação;
Ciclo de Projeto:
– Síntese, otimização e Fitting:

Síntese: compilação de um código VHDL para uma

descrição abstrata.

Otimização: seleção da melhor solução de

implementação para uma dada tecnologia.

Fitting: lógica sintetizada e otimizada mapeada nos

recursos oferecidos pela tecnologia.
Ciclo de Projeto:

– Simulação do modelo: resultados mais apurados de

comportamento e timing.

– Geração: configuração das lógicas programáveis ou de

fabricação de ASICs.
Etapas de Projeto:
Etapas de Projeto:
Tipos de circuitos:

– Circuitos Combinacionais: circuitos que dependem apenas da

combinação das variáveis de entrada
– Circuitos Sequenciais: circuitos que dependem da variável
tempo (sincronização, realimentação, etc)
– Circuitos Hardwired: circuito projetado para realizar uma
tarefa específica, sem a necessidade de programação
– Processadores: sistemas de uso geral, compostos por unidades
operativas e de controle, com conjunto de instruções específico.
– Sistemas embarcados: sistemas para uso específico com
restrições de potência e aplicações de tempo real.
PARTE I : ELEMENTOS
BÁSICOS
Componentes de um projeto
PACKAGE
ENTITY
ARCHITECTURE
CONFIGURATION
– Package (Pacote): constantes, bibliotecas;
– Entity (Entidade): pinos de entrada e saída;
– Architecture (Arquitetura): implementações do projeto;
– Configuration (Configuração): define as arquiteturas que
serão utilizadas.
Componentes de um projeto
LIBRARY IEEE;
USE IEEE.STD_LOGIC_1164.all; PACKAGE (BIBLIOTECAS)
USE IEEE.STD_LOGIC_UNSIGNED.all;

ENTITY exemplo IS
PORT (
<descrição dos pinos de I/O> ENTITY (PINOS DE I/O)
);
END exemplo;
ARCHITECTURE teste OF exemplo IS
BEGIN ARCHITECTURE
... (ARQUITETURA)
END teste;
 Entity (Entidade)
Abstração que descreve um sistema, uma placa, um chip, uma
função ou uma porta lógica.
Etapa “caixa preta”, onde é necessário apenas descrever quem são as
entradas e saídas do circuito (interface com meio externo)
Entity <nome_da_entidade> is
port (
entrada_1: in <tipo>;
entrada_2: in <tipo>;
saída_1 : out <tipo>;
...
);
end <nome_da_entidade>;
 Entity (Entidade)
Parâmetros:
- GENERIC: passagem de informações estáticas
- PORT: correspondem ao pinos de entrada e saída.

Modos de operação:
IN: porta de entrada;
OUT: porta de saída (não podem ser usados
como entradas, nem seus valores utilizados na
lógica interna);
INOUT: porta de entrada e saída;
BUFFER: saída com possibilidade de
realimentação.
 ARCHITECTURE
(ARQUITETURA)
PROCESSOS

N
N

ENTITY
(ENTIDADE)
PINOS DE I/O
 Entity (Entidade)
Tipos mais utilizados:
bit Assume valores „0‟ ou „1‟.
x: in bit;
bit_vector Vetor de bits.
x: in bit_vector(7 downto 0);
x: in bit_vector(0 to 7);
std_logic* x: in std_logic;
std_logic_vector x: in std_logic_vector(7 downto 0);
x: in std_logic_vector(0 to 7);
boolean Assume valores TRUE ou FALSE
 Entity (Entidade)
STD_LOGIC:
• Definida pela biblioteca IEEE:
• use ieee.std_logic_1164.all;
• Pode assumir nove valores:
‘U’: não inicializada ‘Z’: alta impedância
‘X’: desconhecida ‘W’: desconhecida fraca
‘0’: valor ‘0’ ‘L’: ‘0’ fraca (Low)
‘1’: valor ‘1’ ‘H”: ‘1’ fraca (High)
‘-’: Don’t care.
 Entity (Entidade)
Circuito exemplo:

 A extensão de um arquivo em VHDL é ”.vhd”. O nome do

arquivo DEVE ser o mesmo nome da entidade. No caso
acima, o arquivo deve ser salvo com o nome exemplo1.vhd.
Architecture (Arquitetura)
 Especificação do funcionamento do circuito

 Formada por:
◦ Declarações: sinais, constantes, componentes, subprogramas
◦ Comandos: blocos, atribuições a sinais, chamadas a subprogramas,
instanciação de componentes, processos

 Uma entidade pode ter várias arquiteturas: VHDL provê meios de

especificar qual arquitetura se deseja utilizar
Architecture (Arquitetura)
Architecture (Arquitetura)
Arquitetura do circuito exemplo:
Architecture (Arquitetura)
Circuito exemplo completo em VHDL:
Package (Pacotes)
Os pacotes (bibliotecas) contém uma coleção de
elementos incluindo descrição do tipos de dados

Analogia com C/C++: #include <library.h>.

Para incluir uma biblioteca no código VHDL (início do

código):

LIBRARY <nome_da_biblioteca> e/ou

USE <nome_da_biblioteca>.all
Package (Pacotes)
Permite a reutilização de um código já escrito.

Armazena:
 Declaração de tipos
 Declaração de constantes
 Declaração de subprogramas
 Declaração de mnemônicos

Pode ser dividido em parte de declaração e parte de corpo

(opcional).
Package (Pacotes)
É necessário o uso de packages quando se deseja utilizar algo não
definido pela biblioteca VHDL padrão. A área de packages deve
vir antes da área de entidade.

library IEEE;
use ieee.std_logic_1164.all;
use ieee.std_logic_arith.all;

Biblioteca do usuário (default): work.

Package (Pacotes)
Exemplo de Packages:

package <biblioteca> is
function soma(a,b: bit) return bit;
subtype dado is bit_vector(32 downto 0);
constant mascara : bit_vector(3 donwto 0) := “1100”;
alias terceiro_bit: bit is dado(3) );
end <biblioteca>.
PARTE II : SEMÂNTICA
 Usados como referência a todos os objetos
declarados

 Regras
◦ Primeiro caractere deve ser uma LETRA
◦ Não é CASE-SENSITIVE
 Ex: Teste = teste = TESTE
◦ Existem palavras reservadas
 Ex: and, mux

36
 São permitidos apenas letras, números e underscore ( _ )

 Último caractere não pode ser underscore;

o Ex: Teste_

 Não são permitidos 2 underscores em seqüência;

o Ex: Teste__projeto

 Nomes com underscore são diferentes de nome sem underscore.

o Ex: teste_projeto ≠ testeprojeto
 Valores de dados específicos usados como parâmetros de objetos
ou dentro de expressões.

 Não representam tipos específicos:

◦ Ex: '1' pode representar um bit ou um caractere.

 São válidos dependendo do tipo:

◦ Ex: '$' é válido como um caractere mas não como bit.
 Podem ser representados pelas seguintes categorias:

◦ Character Literals: um caracter ASCII („a‟, „z‟).

◦ String Literals: seqüência de caracteres ASCII (“texto”)

◦ Bit String Literals: formas especiais de string literals para representar

valores das bases binária, octal e hexadecimal.
 B”100100”
 O”446”
 X”A0F4B51”
 Válidos para bit_vector e std_logic_vector
◦ Numeric Literals: Integer Literals (Ex: 1) e Real Literals (Ex: 1.1)
 Números reais não são sintetizáveis.

◦ Based Literals: idêntico a numeric literals, mas utilizando bases

binária, octal e hexadecimal.
 Ex: 2#101#, 16#FC9#, 2#1.0#E10#

◦ Physical Literals: grandeza física. Contém parte numérica e unidade.

 Podem representar tempo, velocidade, distância etc
 Não são sintetizáveis (tempo é simulável)
 Ex: 300 s, 40 m
 VHDL é uma linguagem fortemente tipada;

 Pouca conversão é feita automaticamente;

 Cada tipo tem um conjunto de operações válidas;

 Cada tipo tem um conjunto de valores definidos;

 Os tipos podem ser estendidos pelo usuário.

41
 São divididos em 4 classes:

◦ Tipos escalares (representam um único valor);

◦ Tipos compostos (representam uma coleção de valores);

◦ *Tipos de acessos (similares a ponteiros);

◦ *Tipos de arquivo (referencia objetos que contém uma seqüência de

valores).

* Não são sintetizáveis

 TIPOS

Scalar
numéricos Composite
discretos escalar
composto
Floating
Enumerated Integer Physical Array
enumerado point físico vetor

bit boolean character integer real time bit_vector string

booleano caracter inteiro tempo

 Tipos enumerados: tipos já definidos pela norma

◦ Bit
◦ Boolean
◦ Integer
◦ Real
◦ Physical
◦ STD_LOGIC
TIPO PREDEFINIDO VALOR EXEMPLO
BIT um, zero 1, 0
BOOLEAN Verdadeiro, falso TRUE, FALSE
CHARACTER Caracteres ASCII a, b, c, A, B, C, ?, (
INTEGER -231 -1 ≤ x ≤ 231 -1 123, 8#173#, 16#7B#,
2#11_11_011#
NATURAL 0 ≤ X ≤ 231 -1 123, 8#173#, 16#7B#,
2#11_11_011#
POSITIVE 1 ≤ X ≤ 231 -1
REAL -3.65*1047 ≤ x ≤ +3.65*1047 1.23, 1.23E+2,
16#7.B#E+1
TIME ps=103 fs ns=103 ps us=103 ns 1 us, 100 ps, 1 fs
ms=103 us sec=103 ms
min=60sec hr=60min

“NATURAL” e “POSITIVE” são subtipos de “INTEGER”

45
 Tipos enumerados: permite criar novos tipos.

◦ Útil para máquina de estados (FSM)

 Ex: type estado is (inicio, espera, calculo, final);

◦ Os tipos criados podem ser declarados

 Ex: signal estado_atual : estado

◦ Outros Exemplos (user defined types):

 type dedos is range 0 to 10;
 type pos_neg is range -1 to 1;
 ARRAY: Coleção de elementos do mesmo tipo

 Ordem crescente ou decrescente

◦ type word is array (7 downto 0) of bit;
◦ type word is array (0 to 7) of bit;

 Indexação por parêntesis

◦ signal palavra: word := “01111111”;
◦ signal aux: bit;
◦ aux <= palavra(0);
TIPO PREDEFINIDO VALOR EXEMPLO
BIT_VECTOR 1, 0 “1010”, B”10_10”, O”12”,
X”A”
STRING Tipo character “texto”, ““incluindo_aspas””

Signal a: Bit_Vector (0 TO 7) := “10110011”

1 0 1 1 0 0 1 1
a(0) a(1) a(2) a(3) a(4) a(5) a(6) a(7)

Constant c: String (1 TO 9) := “Alo mundo”

A l o m u n d o
c(1) c(2) c(3) c(4) c(5) c(6) c(7) c(8) c(9)

48
a(4) <= b(4); -- 1 elemento <= 1 elemento
a(0 to 3) <= b(2 DOWNTO 0); -- parte do vetor <= parte do vetor
b(4) <= „0‟; -- 1 elemento <= 1 valor
b(2 DOWNTO 0) <= “0010”; -- parte do vetor <= valor
c <= („0‟, „0‟, „0‟, „1‟, „0‟); -- valor 00010 agregado notação
-- posicional
d <= (1 => „1‟, OTHERS => „0‟); -- valor 00010 agregado notação
-- posicional

 OTHERS: forma genérica de se atribuir valores aos demais bits não

especificados anteriormente

49
 Records: coleção de elementos de tipos diferentes.

◦ Semelhante a struct em C
◦ Exemplos:

type instruction is record

Mnemonico: string;
Codigo: bit_vector(3 downto 0);
Ciclos: integer;
end record;

signal instrucao : instruction;

instrucao.Mnemonico : “registrador”
instrucao.codigo : “0001”
Instrucao.ciclos : „3‟
 Realizam operações sobre objetos do mesmo tipo;

 Operações lógicas: and, or, nand, nor, xor, xnor e not; Para vetores, são
efetuados bit a bit;

 Operações relacionais: igual (=), diferente (/=), menor que (<), menor ou igual
(<=), maior que (>), maior ou igual (>=) – o resultado é sempre do tipo boolean;

 Operações numéricas: soma (+), subtração (-), negação (- unário), multiplicação

(*), divisão (/), módulo (mod), remanescente (rem), expoente (**) e valor
absoluto (abs) são aplicados somente para integer e real e para o tipo time,
embora existam bibliotecas específicas para aritmética;
 Operações de concatenação:

◦ Cria um novo vetor a partir de dois vetores já existentes.

◦ Ex:
 Dado1: bit_vector(7 downto 0);
 Dado2: bit_vector(7 downto 0);
 Dado_Resultante: bit_vector(7 downto 0)
 Dado1 := “01011011”;
 Dado2 := “11010010”;
 Dado_Resultante := (Dado1(7 downto 6) & Dado2(5 downto 2) & Dado1(1
downto 0));
 Dado_Resultante = “01010011”
 Usados para representar e armazenar dados;

 Três tipos básicos: constantes, sinais e variáveis;

 Cada objeto possui um tipo de dados específico e um conjunto de

possíveis valores;

 Objetos de dados de tipos diferentes não podem ser atribuídos um

ao outro. Ex: somar 101(Bit) e 011(Std_logic).
 Assumem apenas um valor em todo o código.

 Declaração:
◦ constant <identificador>: <tipo> := <valor>
 Ex: constant errado : boolean := False;
 Ex: constant parte_ram : bit_vector(3 downto 0) := 1110;
 Podem ser declaradas em qualquer parte do código

 Constante com valor global:

 Package (uso mais freqüente)

 Somente no contexto em que foi declarada:

 entity, architecture, process, function
 Representam ligações entre elementos;
 Comunicação de módulos em uma estrutura
 Temporizados.
 Declaração:
• signal <identificador>: <tipo> [:= valor];
 Podem ser declaradas:
• Globalmente:
 Package
• Internamente:
 architecture (mais utilizado)
 Utilizados para armazenar valores intermediários entre expressões;

 Atribuição imediata;

 Declaração:
◦ variable <identificador>: <tipo> [:= valor];

 Podem ser declaradas apenas em processos (variáveis locais);

 Podem corresponder a registradores (processos sem temporização) ou não

(processos com temporização);
 Quando utiliza-se sinal, a atribuição ocorre no final do processo, enquanto que
a atribuição na variável ocorre simultaneamente.

 Diferença entre as atribuições:

<= (atribuição de sinal)

:= (atribuição de variável)

Dentro de um processo (atribuições sequenciais) um sinal só pode ter atribuído um

valor de cada vez.
D <= 2;

process (C, D ) process (C, D) process (C, D) process (C, D)

begin begin begin begin
A <= 2; A <= 2; A <= 2 ; A <= 2;
B <= A + C; B <= A + C; B <= A + C; B <= A + C
A <= D +1; A <= D +1; A <= D +1; A <= D +1;
E <= A * 2; E <= A * 2; E <= A * 2; E <= A * 2;
end process; end process; end process; end process;

A=1 A=1 A=1 A <= 2 A = 1 A <= 2

B=1 B=1 B=1 B = 1 B <= A + C Não atualiza
C=1 C=1 C=1 C=1
D=1 D=2 D=2 D=2
E=1 E=1 E=1 E=1
process (C, D) process (C, D) process (C, D) process (C, D)
begin begin begin begin
A <= 2; A <= 2; A <= 2; A <= 2;
B <= A + C; B <= A + C; B <= A + C; B <= A + C;
A <= D +1; A <= D +1; A <= D +1; A <= D +1;
E <= A * 2; E <= A * 2; E <= A * 2; E <= A * 2;
end process; end process; end process; end process;

A = 1 A <= D + 1 A = 1 A <= D + 1 A=1 A <= 3 A= 3 A diferença entre

B = 1 B <= A + C B = 1 B <= A + C B=1 B <= 2 B= 2 e não 3 os valores deve-se
C=1 C=1 C=1 C=1 a forma de atribuição
D=2 D=2 D=2 D=2
E=1 E = 1 E <= A * 2; E=1 E <= 2; E= 2 e não 6
D <= 2;
process (C, D) process (C, D) process (C, D)
variable Av, Bv, Ev : integer := 0; variable Av, Bv, Ev : integer :=0; variable Av, Bv, Ev : integer := 0;
begin begin begin
Av := 2; Av := 2; Av := 2;
Bv := Av + C; Bv := Av + C; Bv := Av + C;
Av := D +1; Av := D +1; Av := D +1;
Ev := Av * 2; Ev := Av * 2; Ev := Av * 2;
A <= Av; A <= Av; A <= Av;
B <= Bv; B <= Bv; B <= Bv;
E <= Ev; E <= Ev; E <= Ev;
end process; end process; end process;
A=1 A=1 Av = 0 A=1 Av = 2
B=1 B=1 Bv = 0 B=1 Bv = 0
C=1 C=1 C=1
D=2 D=2 D=2
E=1 E=1 Ev = 0 E=1 Ev = 0
process (C, D) process (C, D) process (C, D)
variable Av, Bv, Ev : integer := 0; variable Av, Bv, Ev : integer := 0; variable Av, Bv, Ev : integer := 0;
begin begin begin
Av := 2; Av := 2; Av := 2;
Bv := Av + C; Bv := Av + C; Bv := Av + C;
Av := D +1; Av := D +1; Av := D +1;
Ev := Av * 2; Ev := Av * 2; Ev := Av * 2;
A <= Av; A <= Av; A <= Av;
B <= Bv; B <= Bv; B <= Bv;
E <= Ev; E <= Ev; E <= Ev;
end process; end process; end process;
A=1 Av = 2 A=1 Av = 3 A=1 Av = 3
B=1 Bv = 3 B=1 Bv = 3 B=1 Bv = 3
C=1 C=1 C=1
D=2 D=2 D=2
E=1 Ev = 0 E=1 Ev = 0 E=1 Ev = 6
PARTE III : CIRCUITOS
COMBINACIONAIS
Architecture (Arquitetura)
◦ Descrição comportamental:
 descreve o que o sistema deve fazer de forma abstrata

◦ Descrição por fluxo de dados (data-flow):

 descreve o que o sistema deve fazer utilizando expressões
lógicas

◦ Descrição estrutural:
 descreve como é o hardware em termos de interconexão de
componentes
 Comandos paralelos: operam simultaneamente, geralmente,
sem comunicação entre si

 Comandos concorrentes: operam ao mesmo tempo com

uma cooperação implícita na comunicação entre eles

64
 Usados para imitar a natureza concorrente e paralela do
hardware

 Um comando do tipo:
a <= b XOR c
Será executado apenas quando os sinais da direita mudam o valor e
não por ordem de aparecimento na descrição ou no fluxo de
controle

65
  Exemplo: ou-exclusivo (XOR)
LIBRARY ieee; ARCHITECTURE behavior OF xor2 IS
USE ieee.std_logic_1164.all; SIGNAL int1, int2 : STD_LOGIC;
BEGIN
ENTITY xor2 IS int1 <= NOT a AND b;
PORT ( a, b : IN STD_LOGIC; int2 <= a AND NOT b;
s : OUT STD_LOGIC); s <= int1 OR int2;
END xor2; END behavior;

• s <= int1 OR int2 só será executado se alguma modificação de a ou b provocarem

alguma modificação em um ou ambos os sinais int1 e int2. A ordem de
aparecimento na descrição em nada modifica o resultado.

66
 WHEN-ELSE
 Atribuição condicional de sinais.

 WITH-SELECT
 Atribuição de sinal com escolha.

 PROCESS

67
 Atribuição de sinal condicional

LABEL:
<sinal> <= <expressão> WHEN <expressão_booleana> ELSE
<expressão> WHEN <expressão_booleana> ELSE
<expressão>

68
ENTITY teste IS
PORT (a, b, c : IN integer;
z : OUT integer);
END teste;

ARCHITECTURE behavior OF teste IS

SIGNAL x : integer;
BEGIN
x <= 3;
z <= a WHEN (x > 3) ELSE
b WHEN (x < 3) ELSE
c;
END behavior;

69
 As opções de escolha são definidas por expressões que
retornam um valor booleano.

 Como WHEN-ELSE define uma prioridade na ordem

das opções, o circuito equivalente corresponde a uma
cadeia de seletores.

s0 <= i0 OR i1 WHEN na = 8 OR nb = 2 ELSE

i1 WHEN na = 3 OR nb = 5 ELSE
i0 AND i1 WHEN na = 7 ELSE
i0;

70
 Exemplo: Multiplexador de 1 bit
D0 D1
D
0
S
MUX A
D S
1

D0, D1 = Entradas
A A = Sinal
S = Saída
LIBRARY ieee;
USE ieee.std_logic_1164.all;

ENTITY Mux_1b IS
PORT (
D0, D1, Sinal : IN std_logic;
Saida : OUT std_logic
);
END Mux_1b;

ARCHITECTURE behavior_we OF Mux_1b IS

BEGIN
Saida <= D0 WHEN Sinal = „0‟ ELSE
D1 WHEN Sinal = „1‟;
END behavior;
LIBRARY ieee;
USE ieee.std_logic_1164.all;

ENTITY decod3to8 IS
PORT (
endereco : IN STD_LOGIC_VECTOR(2 DOWNTO 0);
Saida : OUT STD_LOGIC_VECTOR(7 DOWNTO 0) );
END decod3to8;
ARCHITECTURE behav OF decod3to8 IS
BEGIN
Saida <= “00000001” WHEN endereco = “000” ELSE
“00000010” WHEN endereco = “001” ELSE
“00000100” WHEN endereco = “010” ELSE
“00001000” WHEN endereco = “011” ELSE
“00010000” WHEN endereco = “100” ELSE
“00100000” WHEN endereco = “101” ELSE
“01000000” WHEN endereco = “110” ELSE
“10000000” WHEN endereco = “111”;
END behav;
 Atribuição de sinal selecionada

WITH <expressão> SELECT

<sinal> <= <expressão_a> WHEN <condicao_1>,
<expressão_b> WHEN <condicao_2>,
<expressão_c> WHEN <condicao_3> [|
<condicao_4>],
<expressão_d> WHEN OTHERS;

74
 As condições são mutuamente exclusivas

 Não contém uma prioridade como WHEN-ELSE

 As condições podem ser agrupas através do delimitador “|”, equivalente a

“OU”

 “TO” e “DOWNTO” podem ser empregadas para faixa de valores

 “OTHERS” é válida, como última alternativa

75
 Exemplos

WITH s0 SELECT -- s0 tipo CHARACTER

x0 <= i0 AND i1 WHEN „a‟,
i0 OR i1 WHEN „b‟ | „c‟,
i0 XOR i1 WHEN „d‟ TO „g‟,
i0 WHEN „x‟ DOWNTO „k‟,
i1 WHEN OTHERS;

WITH b1 AND b0 SELECT -- b1 e b0 tipo BIT

x1 <= i0 WHEN „0‟,
i1 WHEN „1‟;

76
 Exemplo: Multiplexador de 8 bits com 4 entradas

D0
8
D1
8 MUX Saída
D2 8
8
D3
8
Sinal
2
LIBRARY ieee;
USE ieee.std_logic_1164.all;

ENTITY Mux_8b IS
PORT (
D0, D1, D2, D3 : IN STD_LOGIC_VECTOR(7 DOWNTO 0);
Sinal : IN STD_LOGIC_VECTOR (1 DOWNTO 0);
Saida : OUT STD_LOGIC_VECTOR(7 DOWNTO 0) );
END Mux_8b;

ARCHITECTURE behavior OF Mux_8b IS

BEGIN
WITH Sinal SELECT
Saida <= D0 WHEN “00”,
D1 WHEN “01”,
D2 WHEN “10”,
D3 WHEN OTHERS;
END behavior;
LIBRARY ieee; ARCHITECTURE behavior OF decod3to8 IS
USE ieee.std_logic_1164.all; BEGIN
WITH endereco SELECT
ENTITY decod3to8 IS Saida <= “00000001” WHEN “000”,
PORT ( “00000010” WHEN “001”,
endereco : IN BIT_VECTOR(2 DOWNTO 0); “00000100” WHEN “010”,
Saida : OUT BIT_VECTOR(7 DOWNTO 0) ); “00001000” WHEN “011”,
END decod3to8; “00010000” WHEN “100”,
“00100000” WHEN “101”,
“01000000” WHEN “110”,
“10000000” WHEN “111”;
END behavior;
 Compostos de:
◦ Parte declarativa
◦ Parte de comandos seqüenciais

 Estrutura
nome: PROCESS (lista de sensibilidade)
-- declarações de tipos, constantes,variáveis
-- não é permitido declaração de sinais
BEGIN
-- comandos seqüenciais
END PROCESS nome;

80
 Processos são concorrentes entre si

 Dentro de um processo, a execução é sequencial

 O processo é executado até o último comando e suspenso até que ocorra um evento
em sua lista de sensibilidade

 A lista de sensibilidade é composta por sinais e entradas

 Um evento em qualquer desses sinais dispara o processo

81
 Seguem a ordem de aparecimento no código

 Comandos seqüências só podem ser usados dentro de processos (process)

 Processos podem ser usados para modelar os diferentes componentes de

um sistema

 Processos são concorrentes entre si

82
 IF-THEN-ELSE
 CASE
 NULL
 FOR
 WHILE (* não sintetizável)

83
IF <condição1> THEN
<comandos>;
ELSIF <condição2> THEN
<comandos>;
ELSE
IF <condição3> THEN
<comandos>;
END IF;
END IF;

84
 Exemplo

IF na = 3 THEN
s0 <= i0 OR i1;
s1 <= i3;
ELSIF na = 8 OR y = „1‟ THEN
s0 <= i1;
s1 <= i4;
ELSE
s0 <= i0 AND i1;
s1 <= i5;
END IF;

85
  Exemplo 2: Multiplexador
LIBRARY ieee; ARCHITECTURE behavior OF mux2to1 IS
USE ieee.std_logic_1164.all; BEGIN;
PROCESS (D0, D1, X)
ENTITY mux2to1 IS BEGIN
PORT (D0, D1, X : IN STD_LOGIC; IF X = „0‟ THEN
S: OUT STD_LOGIC S <= D0;
); ELSE
END mux2to1; S <= D1;
END IF;
END PROCESS;
END behavior;

86
 Seleciona a execução que ocorrerá de uma lista de alternativas
 Equivale ao comando WITH-SELECT

CASE <seleção> IS
WHEN <condicao1> =>
<comandos>;
WHEN <condicao2> TO <condicao3> =>
<comandos>;
WHEN <condicao4> | <condicao5> =>
<comandos>;
WHEN others =>
<comandos>;
END CASE;

87
 Exemplo

CASE na IS
WHEN 3 =>
s0 <= i0 OR i1;
s1 <= i3;
WHEN 7 TO 12 =>
s0 <= i1;
s1 <= i4;
WHEN OTHERS =>
s0 <= i0 AND i1;
s1 <= i5;
END CASE;

88
...
PROCESS (sel, en)
BEGIN
y <= ”11111111”;
IF (en = ‟1‟) THEN
CASE sel IS  Ao utilizar processos, um erro comum
WHEN ”000” => y(0) <= ‟0‟; é esquecer de atribuir a uma saída um
WHEN ”001” => y(1) <= ‟0‟; valor default. Todas as saídas devem
WHEN ”010” => y(2) <= ‟0‟; ter valores defaults.
WHEN ”011” => y(3) <= ‟0‟;
WHEN ”100” => y(4) <= ‟0‟;  Neste exemplo, se não fosse atribuído
WHEN ”101” => y(5) <= ‟0‟;
a y o valor default “11111111”,
nenhum valor seria atribuído a y caso
WHEN ”110” => y(6) <= ‟0‟; en = 0.
WHEN ”111” => y(7) <= ‟0‟;
END CASE;
END IF;
END PROCESS;
 Não realiza nenhuma operação

 A execução é passada para o próximo comando

 Especialmente útil na construção CASE WHEN que precisa

cobrir todos os valores da expressão de escolha mas para
alguns valores não deve ser feito nada em um dado projeto

90
FOR

FOR <parâmetro> IN <intervalo> LOOP

<comandos>;
END LOOP;

• O parâmetro é tratado internamente como uma constante e não pode ser

alterado durante a execução do loop;

• Existe o loop WHILE, mas não é sintetizável.

Exemplo: Comparador de 4 bits

a(3 downto 0)
Architecture equals

b(3 downto 0)

se a = b então
Equals = 1
senão
Equals = 0
 Descrição por Data-Flow
-- comparador de 4 bits
entity comp4 is
port ( a, b: in bit_vector (3 downto 0);
equals: out bit );
end comp4;

architecture fluxo of comp4 is

begin
equals  = ‘1’ when (a=b) else ‘O’;
end fluxo;
 Descrição Comportamental
-- comparador de 4 bits
entity comp4 is
port ( a, b: in bit_vector (3 downto 0);
equals: out bit );
end comp4;

architecture comport of comp4 is

begin
comp: process (a,b) -- lista de sensibilidade
begin
if a = b then
equals  = ‘1’ ;
else
equals  = ‘O’ ;
end if;
end process comp;
end comport;
 Descrição Estrutural
-- comparador de 4 bits
entity comp4 is
port ( a, b: in bit_vector (3 downto 0);
equals: out bit );
end comp4;

architecture estrut of comp4 is

signal x: bit_vector (3 downto 0);
component xnor is port (a, b: in bit; equals: out bit );
end component;
begin
U0: xnor port map (a(0), b(0), x(0));
U1: xnor port map (a(1), b(1), x(1));
U2: xnor port map (a(2), b(2), x(2));
U3: xnor port map (a(3), b(3), x(3));
U4: and4 port map (x(0), x(1), x(2), x(3), equals);
end estrut;
 É uma entidade de projeto empregada na arquitetura de
uma outra entidade

 A utilização desses elementos permite a interligação de

múltiplas entidades de projeto, de modo a formar uma
entidade mais complexa em um projeto hierárquico

96
 Para a utilização é necessária a declaração do
componente
◦ Empregando a palavra COMPONENT no lugar de ENTITY

COMPONENT nome_componente_x
GENERIC (n : tipo_n := valor; -- lista de genéricos
PORT ( sinal_a : modo_a tipo_sinal_a;-- lista de portas
sinal_b : modo_b tipo_sinal_b;
sinal_c : modo_c tipo_sinal_c);
END COMPONENT;

97
  A solicitação é um comando concorrente que consiste
em um rótulo, o nome do componente e o mapa de
portas (PORT MAP)

-- rotulo nome mapa lista

x1: componente_x PORT MAP( a(1), b(1), c(1) ); -- posicional
x2: componente_x PORT MAP( sianl_b => b(1), sinal_a => a(1),
sinal_c => c(1) ); -- nomeada
x3: componente_y PORT MAP( sinal_x => x(1), sinal_y => OPEN ) -- nomeada

98
 Posicional
◦ A lista de sinais no mapa deve seguir a mesma ordem estabelecida na
declaração do componente

 Nomeada
◦ Uma nova seqüência definida no mapa

 A palavra OPEN indica que o sinal do componente não é

conectado a nenhum sinal da arquitetura

99
Especificando a Estrutura de um
Sistema
O component é exatamente a descrição de um componente
O port map é um mapeamento deste componente em um sistema
maior.
 Programa 1 Programa 2
--------------------------------------------------------- ---------------------------------------------------------
-- Arquivo componente_inv.vhd -- Arquivo componente_and.vhd
-- Modelo do inversor -- Modelo da porta AND
--------------------------------------------------------- ---------------------------------------------------------

library IEEE; library IEEE;

use IEEE.std_logic_1164.all; use IEEE.std_logic_1164.all;

entity componente_inv is entity componente_and is

port( port(
x : in std_logic; a : in std_logic;
y : out std_logic b : in std_logic;
); c : out std_logic
end componente_inv; );
end componente_and;
architecture arquitetura_inv of compo-
nente_inv is architecture arquitetura_and of com-
ponente_and is
begin
y <= not x; begin
end arquitetura_inv; c <= a and b;
end arquitetura_and;
 Programa 3
------------------------------------------------------
-- Arquivo componente_sistema.vhd
------------------------------------------------------

library IEEE;
use IEEE.std_logic_1164.all;

entity componente_sistema is
port(
in1 : in std_logic;
in2 : in std_logic;
in3 : in std_logic;
in4 : in std_logic;
out1 : out std_logic
);
end componente_sistema;

architecture arquitetura_sistema of componente_sistema is

component componente_and
port( a: in std_logic; b : in std_logicbit; c : out std_logic);
end component;

component componente_inv
port( x: in std_logic; y : out std_logic);
end component;

signal s1, s2, s3, s4 : std_logic;

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 => ut1);
inv1 : componente_inv port map (x => s1, y => s3);
inv2 : componente_inv port map (x => s2, y => s4);
end arquitetura_sistema;
 Somador Completo de 1 bit
sum = a XOR b XOR cin
cout = (a AND b) OR (a AND cin) OR (b AND cin)
A B CIN SUM COUT
0 0 0 0 0
0 0 1 1 0
0 1 0 1 0
0 1 1 0 1
1 0 0 1 0
1 0 1 0 1
1 1 0 0 1
1 1 1 1 1
LIBRARY ieee;
USE ieee.std_logic_1164.all;

ENTITY full_adder IS
PORT (
cin: IN std_logic;
a: IN std_logic;
b: IN std_logic;
sum: OUT std_logic;
cout: OUT std_logic
);
END full_adder;

ARCHITECTURE behavior OF full_adder IS

BEGIN
sum <= a XOR b XOR cin;
cout <= (a AND b) OR (cin AND (a OR b));
END behavior;
  Somador de 4 bits
COUT CIN

ADDER A(3 downto 0)

SUM(3 downto 0)
B(3 downto 0)

COUT ADDER CIN

COUT ADDER ADDER
7
CIN
… 1
COUT
0
A(7) A(1) A(0)
B(2) S(1) B(1) S(0) B(0)
S(3)
  Somador de 4 bits
LIBRARY ieee;
USE ieee.std_logic_1164.all;

ENTITY adder_4bits IS
PORT (
cin: IN std_logic;
a: IN std_logic_vector(3 DOWNTO 0);
b: IN std_logic_vector(3 DOWNTO 0);
sum: OUT std_logic_vector(3 DOWNTO 0);
cout: OUT std_logic
);
END adder_4bits;
ARCHITECTURE structure OF adder_4bits IS
SIGNAL c: std_logic_vector(0 TO 2);

COMPONENT full_adder IS
PORT (
cin : IN std_logic;
a : IN std_logic;
b : IN std_logic;
sum : OUT std_logic;
cout : OUT std_logic
);
END COMPONENT;
BEGIN
FULL_ADDER_0: full_adder
PORT MAP (cin => cin, a => a(0), b => b(0), sum =>
sum(0), cout => c(0));
FULL_ADDER_1: full_adder
PORT MAP (cin => c(0), a => a(1), b => b(1), sum =>
sum(1), cout => c(1));
FULL_ADDER_2: full_adder
PORT MAP (cin => c(1), a => a(2), b => b(2), sum =>
sum(2), cout => c(2));
FULL_ADDER_3: full_adder
PORT MAP (cin => c(2), a => a(3), b => b(3), sum =>
sum(3), cout => cout);
END structure;
PARTE IV : CIRCUITOS
SEQUENCIAIS
 Ativado apenas quando clk sofre alterações
 D não altera o processo

11
0
LIBRARY ieee;
USE ieee.std_logic_1164.all;
ENTITY dff_logic IS
PORT (d, clk : IN BIT;
q : OUT BIT);
END dff_logic;

ARCHITECTURE behavior OF dff_logic IS

BEGIN
PROCESS(clk)
BEGIN
IF (clk’event AND clk = ‘1’) THEN
q <= d;
END IF;
END PROCESS;
END behavior;

11
1
 A condição clk‟event é ativada quando ocorre variação no valor
de clk;

 A utilização de clk‟event em conjunto com a lista de

sensibilidade é redundante, mas necessária devido ao fato de
que algumas ferramentas de síntese ignoram a lista de
sensibilidade;

 Uma mudança do clock pode ocorrer de „0‟ para „1‟ ou de „1‟

para „0‟, desse modo é necessária a condição adicional clk = „1‟
ou clk = „0‟;

 Em STD_LOGIC, usa-se rising_edge para transição de subida de

clock e falling_edge para transição de descida.

11
2
ARCHITECTURE behavior OF dff_logic IS
BEGIN
PROCESS(clk, reset)
BEGIN
IF reset = ‘1’ THEN
q <= (others => ‘0’);
ELSIF RISING_EDGE(clk) THEN
q <= d;
END IF;
END PROCESS;
END behavior;

11
4
ARCHITECTURE behavior OF dff_logic IS
BEGIN
PROCESS(clk, preset)
BEGIN
IF preset = ‘1’ THEN
q <= (others => ‘1’);
ELSIF RISING_EDGE(clk) THEN
q <= d;
END IF;
END PROCESS;
END behavior;

11
5
ARCHITECTURE behavior OF reg_logic IS
BEGIN
PROCESS(clk, reset) BEGIN
IF (reset = ‘1’) THEN
q <= (others => ‘0’);
ELSIF RISING_EDGE(clk) THEN
IF (preset = ‘1’) THEN
q <= (others => ‘1’);
ELSE
q <= d;
END IF;
END IF;
END PROCESS;
END behavior;

11
6
ARCHITECTURE behavior OF reg_logic IS
BEGIN
PROCESS(clk, reset, preset)
BEGIN
IF (reset = ‘1’) THEN
q <= (others => ‘0’);
ELSIF (preset = ‘1’) THEN
q <= (others => ‘1’);
ELSIF RISING_EDGE(clk) THEN
q <= d;
END IF;
END PROCESS;
END behavior;

11
7
 São usadas para especificar e implementar
unidades de controle

 Podem ser representadas por meio de um

diagrama de estados

11
8
Exemplo:
entrada = 0 entrada = 1 entrada = 1
Estado Saída
A B A 0
B 0
entrada = 0
C 1
C

 Cada transição ocorre em um evento do relógio, tanto de um

estado para outro quanto para o mesmo estado

11
9
 Seqüência de passos:
◦ Cada estado é transcrito utilizando o CASE
◦ A transição entre estados é realizada utilizando o IF-THEN-ELSE
◦ Para criar os estados é necessário definir um tipo enumerado
(enumeration type) contendo o nome dos estados e os sinais para
cada tipo:

TYPE <tipo_estado> IS (nome_estado, nome_estado);

SIGNAL estado : <tipo_estado>

São necessários dois processos: um realiza as operações dentro

dos estados e o outro atualiza o estado.

12
0
 Máquina de estados do exemplo anterior:
LIBRARY ieee;
USE ieee.std_logic_1164.all;

ENTITY maquina_estados IS
PORT (
entrada : IN std_logic;
clock : IN std_logic;
saida : OUT std_logic
);
END maquina_estados;

12
1
ARCHITECTURE behavior OF maquina_estados IS
TYPE estado IS (A, B, C);
SIGNAL estado_atual, proximo_estado : estado;
BEGIN

PROCESS (clock, entrada)

BEGIN
CASE estado_atual IS
WHEN A =>
saida <= ‘0’;
IF (entrada = ‘1’) THEN
proximo_estado <= B;
END IF;

12
2
WHEN B =>
saida <= ‘0’;
IF (entrada = ‘0’) THEN
proximo_estado <= C;
END IF;

WHEN C =>
saida <= ‘1’;
proximo_estado <= A;
END CASE;
END PROCESS;

12
3
ATUALIZA_ESTADO : PROCESS (clock)
BEGIN
IF (clock’event AND clock = ‘1’) THEN
estado_atual <= proximo_estado;
END IF;
END PROCESS ATUALIZA_ESTADO;
END behavior;

 O primeiro processo realiza as operações dentro dos estados e

indica qual será a transição de estado

 O segundo processo (ATUALIZA_ESTADO) realiza a transição entre

estados quando ocorre um evento de subida do relógio (clock)

12
4
PARTE V : CIRCUITOS
HARDWIRED
•Descrição de um circuito que realiza a raiz
quadrada de um número natural;

•Obtenção de um modelo de hardware a partir

de um algoritmo;

•Descrição das Partes Operativa e de Controle

em VHDL;
d <- 2;
s <- 4;
Fazer
d <- d + 2;
r <- d / 2;
s <- s + d + 1;
Enquanto (s < = x);
 d = 2; s = 4; x = DATA_IN
Registradores
Multiplexadores d=d+2 Somador

Divisão por 2 =
r=d/2
Deslocador à
direita
s=s+d+1

s>x
Flag para controle
Maior / menor

DATA_OUT = r
Composta de:
• 1 Multiplexador para o valor de D
• 1 Multiplexador para o valor de S
• 2 Multiplexadores para os valores de entrada do somador
• 1 Multiplexador para o bit de seleção do somador
• 4 Registradores (D, S, R e X)
• 1 Somador para o cálculo de D e S
• 1 deslocador para o valor de R
d <- 2;
s <- 4;
Fazer
d <- d + 2;
r <- d / 2;
s <- s + d + 1;
Enquanto (s < = x);
 d = 2; s = 4; x = DATA_IN
Registradores
d=d+2

r=d/2

s=s+d+1

s>x

DATA_OUT = r
Dados dos registradores utilizados: WE
• Tamanho: N bits 1
• Possuem write enable
• Circuitos síncronos Entrada Saida
N REG N

clk
LIBRARY IEEE; ARCHITECTURE behavior OF reg_gen IS
USE IEEE.STD_LOGIC_1164.ALL; BEGIN
PROCESS(clk)
ENTITY reg_gen IS BEGIN
GENERIC (N : POSITIVE := 8); -- Default value IF (clk'EVENT AND clk = „1') THEN
PORT ( IF ( WE = '1') THEN
clk : IN BIT; DATA_OUT <= DATA_IN;
DATA_IN : IN END IF;
STD_LOGIC_VECTOR(N-1 DOWNTO 0);
END IF;
WE : IN STD_LOGIC;
END PROCESS;
DATA_OUT : OUT
STD_LOGIC_VECTOR(N-1 DOWNTO 0) END behavior;
);
END reg_gen;
 WED
1
D

WES
1
S
WER
1
R

WEX
1
X
clk
 d = 2; s = 4; x = DATA_IN
Multiplexadores
d=d+2

r=d/2

s=s+d+1

s>x

DATA_OUT = r
Dados dos multiplexadores utilizados para D e S:
• Tamanho: N bits
• Possuem 2 entradas Seleção
• Circuitos Combinacionais 1

Entrada_1
N M Saida
U N
Entrada_2 X
N
LIBRARY IEEE; ARCHITECTURE behavior OF mux_gen IS
USE IEEE.STD_LOGIC_1164.ALL; BEGIN
PROCESS
ENTITY mux_gen IS BEGIN
GENERIC (N : POSITIVE := 8); -- Default value IF (SM = '0') THEN
PORT ( DATA_OUT <= DATA_A;
DATA_A, DATA_B : IN ELSE
STD_LOGIC_VECTOR(N-1 DOWNTO 0);
DATA_OUT <= DATA_B;
SM : IN STD_LOGIC;
END IF;
DATA_OUT : OUT
STD_LOGIC_VECTOR(N-1 DOWNTO 0) END PROCESS;
); END behavior;
END mux_gen;
SMD
1 WED
M
U
1
X D
D

SMS WES
1
M 1
U S
X
S
WER
1
R

WEX
1
X
clk
d = 2; s = 4; x = DATA_IN

d=d+2 Cin = 0

r=d/2
Somador

s=s+d+1 Cin = 1

S–X=
s>x
S + (-X) + 1
(Complemento de 2)
DATA_OUT = r
Dados da ULA
• Tamanho: N bits
• Circuitos Combinacionais
CIN
• Para d + 2
1
• Entrada_1 = d
• Entrada_2 = 2 Entrada_1
• Para s + d + 1 N
• Entrada_1 = d U Saida
• Entrada_2 = s L N
• Para s - x A
Entrada_2
• Entrada_1 = -x
N
• Entrada_2 = s
LIBRARY IEEE; ARCHITECTURE behavior OF ula IS
USE IEEE.STD_LOGIC_1164.ALL; SIGNAL int_carry : STD_LOGIC_VECTOR(N-1
DOWNTO 0);
ENTITY ula IS SIGNAL sum_t : STD_LOGIC_VECTOR(N-1
GENERIC (N : POSITIVE := 8); -- Default value DOWNTO 0);
PORT ( Cin : IN STD_LOGIC; BEGIN
A, B : IN STD_LOGIC_VECTOR(N-1 sum_t <= A(N-1 DOWNTO 0) XOR B(N-1
DOWNTO 0); DOWNTO 0) XOR (int_carry (N-2 DOWNTO 0)
&Cin);
Sum : OUT STD_LOGIC_VECTOR(N-1
DOWNTO 0); int_carry(0) <= ((A(0) OR B(0)) AND Cin) OR (A(0)
AND B(0));
Cout : OUT STD_LOGIC);
END ula;
CASCADE_CARRY:
FOR I in 1 TO N-1 GENERATE
int_carry(I) <= ((A(I) OR B(I)) AND int_carry(I-1)) OR (A(I) AND B(I));
END GENERATE CASCADE_CARRY;
--
PROCESS
BEGIN
IF ( (sum_t(N - 1) = '1') OR ( A = NOT B)) THEN Necessário para S – X, mas
Cout <= '1';
não para X – S
ELSE
Cout <= '0';
END IF;
END PROCESS;
Sum <= sum_t;
END behavior;
 SMD
1 WED
M
U
1
X D
2 D
SM1 MUX_UL
A
SMS WES
1 M CIN= SM3
M 1 U
U S X

4
X A
U
N
S
WER L
A
1 SM2
R M
U
X
WEX B
1
X 2
clk
 d = 2; s = 4; x = DATA_IN

d=d+2

Divisão por 2
r=d/2
Deslocador à
direita
s=s+d+1

s>x

DATA_OUT = r
Dados do deslocador
• Tamanho: N bits
• Desloca apenas à direita
• Circuito Combinacional

D
Entrada Saida
E
N N
S
L
LIBRARY IEEE; ARCHITECTURE behavior OF DESLOCADOR IS
USE IEEE.STD_LOGIC_1164.ALL; BEGIN
DATA_OUT <= '0' & DATA_IN(N-1 DOWNTO
ENTITY DESLOCADOR IS 1);
GENERIC (N : POSITIVE := 8); -- Default value END behavior;
PORT (
DATA_IN : IN
STD_LOGIC_VECTOR(N-1 DOWNTO 0);
DATA_OUT : OUT
STD_LOGIC_VECTOR(N-1 DOWNTO 0));
END DESLOCADOR;
 SMD
1 WED
M
U
1
X D
2 D
SM1 MUX_UL SM3
A
SMS WES
1 M
M 1 U
CIN
U S X

4
X A
U
N D
S
WER L E
A
1 SM2 S
R M L
U
X
WEX B
1
X 2
clk
LIBRARY IEEE;
USE IEEE.STD_LOGIC_1164.ALL;

ENTITY OP IS
PORT (
clk : IN BIT;
DATA_IN : IN STD_LOGIC_VECTOR(15 DOWNTO 0);
DATA_OUT : OUT STD_LOGIC_VECTOR(15 DOWNTO 0);
N : OUT STD_LOGIC;
CTR : IN STD_LOGIC_VECTOR(8 DOWNTO 0)
);
END OP;
ARCHITECTURE estrutural OF OP IS
SIGNAL sig_muxd, sig_muxs : STD_LOGIC_VECTOR(15 DOWNTO 0);
SIGNAL sig_d, sig_s, sig_r, sig_x : STD_LOGIC_VECTOR(15 DOWNTO 0);
SIGNAL sig_muxa, sig_muxb : STD_LOGIC_VECTOR(15 DOWNTO 0);
SIGNAL sig_sula, sig_desl : STD_LOGIC_VECTOR(15 DOWNTO 0);
SIGNAL cin : STD_LOGIC;
SIGNAL sig_muxd1, sig_muxs1, sig_muxa1, sig_muxb0 : STD_LOGIC_VECTOR(15 DOWNTO 0);
ALIAS smd : STD_LOGIC IS CTR(8);
ALIAS sms : STD_LOGIC IS CTR(7);
ALIAS wed : STD_LOGIC IS CTR(6);
ALIAS wes : STD_LOGIC IS CTR(5);
ALIAS wer : STD_LOGIC IS CTR(4);
ALIAS wex : STD_LOGIC IS CTR(3);
ALIAS sm1 : STD_LOGIC IS CTR(2);
ALIAS sm2 : STD_LOGIC IS CTR(1);
ALIAS sm3 : STD_LOGIC IS CTR(0);
COMPONENT mux_gen IS
GENERIC (N : POSITIVE);
PORT (
DATA_A, DATA_B : IN STD_LOGIC_VECTOR(N-1 DOWNTO 0);
SM : IN STD_LOGIC;
DATA_OUT : OUT STD_LOGIC_VECTOR(N-1 DOWNTO 0));
END COMPONENT;

COMPONENT mux_1 IS
PORT (
DATA_A, DATA_B : IN STD_LOGIC;
SM : IN STD_LOGIC;
DATA_OUT : OUT STD_LOGIC);
END COMPONENT;
COMPONENT reg_gen IS
GENERIC (N : POSITIVE);
PORT (clk : IN BIT;
DATA_IN : IN STD_LOGIC_VECTOR(N-1 DOWNTO 0);
WE : IN STD_LOGIC;
DATA_OUT : OUT STD_LOGIC_VECTOR(N-1 DOWNTO 0));
END COMPONENT;

COMPONENT DESLOCADOR IS
GENERIC (N : POSITIVE);
PORT (DATA_IN : IN STD_LOGIC_VECTOR(N-1 DOWNTO 0);
DATA_OUT : OUT STD_LOGIC_VECTOR(N-1 DOWNTO 0));
END COMPONENT;
COMPONENT ula IS
GENERIC (N : POSITIVE);
PORT (Cin : IN STD_LOGIC;
A, B : IN STD_LOGIC_VECTOR(N-1 DOWNTO 0);
Sum : OUT STD_LOGIC_VECTOR(N-1 DOWNTO 0);
Cout : OUT STD_LOGIC);
END COMPONENT;
--
BEGIN
--
sig_muxd1 <= "0000000000000010"; -- “2”
sig_muxs1 <= "0000000000000100"; -- “4”
sig_muxb0 <= "0000000000000010"; -- “2”
sig_muxa1 <= NOT(sig_x);
MUXD : mux_gen
GENERIC MAP (N => 16)
PORT MAP (sig_sula, sig_muxd1, smd, sig_muxd);
--
MUXS : mux_gen
GENERIC MAP (N => 16)
PORT MAP (sig_sula, sig_muxs1, sms, sig_muxs);
--
REGD : reg_gen
GENERIC MAP (N => 16)
PORT MAP (clk, sig_muxd, wed, sig_d);
--
REGS : reg_gen
GENERIC MAP (N => 16)
PORT MAP (clk, sig_muxs, wes, sig_s);
REGR : reg_gen
GENERIC MAP (N => 16)
PORT MAP (clk, sig_desl, wer, sig_r);
--
REGX : reg_gen
GENERIC MAP (N => 16)
PORT MAP (clk, DATA_IN, wex, sig_x);
--
MUXA : mux_gen
GENERIC MAP (N => 16)
PORT MAP (sig_d, sig_muxa1, sm2, sig_muxa);
--
MUXB : mux_gen
GENERIC MAP (N => 16)
PORT MAP (sig_muxb0, sig_s, sm1, sig_muxb);
MUXULA : mux_1
PORT MAP (sm2, sm1, sm3, cin);
--
Adder : ula
GENERIC MAP (N => 16)
PORT MAP (cin, sig_muxa(15 downto 0), sig_muxb(15 downto 0), sig_sula(15 DOWNTO 0), N);
--
desl : DESLOCADOR
GENERIC MAP (N => 16)
PORT MAP (sig_sula, sig_desl);
--
DATA_OUT <= sig_r;
END estrutural;
O diagrama de estados terá 4 estados, com o seguinte
funcionamento:
Estado1 :
d = 2; ready/
s = 4; ready
x = DATA_IN; s1
Valores de saída dos bits de controle
Estado2: s2
d = d +2;
r = d/2; pronto pronto/
Valores de saída dos bits de controle
Estado3:
s = s + d + 1;
Valores de saída dos bits de controle s3
Estado4:
S>X?
Valores de saída dos bits de controle s4
LIBRARY IEEE;
USE IEEE.STD_LOGIC_1164.ALL;

ENTITY controle IS
PORT (
clk : IN STD_LOGIC;
NEG : IN STD_LOGIC; -- bit que verifica se s > x
READY : IN STD_LOGIC; -- bit de inicializacao
PRONTO : OUT STD_LOGIC; -- bit de parada
SAIDA : OUT STD_LOGIC_VECTOR(8 DOWNTO 0)
);
END controle;
ARCHITECTURE behavior OF controle IS
TYPE StateType IS (s1, s2, s3, s4);
SIGNAL estado_atual, proximo_estado : StateType;
BEGIN
outro_estado : PROCESS (estado_atual)
BEGIN
…
END PROCESS outro_estado;

…
Organização dos bits de controle: SAIDA(8 DOWNTO 0);
BIT FUNÇÃO
SMD (8) Bit de controle do componente MUXD
SMS (7) Bit de controle do componente MUXS
WED (6) Write Enable do registrador D
WES (5) Write Enable do registrador S
WER (4) Write Enable do registrador R
WEX (3) Write Enable do registrador X
SM1 (2) Bit de controle do componente MUX_B
SM2 (1) Bit de controle do componente MUX_A
SM3 (0) Bit de controle do componente MUX_ULA
CASE estado_atual IS WHEN s3 =>
WHEN s1 => SAIDA <= "000100101";
SAIDA <= "111101000"; proximo_estado <= s4;
IF (READY = '1') THEN --
proximo_estado <= s1; WHEN s4 =>
ELSE SAIDA <= "000000110";
PRONTO <= '0'; IF (NEG = '0') THEN
proximo_estado <= s2; PRONTO <= '1';
END IF; proximo_estado <= s1;
-- ELSE
WHEN s2 => PRONTO <= '0';
SAIDA <= "001010000"; proximo_estado <= s2;
proximo_estado <= s3; END IF;
END CASE;
--
atualiza_estado : PROCESS (clk)
BEGIN
IF (clk'EVENT AND clk = '1') THEN -- rising_edge(clk)
Estado_atual <= proximo_estado;
END IF;
END PROCESS atualiza_estado;
END behavior;
LIBRARY IEEE;
USE IEEE.STD_LOGIC_1164.ALL;

ENTITY raiz IS
PORT (clk : IN BIT;
ENTRADA : IN STD_LOGIC;
DATA_IN : IN STD_LOGIC_VECTOR(15 DOWNTO 0);
DATA_OUT : OUT STD_LOGIC_VECTOR(15 DOWNTO 0);
PRONTO : OUT STD_LOGIC);
END raiz;

ARCHITECTURE estrutural OF raiz IS

--
SIGNAL CTR : STD_LOGIC_VECTOR(8 DOWNTO 0);
SIGNAL N : STD_LOGIC;
COMPONENT OP IS
PORT (clk : IN BIT;
DATA_IN : IN STD_LOGIC_VECTOR(15 DOWNTO 0);
DATA_OUT : OUT STD_LOGIC_VECTOR(15 DOWNTO 0);
N : OUT STD_LOGIC;
CTR : IN STD_LOGIC_VECTOR(8 DOWNTO 0));
END COMPONENT;

COMPONENT controle IS
PORT (clk : IN BIT;
N : IN STD_LOGIC;
ENTRADA : IN STD_LOGIC;
DATA_OUT : OUT STD_LOGIC_VECTOR(8 DOWNTO 0);
PRONTO : OUT STD_LOGIC);
END COMPONENT;
BEGIN
CONTROL: controle
PORT MAP (clk, N, ENTRADA, ctr, PRONTO);
--
OPERACIONAL: OP
PORT MAP (clk, DATA_IN, DATA_OUT, N, ctr);
--
END estrutural;
 Quartus II Web Edition
 www.altera.com
 Compilador e Simulador integrados
 Licença gratuita para estudantes

16
6
 casillo@gmail.com

 casillo@ufersa.edu.br

 leonardocasillo@hotmail.com

 @leocasillo

16
7