minicurso: tÓpicos em vhdl - ufersa.edu.br · características do vhdl – linguagem concorrente....

Prof. Leonardo Augusto Casillo

MINICURSO: TÓPICOS EM VHDL

O que significa VHDL?Very High Speed Integrated CircuitHardwareDescriptionLanguage

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 umsistema faz e como;

Um sistema descrito em linguagem de hardware pode serimplementado em um dispositivo programável FPGA (FieldProgrammable Gate Array) ou um dispositivo ASIC (AplicationSpecific Integrated Circuit), permitindo o uso em campo dosistema;

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 dosistema digital;

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

Algorítmico ou comportamental.

Transferência entre registradores (RTL).

Hoje utilizada para SIMULAÇÃO e SÍNTESE

VHDL é análogo a uma linguagem de programação

VHDL provê mecanismos para modelar a concorrência esincronização que ocorrem a nível físico no hardware

Projetar um sistema em VHDL é geralmente mais difícil queescrever um programa para fazer a mesma coisa utilizandouma linguagem de programação como C

O código VHDL é executado em um simulador◦ Não há um “executável”

Características do VHDL

Características do VHDL

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.

Considerações importantes

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;

– 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.

Ciclo de Projeto:

Etapas de Projeto:

– 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.

Tipos de circuitos:

PARTE I : ELEMENTOS

BÁSICOS

Componentes de um projetoPACKAGE

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.

LIBRARY IEEE;

USE IEEE.STD_LOGIC_1164.all;

USE IEEE.STD_LOGIC_UNSIGNED.all;

PACKAGE (BIBLIOTECAS)

ENTITY exemplo IS

PORT (

<descrição dos pinos de I/O>

);

END exemplo;

ENTITY (PINOS DE I/O)

ARCHITECTURE teste OF exemplo IS

BEGIN

...

END teste;

ARCHITECTURE

(ARQUITETURA)

Componentes de um projeto

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.

Entity (Entidade)

NN

ENTITY

(ENTIDADE)

PINOS DE I/O

ARCHITECTURE

(ARQUITETURA)

PROCESSOS

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)

‘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.

STD_LOGIC:

• Definida pela biblioteca IEEE:

• use ieee.std_logic_1164.all;

• Pode assumir nove valores:

Entity (Entidade)

Circuito exemplo:

Entity (Entidade)

A extensão de um arquivo em VHDL é ”.vhd”. O nome doarquivo DEVE ser o mesmo nome da entidade. No casoacima, 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


Arquitetura do circuito exemplo:


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

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)

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.

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>.

Package (Pacotes)

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 basesbiná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

Enumerated

bit boolean character

Integer

integer

Floating

point

real

Physical

time

Composite

Array

bit_vector string

escalar

composto

discretosnuméricos

enumerado físico

booleano caracter inteiro tempo

vetor

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 nsms=103 us sec=103 msmin=60sec hr=60min

1 us, 100 ps, 1 fs

“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””

48

1 0 1 1 0 0 1 1

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

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

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

c(1) c(2) c(3) c(4) c(5) c(6) c(7) c(8) c(9)

A l o m u n d o

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 depossíveis valores;

Objetos de dados de tipos diferentes não podem ser atribuídos umao 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 quea 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)begin

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

end process;

A = 1B = 1C = 1D = 1

E = 1

process (C, D)begin

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

end process;

A = 1B = 1C = 1D = 2

E = 1

process (C, D)begin

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

end process;

A = 1 A <= 2B = 1C = 1D = 2

E = 1

process (C, D)begin

A <= 2;B <= A + C

A <= D +1;E <= A * 2;

end process;

A = 1 A <= 2B = 1 B <= A + CC = 1D = 2

E = 1

process (C, D)begin

A <= 2;B <= A + C;A <= D +1;

E <= A * 2;end process;

A = 1 A <= D + 1B = 1 B <= A + C

C = 1D = 2E = 1

process (C, D)begin

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

end process;

A = 1 A <= D + 1B = 1 B <= A + C

C = 1D = 2E = 1 E <= A * 2;

process (C, D)begin

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

end process;

A = 1 A <= 3

B = 1 B <= 2

C = 1D = 2E = 1 E <= 2;

process (C, D)begin

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

end process;

A = 3

B = 2 e não 3

C = 1D = 2

E = 2 e não 6

A diferença entre

os valores deve-se

a forma de atribuição

Não atualiza

D <= 2;

process (C, D)variable Av, Bv, Ev : integer := 0;

begin

Av := 2;

Bv := Av + C;

Av := D +1;Ev := Av * 2;

A <= Av;

B <= Bv;

E <= Ev;

end process;

A = 1

B = 1

C = 1D = 2

E = 1

process (C, D)variable Av, Bv, Ev : integer :=0;

begin

Av := 2;

Bv := Av + C;

Av := D +1;Ev := Av * 2;

A <= Av;

B <= Bv;

E <= Ev;

end process;

A = 1 Av = 0

B = 1 Bv = 0

C = 1

D = 2

E = 1 Ev = 0


begin

Av := 2;

Bv := Av + C;

Av := D +1;Ev := Av * 2;

A <= Av;

B <= Bv;

E <= Ev;

end process;

A = 1 Av = 2

B = 1 Bv = 0

C = 1D = 2

E = 1 Ev = 0


begin

Av := 2;

Bv := Av + C;

Av := D +1;

Ev := Av * 2;

A <= Av;

B <= Bv;

E <= Ev;end process;

A = 1 Av = 2

B = 1 Bv = 3

C = 1

D = 2

E = 1 Ev = 0


begin

Av := 2;

Bv := Av + C;

Av := D +1;

Ev := Av * 2;

A <= Av;

B <= Bv;


A = 1 Av = 3

B = 1 Bv = 3

C = 1

D = 2

E = 1 Ev = 0


begin

Av := 2;

Bv := Av + C;

Av := D +1;

Ev := Av * 2;

A <= Av;

B <= Bv;


A = 1 Av = 3

B = 1 Bv = 3

C = 1

D = 2

E = 1 Ev = 6

PARTE III : CIRCUITOS

COMBINACIONAIS

◦ 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)

66

LIBRARY ieee;

USE ieee.std_logic_1164.all;

ENTITY xor2 IS

PORT ( a, b : IN STD_LOGIC;

s : OUT STD_LOGIC);

END xor2;

ARCHITECTURE behavior OF xor2 IS

SIGNAL int1, int2 : STD_LOGIC;

BEGIN

int1 <= NOT a AND b;

int2 <= a AND NOT b;

s <= int1 OR int2;

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.

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 ISPORT (a, b, c : IN integer;

z : OUT integer);END teste;

ARCHITECTURE behavior OF teste ISSIGNAL x : integer;BEGINx <= 3;z <= a WHEN (x > 3) ELSE

b WHEN (x < 3) ELSEc;

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.

70

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;

Exemplo: Multiplexador de 1 bit

A

D1

S

D0

D0, D1 = Entradas

A = Sinal

S = Saída

MUX

D0 D1

A

S

LIBRARY ieee;USE ieee.std_logic_1164.all;

ENTITY Mux_1b ISPORT (

D0, D1, Sinal : IN std_logic;Saida : OUT std_logic

); END Mux_1b;

ARCHITECTURE behavior_we OF Mux_1b ISBEGIN

Saida <= D0 WHEN Sinal = „0‟ ELSED1 WHEN Sinal = „1‟;

END behavior;

LIBRARY ieee;


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






“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

76

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‟;

Exemplo: Multiplexador de 8 bits com 4 entradas

D0

MUX

D1

D2

D3

Sinal

Saída

8

8

8

8

8

2

LIBRARY ieee;


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;


ENTITY decod3to8 IS

PORT (

endereco : IN BIT_VECTOR(2 DOWNTO 0);

Saida : OUT BIT_VECTOR(7 DOWNTO 0) );

END decod3to8;

ARCHITECTURE behavior OF decod3to8 IS

BEGIN

WITH endereco SELECT

Saida <= “00000001” WHEN “000”,“00000010” WHEN “001”,

“00000100” WHEN “010”,

“00001000” WHEN “011”,

“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 deum 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 THENs0 <= i0 OR i1;s1 <= i3;

ELSIF na = 8 OR y = „1‟ THENs0 <= i1;s1 <= i4;

ELSEs0 <= i0 AND i1;s1 <= i5;

END IF;

85

Exemplo 2: Multiplexador

86


ENTITY mux2to1 ISPORT (D0, D1, X : IN STD_LOGIC;

S: OUT STD_LOGIC);

END mux2to1;

ARCHITECTURE behavior OF mux2to1 ISBEGIN;PROCESS (D0, D1, X)BEGIN

IF X = „0‟ THENS <= D0;

ELSES <= D1;

END IF;END PROCESS;END behavior;

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 ISWHEN 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

WHEN ”000” => y(0) <= ‟0‟;

WHEN ”001” => y(1) <= ‟0‟;

WHEN ”010” => y(2) <= ‟0‟;

WHEN ”011” => y(3) <= ‟0‟;

WHEN ”100” => y(4) <= ‟0‟;

WHEN ”101” => y(5) <= ‟0‟;

WHEN ”110” => y(6) <= ‟0‟;

WHEN ”111” => y(7) <= ‟0‟;

END CASE;

END IF;

END PROCESS;

Ao utilizar processos, um erro comumé esquecer de atribuir a uma saída umvalor default. Todas as saídas devemter valores defaults.

Neste exemplo, se não fosse atribuídoa y o valor default “11111111”,nenhum valor seria atribuído a y casoen = 0.

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 <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.

FOR

Architecture

a(3 downto 0)

b(3 downto 0)

equals

Exemplo: Comparador de 4 bits

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


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


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));




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

97

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;

A solicitação é um comando concorrente que consiste

em um rótulo, o nome do componente e o mapa de

portas (PORT MAP)

98

-- 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

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 -- Modelo do inversor ---------------------------------------------------------

library IEEE;

use IEEE.std_logic_1164.all;

entity componente_inv is

port( x : in std_logic; y : out std_logic );

end componente_inv;

architecture arquitetura_inv of compo-

nente_inv is

begin

y <= not x;

end arquitetura_inv;

--------------------------------------------------------- -- Arquivo componente_and.vhd -- Modelo da porta AND ---------------------------------------------------------

library IEEE;


entity componente_and is

port( a : in std_logic; b : in std_logic; c : out std_logic );

end componente_and;

architecture arquitetura_and of com-

ponente_and is

begin

c <= a and b;

end arquitetura_and;

Programa 3

------------------------------------------------------ -- Arquivo componente_sistema.vhd ------------------------------------------------------

library IEEE;


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


ENTITY full_adder ISPORT (

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 ISBEGIN

sum <= a XOR b XOR cin;cout <= (a AND b) OR (cin AND (a OR b));

END behavior;

Somador de 4 bits

ADDER

CIN

A(3 downto 0)

B(3 downto 0)

COUT

SUM(3 downto 0)

ADDER

0

ADDER

1

CIN

A(0)

B(0)S(0)

A(1)

B(1)S(1)

COUTADDER

7A(7)

B(2)S(3)

… COUTCOUT CIN

Somador de 4 bits


ENTITY adder_4bits ISPORT (

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 ISSIGNAL c: std_logic_vector(0 TO 2);

COMPONENT full_adder ISPORT (

cin : IN std_logic;a : IN std_logic; b : IN std_logic;sum : OUT std_logic;cout : OUT std_logic

);END COMPONENT;

BEGINFULL_ADDER_0: full_adderPORT 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_adderPORT 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;


ENTITY dff_logic IS

PORT (d, clk : IN BIT;

q : OUT BIT);

END dff_logic;

11

1

ARCHITECTURE behavior OF dff_logic ISBEGINPROCESS(clk)BEGIN

IF (clk’event AND clk = ‘1’) THENq <= d;

END IF;END PROCESS;

END behavior;

A condição clk‟event é ativada quando ocorre variação no valorde clk;

A utilização de clk‟event em conjunto com a lista desensibilidade é redundante, mas necessária devido ao fato deque algumas ferramentas de síntese ignoram a lista desensibilidade;

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 declock 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 ISBEGINPROCESS(clk, reset) BEGIN

IF (reset = ‘1’) THENq <= (others => ‘0’);

ELSIF RISING_EDGE(clk) THENIF (preset = ‘1’) THEN

q <= (others => ‘1’);ELSE

q <= d;END IF;

END IF;END PROCESS;

END behavior;

11

6

ARCHITECTURE behavior OF reg_logic ISBEGINPROCESS(clk, reset, preset)BEGIN

IF (reset = ‘1’) THENq <= (others => ‘0’);

ELSIF (preset = ‘1’) THENq <= (others => ‘1’);

ELSIF RISING_EDGE(clk) THENq <= 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:

Cada transição ocorre em um evento do relógio, tanto de um estado para outro quanto para o mesmo estado

A B

Centrada = 0

entrada = 1entrada = 1entrada = 0

Estado Saída

A 0

B 0

C 1

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:


ENTITY maquina_estados ISPORT (

entrada : IN std_logic;clock : IN std_logic;saida : OUT std_logic);

END maquina_estados;

12

1

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

PROCESS (clock, entrada)BEGIN

CASE estado_atual ISWHEN A =>

saida <= ‘0’;IF (entrada = ‘1’) THEN

proximo_estado <= B;END IF;

12

2

WHEN B =>saida <= ‘0’;IF (entrada = ‘0’) THENproximo_estado <= C;

END IF;

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

END CASE;END PROCESS;

12

3

ATUALIZA_ESTADO : PROCESS (clock)BEGINIF (clock’event AND clock = ‘1’) THENestado_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

d = d + 2

r = d / 2

s = s + d + 1

s > x

DATA_OUT = r

Somador

Divisão por 2 =

Deslocador à

direita

Flag para controle

Maior / menor

Registradores

Multiplexadores

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

d = d + 2

r = d / 2

s = s + d + 1

s > x

DATA_OUT = r

Registradores

Dados dos registradores utilizados:

• Tamanho: N bits

• Possuem write enable

• Circuitos síncronosREG

Entrada Saida

WE

clk

N N

1

LIBRARY IEEE;

USE IEEE.STD_LOGIC_1164.ALL;

ENTITY reg_gen IS

GENERIC (N : POSITIVE := 8); -- Default value

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 reg_gen;

ARCHITECTURE behavior OF reg_gen IS

BEGIN

PROCESS(clk)

BEGIN

IF (clk'EVENT AND clk = „1') THEN

IF ( WE = '1') THEN

DATA_OUT <= DATA_IN;

END IF;

END IF;

END PROCESS;

END behavior;

clk

WES

1

WED

1

WEX

1

WER

1

D

S

R

X

d = 2; s = 4; x = DATA_IN

d = d + 2

r = d / 2

s = s + d + 1

s > x

DATA_OUT = r

Multiplexadores

Dados dos multiplexadores utilizados para D e S:

• Tamanho: N bits

• Possuem 2 entradas

• Circuitos Combinacionais

Entrada_1

N

Entrada_2

N

Saida

N

M

U

X

Seleção1

LIBRARY IEEE;


ENTITY mux_gen IS


PORT (

DATA_A, DATA_B : IN


SM : IN STD_LOGIC;

DATA_OUT : OUT

STD_LOGIC_VECTOR(N-1 DOWNTO 0)

);

END mux_gen;

ARCHITECTURE behavior OF mux_gen IS

BEGIN

PROCESS

BEGIN

IF (SM = '0') THEN

DATA_OUT <= DATA_A;

ELSE

DATA_OUT <= DATA_B;

END IF;

END PROCESS;

END behavior;

clk

WES

1

WED

1

WEX

1

WER

1

D

S

R

X

M

U

X

D

M

U

X

S

SMD

SMS

1

1

d = 2; s = 4; x = DATA_IN

d = d + 2

r = d / 2

s = s + d + 1

s > x

DATA_OUT = r

Somador

Cin = 0

Cin = 1

S – X =

S + (-X) + 1

(Complemento de 2)

Dados da ULA

• Tamanho: N bits

• Circuitos Combinacionais

• Para d + 2

• Entrada_1 = d

• Entrada_2 = 2

• Para s + d + 1

• Entrada_1 = d

• Entrada_2 = s

• Para s - x

• Entrada_1 = -x

• Entrada_2 = s

Entrada_1N

Entrada_2N

Saida

N

U

L

A

CIN1

LIBRARY IEEE;


ENTITY ula IS


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 ula;

ARCHITECTURE behavior OF ula IS

SIGNAL int_carry : STD_LOGIC_VECTOR(N-1

DOWNTO 0);

SIGNAL sum_t : STD_LOGIC_VECTOR(N-1

DOWNTO 0);

BEGIN

sum_t <= A(N-1 DOWNTO 0) XOR B(N-1

DOWNTO 0) XOR (int_carry (N-2 DOWNTO 0)

&Cin);

int_carry(0) <= ((A(0) OR B(0)) AND Cin) OR (A(0)

AND B(0));

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

Cout <= '1';

ELSE

Cout <= '0';

END IF;

END PROCESS;

Sum <= sum_t;

END behavior;

Necessário para S – X, mas

não para X – S

clk

WES

1

WED

1

WEX

1

WER

1

D

S

R

X

M

U

X

D

M

U

X

S

SMD

SMS

1

1 CIN= SM3

U

L

A

M

U

X

A

SM1

M

U

X

B

SM2

2

2

4

MUX_UL

A

N

d = 2; s = 4; x = DATA_IN

d = d + 2

r = d / 2

s = s + d + 1

s > x

DATA_OUT = r

Divisão por 2

Deslocador à

direita

Dados do deslocador

• Tamanho: N bits

• Desloca apenas à direita

• Circuito Combinacional

Entrada Saida

NN

D

E

S

L

LIBRARY IEEE;


ENTITY DESLOCADOR IS


PORT (

DATA_IN : IN


DATA_OUT : OUT

STD_LOGIC_VECTOR(N-1 DOWNTO 0));

END DESLOCADOR;

ARCHITECTURE behavior OF DESLOCADOR IS

BEGIN

DATA_OUT <= '0' & DATA_IN(N-1 DOWNTO

1);

END behavior;

clk

WES

1

WED

1

WEX

1

WER

1

D

S

R

X

M

U

X

D

M

U

X

S

SMD

SMS

1

1 CIN

U

L

A

M

U

X

A

SM1

M

U

X

B

SM2

2

2

4

MUX_UL

A

D

E

S

L

N

SM3

LIBRARY IEEE;


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);



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


PORT (clk : IN BIT;

DATA_IN : IN STD_LOGIC_VECTOR(N-1 DOWNTO 0);

WE : IN STD_LOGIC;


END COMPONENT;

COMPONENT DESLOCADOR IS


PORT (DATA_IN : IN STD_LOGIC_VECTOR(N-1 DOWNTO 0);


END COMPONENT;

COMPONENT ula IS


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


PORT MAP (sig_sula, sig_muxs1, sms, sig_muxs);

--

REGD : reg_gen


PORT MAP (clk, sig_muxd, wed, sig_d);

--

REGS : reg_gen


PORT MAP (clk, sig_muxs, wes, sig_s);

REGR : reg_gen


PORT MAP (clk, sig_desl, wer, sig_r);

--

REGX : reg_gen


PORT MAP (clk, DATA_IN, wex, sig_x);

--

MUXA : mux_gen


PORT MAP (sig_d, sig_muxa1, sm2, sig_muxa);

--

MUXB : mux_gen


PORT MAP (sig_muxb0, sig_s, sm1, sig_muxb);

MUXULA : mux_1

PORT MAP (sm2, sm1, sm3, cin);

--

Adder : ula


PORT MAP (cin, sig_muxa(15 downto 0), sig_muxb(15 downto 0), sig_sula(15 DOWNTO 0), N);

--

desl : DESLOCADOR


PORT MAP (sig_sula, sig_desl);

--

DATA_OUT <= sig_r;

END estrutural;

O diagrama de estados terá 4 estados, com o seguintefuncionamento:

Estado1 :d = 2;s = 4;x = DATA_IN;Valores de saída dos bits de controle

Estado2:d = d +2;r = d/2;Valores de saída dos bits de controle

Estado3:s = s + d + 1;Valores de saída dos bits de controle

Estado4:S > X ?Valores de saída dos bits de controle

s1

s2

s3

s4

ready/ ready

pronto/pronto

LIBRARY IEEE;


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 s1 =>

SAIDA <= "111101000";

IF (READY = '1') THEN

proximo_estado <= s1;

ELSE

PRONTO <= '0';


END IF;

--

WHEN s2 =>

SAIDA <= "001010000";


--

WHEN s3 =>

SAIDA <= "000100101";


--

WHEN s4 =>

SAIDA <= "000000110";

IF (NEG = '0') THEN

PRONTO <= '1';

proximo_estado <= s1;ELSE

PRONTO <= '0';


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;


ENTITY raiz IS

PORT (clk : IN BIT;

ENTRADA : IN STD_LOGIC;



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;



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;


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

http://www.altera.com/

[email protected]

[email protected]

[email protected]

@leocasillo

16

7

mailto:[email protected]



minicurso: tÓpicos em vhdl - ufersa.edu.br · características do vhdl – linguagem concorrente....

Documents