Escolar Documentos
Profissional Documentos
Cultura Documentos
VHDL Completo PDF
VHDL Completo PDF
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:
Formada por:
◦ Declarações: sinais, constantes, componentes, subprogramas
◦ Comandos: blocos, atribuições a sinais, chamadas a subprogramas,
instanciação de componentes, processos
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
library IEEE;
use ieee.std_logic_1164.all;
use ieee.std_logic_arith.all;
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 ( _ )
41
São divididos em 4 classes:
Scalar
numéricos Composite
discretos escalar
composto
Floating
Enumerated Integer Physical Array
enumerado point físico vetor
◦ 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
45
Tipos enumerados: permite criar novos tipos.
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
49
Records: coleção de elementos de tipos diferentes.
◦ Semelhante a struct em C
◦ Exemplos:
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;
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
Atribuição imediata;
Declaração:
◦ variable <identificador>: <tipo> [:= valor];
◦ Descrição estrutural:
descreve como é o hardware em termos de interconexão de
componentes
Comandos paralelos: operam simultaneamente, geralmente,
sem comunicação entre si
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;
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;
69
As opções de escolha são definidas por expressões que
retornam um valor booleano.
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;
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
74
As condições são mutuamente exclusivas
75
Exemplos
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;
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
O processo é executado até o último comando e suspenso até que ocorra um evento
em sua lista de sensibilidade
81
Seguem a ordem de aparecimento no código
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
90
FOR
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;
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)
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
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;
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;
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;
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;
SUM(3 downto 0)
B(3 downto 0)
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;
11
1
A condição clk‟event é ativada quando ocorre variação no valor
de clk;
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
11
8
Exemplo:
entrada = 0 entrada = 1 entrada = 1
Estado Saída
A B A 0
B 0
entrada = 0
C 1
C
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:
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
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;
12
4
PARTE V : CIRCUITOS
HARDWIRED
•Descrição de um circuito que realiza a raiz
quadrada de um número natural;
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;
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