RESUMO DE DICAS VHDL

1 No se podem declarar variveis dentro de arquitetura variveis so declaradas dentro de

processos.

1a- Entre blocos da arquitetura s h sinais ligando os blocos.

2 No se pode declarar um sinal dentro de um Process (apenas variveis), mas pode-se atribuir o
valor de uma varivel a um sinal, ou realizar operaes entre sinais e variveis.

3 Sinais podem ser usados dentro de um Process, mas atribuies a sinais dentro de processo
podem causar resultados inesperados porque a atribuio do valor retardada at que um
comando WAIT seja executado. O mesmo ocorre se o processo for disparado por alguma mudana
em um ou mais elementos da lista de sensibilidades, que equivalente a executar um WAIT no final do
processo.

4 Sinais so usados para fazer comunicao entre processos e tambm so usados para interligar
(wire) projetos estruturais (projetos que explicitam a interligao fsica dos mdulos, sem detalhar o
comportamento de cada mdulo).

5 Dentro de um processo, atribuies a sinais podem enviar dados para outros processos (disparando-
os).

6 Dentro de um processo, valores de sinais podem ser usados do lado direito de expresses para
atribuir valores a variveis.

7 IMPORTANTE: Dentro de um processo, a atribuio a um sinal retardada (no feita) at que um

ciclo de simulao seja rodado, sendo disparado pela execuo de um comando WAIT, ou atravs da
mudana de um sinal na lista de sensibilidades, o que tambm feito no final do processo. Exemplo:
Process
Begin
Sys_clk <= NOT (sys_clk) after 50 ns;
Int_bus <= data_in after 10 ns;
Data_out <= my_function (int_bus) after 10 ns;
WAIT 30 ns; -- s aps 30 ns aps o tempo de simulacao anterior
-- que sys-clk, int_bus e data_out vao mudar,
-- com seus respectivos atrasos !!
8 Dentro de um processo (atribuies sequenciais) um sinal s pode ter atribudo um valor de cada
vez. Ex.:
Process
Begin
Xyz <= 1 after 4 ns;
Pqd <= 10 after 5 ns;
Xyz <= 2 after 4 ns; -- s esta atribuio realizada !
WAIT ----
---- -
end process;

9 ATRASO DE SINAIS Quando uma atribuio de sinal simulada, a mudana de sinal ocorre num
instante preciso de tempo simulado (isto j no se pode precisar na sntese do circuito). Tais atribuies
de atraso nos sinais servem para simulao, mas no servem para sntese. Quando ser for sintetizar o

1
circuito devem-se usar clocks e contadores para gerar os atrasos necessrios. Veja-se um exemplo
abaixo, que para simulao est OK, mas para sintetizar no serve:
signal x : integer;
process ---
begin
---- -
x <= x + 1 after 10 ns; -- para sintetizar precisa usar registro c/ clock para
--- - -- construir um contador e garantir esse tempo.
end;

10 ATRASO ZERO Atribuies de sinais podem especificar atraso ZERO, bastando no indicar a
clusula de atraso AFTER; Ex: x <= x+1;

11 Exemplo de MUX usando atribuio de sinais com ZERO DELAY:

entity VAR is
port (A : in BIT_VECTOR (0 to 7);
INDEX : in INTEGER range 0 to 7;
OUTPUT : out BIT);
End VAR;
Architecture VHDL_1 of VAR is
Begin
Process
Begin
OUTPUT <= A (INDEX); --- schedulado em 0 ns; (0ns aps o que for especificado
WAIT -- -- pelo WAIT)
---- -
end VHDL_1;
---- MESMO COM ZERO DELAY precisa ter o comando WAIT !

11 SIGNAL ASSIGNMENT VARIABLE ASSIGNMENT

-------------------------------
- valores de sinais so schedulados
- valores de sinais podem ter atraso
- valores de sinais so atualizados s
aps o WAIT ser executado.
------------------------------------
- valores de variveis no so schedulados
- valores de variveis so especific. S/atraso
- val. de variv. so atualiz. imediatamente

Ex1: V := 1;
S <= V;
A := S; -- A recebe o valor velho de S e no V (ou 1);
WAIT ---;

Ex2: X <= 1;
X <= 2;
WAIT for 0 ns; -- Aps o wait ser executado, x recebe valor 2.

12 FORMAS DE WAIT:

WAIT ON A, B; -- suspende execuo do processo at que ocorra evento em A ou B.

WAIT UNTIL A> 10; -- susp. Exec. do processo at que ocorra evento em A e A>10.
WAIT FOR 10 ns; -- susp. Exec. Do processso por 10 ns (tempo de simulao).

2
WAIT; -- suspende exec. Do processo para sempre usado em processos de inicializao. Nao h
modo de matar um processo em VHDL.

13 Ao invs de ter um ou mais comandos WAIT dentro de um processo, pode-se usar uma lista de
sensibilidade. equivalente a ter um WAIT no fim do processo. NO SE PODE TER LISTA DE
SENSIBILIDADES E WAIT AO MESMO TEMPO NUM PROCESSO.

Ex.: Simulao Passo Simples: Simulao Dois Passos

(Maioria dos Compilad. VHDL)
Process (A, B) Process (A, B, S, T)
Begin begin
S<= A; S <= A;
T <= B; T <= B;
V <= S or T; V <= S or T;
End process; end process;
-- usa valores velhos de S, T para V -- Atualiza o valor de S, T para V em dois
-- passos de delta time(tempo de simul.Zero)

14 O LOOP FOR:

architecture ----- of decoder is procedure ODD_PARITY (

begin A: in BIT_VECTOR (0 to 7);
process (BUS_A) -- type integer RESULT : INOUT BIT ) is
begin begin
for K in 0 to 3 loop RESULT <= 0;
D (K) <= (BUS_A = k); for m in 0 to 7 loop
End loop; RESULT <= RESULT xor A (m);
End process; End loop;
End architecture; End ODD_PARITY;

PROCESSO OK. ERRO: MULTIPLAS ATRIBUIES NO

MESMO PASSO DE SIMULAO.
SO GUARDA ULTIMO => A(7) !!.

15 Restrio de RANGE uma restrio de range usa valores que deveriam ser compatveis com o
tipo que esto relacionadas, e estar numa direo compatvel com a declarao original do tipo. O valor
inicial default o extremo inferior do range.
Ex:
Integer range 1 to 10 == NAO == integer range 10 to 1
Integer range 10 downto 1 == NO == integer range 1 downto 10

real range 1.0 to 10.0 == NO == real range 1 to 10

Em alguns casos deseja-se toda a faixa : integer

16 Declarao de Sinais

Sinais podem ser declarados em diversos lugares: entidade, arquitetura ou num package.

3
 Sinais podem ser abstraes de fios fsicos, de barramentos, ou usados para documentar fios num
circuito real. Um sinal deve ser declarado com um tipo, antes de ser usado. A sintaxe :

Declarao de sinal:
Escalar : signal name(s) : type [range_constraint][:=expression];
Array: signal name(s) : array_type[index_constraint][:=expression];
Entity: port (name(s): direction type [range_constraint][:=expression];

Se se deseja incializar um sinal, deve-se indicar um literal em [:expresso].

Ex:
Signal S: BIT := 1;
Signal GROUND: BIT := 0;

Caso contrrio, o valor default inicial o valor mais baixo daquele tipo.

17 EXPRESSES:

Alm dos tipos padro (standard), algumas empresas fornecem tipos de dados estendidos e operadores
sobrecarregados (funes), tal como declarado num package. Algumas empresas podem fornecer
operadores com converso automtica de tipos, mas o Package STANDARD no fornece tais
operadores.

Ex:
Geralmente operandos tem que ser do mesmo tipo. No h converso automtica de tipos.
Exemplo NO SE PODE ESPECIFICAR:

1 + 1.0

Exemplo de Converso de tipos:

Integer (3.0) tipo integer
Real (3) tipo real
Integer * time tipo time
Nanos + picos tipo time
Nanos/picos

18 Resumo de Operadores: NOTA: Parnteses podem alterar a precedncia.

Precedncia OPERADORE OPERANDOS

Operadores S
MENOR Lgicos And Lgico Mesmo tipo
And Or Lgico Mesmo tipo
Or Complem. And Mesmo tipo
Nand
Nor Complem. Do Or Mesmo tipo
Xor Ou exclusivo Lgico Mesmo tipo
Operadores = Igual Mesmo tipo
Relacionais /= No igual Mesmo tipo
< Menor que Mesmo tipo
<= Menor ou igual que Mesmo tipo
> Maior que Mesmo tipo
>= Maior ou igual que Mesmo tipo

4
 Operador de
Concatenao & Concatenao
Operadores + Adio Mesmo tipo
Aritmticos - Subtrao Mesmo tipo

Operadores + Mais Unrio Qualquer numrico

Aritmticos - Menos Unrio Qualquer numrico

Operador * Multiplicao Mesmo tipo

Aritmtico / Diviso Mesmo tipo
mod Mdulo Inteiro
rem Resto Inteiro

MAIOR Operador ** Exponenciao Exp. Inteira

Aritmtico abs Valor Absoluto Qualquer numrico

Operadores not Complemento Mesmo tipo

Lgicos

19 OPERADORES

Operadores Lgicos trabalham com tipos BIT, BOOLEAN, STD_LOGIC, vetores de tamanho igual
e NO EM INTEIROS.

Operadores Relacionais trabalham com qualquer tipo de escalar ou tipo array UNI-DIMENSIONAL
cujo tipo de elemento um tipo discreto (enumerao ou inteiro).

Operadores Aritmticos trabalham com inteiro, real e STD_LOGIC_VECTOR.

Em alguns casos operadores so especificaes para um bloco de hardware para ser construdo usando
ferramentas de sntese lgica. A adio inteira (+) poderia produzir um somador de 32 bits, a menos
que o usurio especifique um tipo explcito (comprimento do somador). O exemplo abaixo representa
um somador de 8 bits (ao invs de 32), com fios a, b, e x. Por exemplo:

Variable a, b, x : integer range 0 to 255;

x := a + b;

Normalmente VHDL requer que a soma seja do mesmo comprimento das parcelas. Para dar conta do
vai um do bit mais significativo da soma, faz-se:

Variable a, b : STD_LOGIC_VECTOR (8 downto 1);

5
 Variable x : STD_LOGIC_VECTOR (9 downto 1);
x := 0&a + 0&b;

20 O que significa isto?

X <= A <= B; ( A menor ou igual a B ?? )

Significa : compare A com B, e o resultado booleano produzido atribua ao sinal X.

21 Aritmtica IEEE Std_Logic_Vector

O package STANDARD no permite aritmtica em bit_vectors. Alguns vendedores fornecem um

package aritmtico que funciona com std_logic_vectors. Portanto, o tipo std_logic_vector
geralmente o tipo de dados mais usado para sntese e simulao. Entretanto, existe uma ambiguidade ao
interpretar o valor de um std_logic_vector. Por exemplo:

1011 => valor sem sinal 11 (onze)

1011 => valor com sinal 5, em complemento a 2.

Deve-se declarar o tipo de package aritmtico que se quer usar, ou seja:

Use IEEE.std_logic_signed.all;
Use IEEE.std_logic_unsigned.all;

Os pacotes definem operadores lgicos, relacionais e aritmticos. Ex:

1011> 0011

A expresso tem duas interpretaes, dependendo da seleo de package:

11 > 3 Nmeros sem sinal (verdadeiro)

-5 > 3 Nmeros com sinal (falso)

Ao usar expresses aritmticas literais, o nome dos subtipos signed e unsigned podem ser usados para
indicar o tipo nico de operador desejado. Por exemplo:

Signed(1011) > Signed(0011)

Como ambos os operandos so signed, o perador de comparao (>) signed, e produz um FALSE.

22 Novos operadores VHDL93:

sll shift left logical ror - rotate right

sla shift left arithmetic srl - shift right logical
rol rotate left sra - shift right arithmetic
xnor exclusive nor

23 LITERAIS SO CASE SENSITIVE EM VHDL

24 OS TIPOS DE DADOS SO DECLARADOS EM PACKAGES COMO ABAIXO:

PACKAGE DATA TYPES

6
Package STD_LOGIC_1164 Std_logic
Std_logic_vector

Package STD_LOGIC_ARITH Signed, unsigned

Package TEXTIO File, Line

Package STANDARD Boolean, bit, character, time,

String, bit_vector,
Natural, positive,
Severity_level

VHDL Language Integer, real

25 Convertendo tipos BIT para BOOLEAN ( 1 torna-se true):

variable XXX : BIT;

variable ZZZ : Boolean;

ZZZ := ( XXX = 1);

26 LITERAIS BIT e BOOLEAN !!

BIT o valor de um sinal num sistema digital. Um literal bit representa dois valores discretos atravs
do uso os literais caracteres 0 ou 1, bit(1). O standard IEEE 1164 define nove foras (U, X,
0, 1, Z, L, H, etc) de sinal num package VHDL para o tipo STD_LOGIC. Estes nove valores so
mais teis para simulao e sntese do que o tipo BIT puro. (Devido a isto, os tipos BIT e BOOLEAN
(true, false) so diferentes ).

BOOLEAN Um literal Booleano representa dois valores discretos somente: TRUE ou FALSE. Um
literal booleano no um um literal BIT, nem tem relao com ele !!. Um BOOLEANO pode ser
testado numa sentena IF. O valor default falso para valores no incializados.

Operadores relacionais, como =, <=, >=, /=, etc produzem um resultado BOOLEANO.

Um sinal booleano comumente usado para expressar o estado de um sinal eletrnico ou Bus, sem
escolher o valor real de voltagem eltrica (ou uma das foras tipo BIT). Portanto, um Boolean uma
representao abstrata. O package STANDARD no predefine um array de valores booleanos.

27 Algumas sentenas vlidas e invlidas de acordo com o tipo dos operadores:

Seja a declarao de tipos:

Variable A, B, C, D : BIT_VECTOR (3 downto 0);

Variable E, F, G : BIT_VECTOR (1 downto 0);
Variable H, I, J, K : BIT;

7
1) A := B xor C and D; Invlida precisa parnteses pois os 2 operadores lgicos tem o
mesmo nvel e se trocar a ordem troca o resultado. Alm disso
o tipo no BOOLEAN e deveria ser.

2) H := I and J or K; Invlida No pode fazer operaes lgicas, pois o tipo deveria

ser BOOLEAN e NO BIT.

3) A := B and E; Invlida Tipos misturados

4) H := I or F; Invlida Tipos misturados

28 Funes e Procedimentos podem ser declarados numa entidade, arquitetura ou package, mas
so instanciados dentro de processos e portanto so sequenciais. H uma exceo para procedure
call concorrente que pode ser usada dentro da arquitetura ver item 43.

Funo recebe um ou mais parmetros e retorna um (1) s valor.

Funo NO pode conter sentena WAIT.

Procedimento como uma funo, mas podem ser retornados mais de um valor, usando parmetros. Os
parmetros so do tipo IN, OUT e INOUT. Os parmetros podem ser variveis ou sinais.
Procedimentos usam a sentena RETURN sem valor.
Procedimento PODE conter sentena WAIT e parmetros tipo sinal podem passar sinais para
serem esperados na sentena WAIT.

O procedimento tem que ser declarado num package, no cabealho de um processo ou na declarao de
uma arquitetura antes de ser chamado.

29 EXEMPLO COM TIPOS ENUMERADOS

architecture behave of cpu is

type instruction is (add, lda, ldb);

begin process
variable a, b, data : integer;
variable instruct : instruction;
begin
....
case instruct is
when lda => a := data; -- load a accumulator
when ldb => b := data; -- load b accumulator
when add => a:= a + b; -- add two acuumulators
end case;
wait on data;
end process;
end behave;

Note-se que durante a sntese lgica ser realizada uma codificao numrica para o CASE, que poder
introduzir estados invlidos, ou seja, associando 00 a lda, 01 a ldb e 10 a add, o que seria associado
quando um valor numrico 11 fosse gerado ?? Seria prudente associar um valor (e.g. invalido) ao valor
11 e tomar alguma atitude caso ele acontecesse, ao invs de deixar indefinido.

8
30 Expresses Qualificadas

difcil distinguir entre o caracter 1, o bit 1 ou std_logic 1. difcil saber com segurana o tipo
de literal que ele , pois precisa-se saber o contexto. Precisa-se typecasting ser explcito no tipo de um
valor. Isto pode ser feito usando uma expresso qualificada. Exemplo:

Bit(1)
Outro exemplo :

Type months is (April, May, June);

Type name is (April, June, Judy);

June de tipo ambguo (April tambm) em alguns contextos. Voc pode qualificar June e explicar
exatamente o que June representa em VHDL com a expresso qualificada:

Months(June)
Name(June).

Quando um tipo tem valores compartilhados com outros tipos, pode ser necessrio tornar claro isso,
fazendo um casting de um literal para um tipo particular. A sintaxe :

expresso_qualificada
type(literal ou expresso).
No confundir uma expresso qualificada com uma funo que realiza converso.

Ex: Qual a diferena entre integer (3.0) e integer (3.0) ?

a integer (3.0) um call legal para uma funo de converso de real para inteiro.
b integer(3.0) uma expresso invlida pois no se pode fazer cast do tipo real para o
tipo inteiro.

31 - Subtipos escalares

subtype digit is integer range 0 to 9;

variable MSD, NSD : digit;

type instr is (add, sub, mul, div, sta, stb, outa, xfr);
subtype arith is instr range add to div; -- subconjunto de instr.
subtype pos is integer range 1 to 2147483647; -- subconjunto de inteiros
subtype nano is time range 0 ns to 1 us; -- subconjunto de tempo

32 Atribuio de ARRAYS

Atribuio de um BIT_VECTOR usando algumas variveis:

C := 1010; -- atribuio de constante

C := S & T & M & W; -- 4 sinais de 1 bit concatenados
C := (1, 0, 1,0); -- 4 bits agregados
C := 3; -- invlido pois tipo BIT_VECTOR e 3 inteiro

33 AGREGADOS

9
Um array literal pode conter uma lista de elementos tanto com notao posicional como com notao
nomeada, formando um tipo agregado. A sintaxe :

[type_name] ([choice => ] expression {, [others => ] expression})

type_name pode ser qualquer tipo de array limitado.

Ex:
Variable X : BIT_VECTOR (1 to 4);
Variable A, B: BIT;

X := BIT_VECTOR(1, A nand B, 1, A or B); -- OU .

X := (1 => 1, 4 => A or B, 2 => A nand B, 3 => 1);

X(1) recebe 1
X(2) recebe (A nand B)
X(3) recebe 1
X(4) recebe (A or B)

34 Declaraes tipo ARRAY

Ex: TYPE RAM IS ARRAY (1 to 8, 1 to 10) OF bit;

TYPE word8 is array (integer range 1 to 8) OF bit;

Exemplo de array sem limites: type BIT_VECTOR is array (natural range <>) of BIT;

ARRAYS MULTIDIMENSIONAIS
Type memory is array (0 to 7, 0 to 3) of bit;
Constant ROM : memory := ( (0,0,0,0),
(0,0,0,1),
========
(0,1,1,1));
Exemplo de referncia:
Data_bit := ROM (5,3);

ARRAY de ARRAYS

Type word is array (0 to 3) of Bit;

Type memory is array (0 to 4) of word;
Variable addr, index : integer;
Variable data: word;
Constant rom_data : memory := ( (0,0,0,0),
(0,0,0,1),
(0,0,1,1),
========
(0,1,1,1));
data := rom_data (addr);
rom_data (addr) (index) -- para acessar um bit somente.

35 SUBTIPOS DE ARRAY

10
Pode ser conveniente declarar um novo tipo (subtipo) de um tipo de array. Isto feito atribuindo limites
ao tipo de array ilimitado. Por exemplo:

Subtype byte is bit_vector (7 downto 0);

Variaveis agora podem usar o subtipo, assim:

Variable xyz : byte;

36 PROCEDURE- Parametros de

O modo dos parmetros IN, OUT e INOUT. Os parmetros podem ser sinais ou variveis. Se no
declarados como sinais, o default serem variveis.

Exemplo:

PROCEDURE vector_to_int (z: IN bit_vector (1 to 8);

Zero_flag : OUT boolean;
Q : INOUT integer) is
BEGIN
Q := 0;
Zero_flag := TRUE; -- para zero;
FOR i in 1 to 8 LOOP
Q := Q * 2; -- Q dos 2 lados do operador atribuio => INOUT !!!
IF (z(i) = 1) THEN q := q + 1;
Zero_flag := FALSE; -- para no zero
END IF;
END LOOP;
Return;
END vector_to_int;

NOTA: Q do tipo INOUT porque usado dos dois lados da atribuio.

37 Subtipos Escalares

type instr is (add, sub, mul, div, sta, stb, outa, xfr);
subtype arith is instr range add to div; -- sbuset of instr

subtype pos is integer range 1 to 2147483647; -- subset of integers

subtype nano is time range 0 ns to 1 us; -- subset of time

38 Tipos Compostos RECORDS

11
Type two_digit is
RECORD sign : bit;
Msd : integer range 0 to 9;
Lsd : integer range 0 to 9;
END RECORD;

PROCESS
VARIABLE ACNTR, BCNTR : two_digit;
BEGIN
ACNTR.sign := 1;
ACNTR.msd := 1;
ACNTR.lsd := ACNTR.msd;
BCNTR := two_digit(0,3,6);
END PROCESS;

39 Tipos predefinidos: TEXTO E LINHAS

Usados para operaes de Entrada e Sada durante simulao. Estes tipos so usados numa declarao file com
funes read, write e end-of-file. Arquivos do tipo texto so tratados como grupos de linhas.

Na biblioteca STD, existe um conjunto de funes e tipos no Package TEXTIO que so predefinidos. Os
procedimentos de entrada no package TEXTIO so readline e read. Os procedimentos de sada no package
TEXTIO so writeline e write. Por exemplo:

Readline (F: In TEXT; L : out LINE); -- L uma linha do arquivo F na varivel L

Read (L: Inout Line; ITEM : integer); -- L um item da linha L na varivel ITEM.

Lendo dados de um arquivo uma operao de dois estgios. Por exemplo:

a : process ...
file testvectors : TEXT is in test.vec;
variable L : Line;
variable av, bv : bit_vector (3 downto 0);
begin
readline (testvectors, L);
read (L, av);
bv := av;
- - - - - - - - - -

Continuando ..

preciso criar uma referncia para o package desta biblioteca antes de fazer I/O de texto:
Use STD.TEXTIO.ALL;
Alm disso, h duas funes que retornam valores Booleanos que indicam condies EOF ou EOL.
ENFILE (filename)
ENDLINE(filename)

Exemplo completo:
USE STD.TEXTIO.ALL;
ENTITY copy4 IS
END copy4;
ARCHITECTURE first OF copy4 IS
BEGIN
PROCESS (go)
FILE instuff : TEXT IS IN /path/test.data;
FILE outfile: TEXT IS OUT /path/new.data;
VARIABLE L1, L2 : LINE;
VARIABLE av: bit_vector (3 downto 0);
BEGIN
WHILE NOT (ENDFILE(instuff)) LOOP

12
 READLINE (instuff, L1); -- l uma linha do arquivo de entrada
READ (L1, av); -- L um valor da linha
WRITE (L2, av);
WRITELINE (outfile, L2);
END LOOP;
END PROCESS;
END first;

O arquivo de dados test.data contm:

0011
00_11
1100
16#F#
1010 1011
Underscores so permitidos e ignorados. Smbolos # indicam um nmero numa base diferente (por
exemplo, base 16). Dados do tipo bit e bit_vector no tem aspas. Tipos enumerados, que utilizam
identificadores no podem ser lidos ou escritos com TEXTIO.

40 Tipos ACCESS

Tipos Access no so suportados por ferramentas de sntese, mas podem ser usados durante simulao.
Tipos Access so semelhantes a ponteiros em linguagens de programao. Eles auxiliam a construir
estruturas na memria do simulador, que podem ser de tamanhos variados. Eles permitem ao usurio
declarar dinamicamente quando memria necessria para um item e para alocar memria do simulador
quando necessria para guardar novos itens criados. Variveis do tipo access so ponteiros que podem
ser manipulados. Um uso tpico de tipos de acesso para criar uma estrutura de lista linkada.

O operador NEW faz com que o sistema do simulador aloque armazenamento para um item
(tipicamente um record) e ele retorne o endereo de onde o novo item armazenado na memria do
simulador. Uma outra operao DEALLOCATE, que deleta um item da memria. Vejam-se os
exemplos abaixo:

Type two_digit is record - - - --

Type pntr is access two_digit; -- pntr um ponteiro
Variable xptr: pntr; -- uma varivel ponteiro para acessar um record

Example of storage allocation:

Xptr := new two_digit; -- aloca espao para o endereo de um record em xptr.

Um exemplo de desalocar memria:

Deallocate (xptr);

Para acessar elementos no record, use o nome do campo selecionado com o ponteiro. Por exemplo:
Xptr.msd := 1001;

41 CICLO DE SIMULAO

Os simuladores de primeira gerao usavam uma tcnica que os desenvolvedores de sistemas CAD chamam
algoritmo de uma lista, que relativamente rpido mas que no consegue lidar com eventos paralelos de
atraso zero, tais como trocar os valores de A e B. O significado e os problemas que esto associados com esta
atribuio de sinais com atraso zero pode ser ilustrado por um exemplo simples:

A <= B; -- atraso zero A recebe o valor velho de B

B <= A; -- atraso zero A j trocou para o valor velho de B e portanto B recebe o

13
 -- valor velho de B.

Este exemplo no trocaria os valores de A e B, mas daria a A e a B o valor velho de B, usando o algoritmo de uma
lista.

Simuladores VHDL modernos usam um algoritmos de duas listas que verificam os valores anteriores e os
novos dos sinais. Neste mtodo, as expresses so primeiro avaliadas e depois os sinais so atribudos novos
valores. Em VHDL, o cdigo exemplo acima realiza uma troca de dados entre os dois sinais A e B, em algum
ponto do tempo de simulao (algum instante). Em operao, os valores velhos de B e A so buscados e
schedulados para atribuio, para atraso zero, aps uma sentena WAIT subsequente ser executada.

Este comportamento de duas fases do ciclo de simulao VHDL natural para projetistas de hardware que esto
acostumados com flip-flops clockados Master/Slave.

A ordem dos eventos de atraso zero tratada com uma unidade de tempo fictcia chamada delta time. Delta
time representa a execuo de um ciclo de simulao, sem avanar o tempo de simulao.

Os pontos chaves de simulao e delta time so:

simulador modela eventos de atraso zero usando delta time.

Eventos schedulados ao mesmo tempo so simulados em ordem especfica durante um passo de delta time.
A lgica relacionada ento resimulada para propagar os efeitos para outro passo de delta time.
Passos de delta time continuam at que no haja mais atividade para o mesmo instante de delta time.

14
O ciclo de simulao VHDL mostrado abaixo:

Execuo de Processos Tempo

Atribuies de Sinais Avaliao de Sinais

Entra Comeo Meio Fim Sai

Todas as atribuies do lado direito (avaliaes)

so calculadas aps atribuies serem feitas

A execuo de uma sentena WAIT ou uma mudana de um parmetro numa lista de sensibilidades
disparam a entrada num ciclo de simulao. O ciclo de simulao comea no tempo de entrada.

Os simuladores VHDL fazem todas as atribuies de sinais com valores previamente computados
e schedulados. Como alguns valores de sinais mudam, alguns processos podem ser ativados.
Ento, o ciclo de simulao vai atravs do tempo do meio e processos ativos so executados.
Sentenas de atribuio a variveis so executadas; expresses do lado direito das atribuies de
sinais so avaliadas.
Elementos que precisam ser schedulados so avaliados para se obterem os valores apropriados.

Pode ser necessrio voltar ao comeo sem na verdade avanar o tempo simulado. Este ciclo chamado
um passo delta time. Delta time a iterao sem o avano do tempo de simulao. Um simulador
poderia dar diversas voltas neste loop fazendo avaliaes a atribuies, sem avanar o tempo simulado.
Quando no forem disparados mais processos , o ciclo de simulao vai para o tempo Sai, e o tempo de
simulao ento avanado.

Notem-se 3 processos concorrentes na figura abaixo, que so disparados de acordo com suas listas de
sensibilidade. O processo A iniciado com a mudana do sinal CK e produz uma mudana no estado do
sinal Sa. O processo B disparado quando o sinal Sa muda de estado e este por sua vez faz com que o
sinal Sc mude e o Processo C seja ativado. Note-se tambm que as execues dos processos esto
acontecendo sem que o tempo de simulao seja avanado pois ainda no se estabilizaram as
mudanas. O processo C ao ser ativado faz com que o sinal Sd mude de estado. Isto faz com que o
processo A seja NOVAMENTE ativado (completou-se um loop). O procedimento transcorre at que
todos os sinais tenham estabilizado. A ento o tempo de simulao avanado.
Sa Sf
Ck PROCESSO A (ck,Sd) PROCESSO B (Sa, SeSg)
Se

Sb Sg
Sd
42 Atribuies Concorrentes a Sinais
PROCESSO C (Sc, Sb)
Sc
Alm de poder atribuir valores a sinais dentro de processos concorrentes, o que torna os sinais
concorrentes, possvel fazer atribuioes a sinais fora dos processos, o seja, dentro da arquitetura. Isto

15
similar a escrever um processo o qual s faz atribuir um valor a um sinal. Desta forma, as atribuies
a sinais dentro da arquitetura so concorrentes.

Architecture ARQ1 of XYZ is

Begin
Saida1 <= A (index); -- saida1 e saida2 sao concorrentes
Saida2 <= B (index);
End ARQ1;

Note-se que na forma concorrente acima, qualquer sinal usado no lado direito da atribuio est (por
default) na lista de sensibilidades. A qualquer hora que o sinal mudar, a atribuio concorrente
avaliada e um valor atribudo ao sinal.

Formas de Atribuies Concorrentes a Sinais:

Alvo <= Expresso -- operao lgica, comparativa ou aritmtica

Condicional -- similar a sentenas IF
Selecionada -- semelhante a sentena CASE

Atribuies Condicionais a Sinais:

Exemplo:
Z <= A when (x>3) else
B when (x<3) else
C;

NOTA: NO SE PODEM FAZER ATRIBUIES CONDICIONAIS A SINAIS DENTRO DE

PROCESSOS !!!!

Atribuies Selecionadas a Sinais Usando Expresso With:

With MEUSINAL select

Z <= A when 15, -- S pode ter um alvo
B when 22,
C when others;

Este tipo de atribuio usado fora de um processo. Como uma atribuio concorrente, roda quando
ocorrer qualquer mudana no sinal selecionado, no exemplo o sinal MEUSINAL. Esta uma forma
reduzida de escrever um processo com uma sentena CASE.

NOTA: NO SE PODEM FAZER ATRIBUIES CONDICIONAIS A SINAIS DENTRO DE

PROCESSOS !!!!

43 Procedure Call Concorrente

Outra forma de sentena concorrente uma procedure call concorrente. Uma procedure call concorrente
uma procedure call que executada fora de um processo.

Procedure Call Concorrente:

Tem parametros IN, OUT e INOUT.
Muitas tem mais que um valor de retorno.
considerada uma sentena.
equivalente a um processo contendo uma s procedure call.

16
Procedure Call Concorrente: => Equivale a: Procedure Call dentro de um Processo:
Architecture Architecture
Begin Begin
Vector_to_int (bitstuff, flag, number); Process
End; Begin
Vector_to_int (bitstuff, flag, number);
Wait on bitstuff, number;
End process;
End;

Ela disparada nos dois casos quando algum dos seus parametros de entrada mudar.

44 Sentenas Block:

Uma sentena Block contm um conjunto de sentenas concorrentes e especialmente til para
organizar um projeto. Pode-se usar Block para particionar uma netlist estrutural. A sintaxe :

Block_statement
{label:} block [(expresso booleana)]
{declaraes}
begin
stentenas_concorrentes
end block [label];

Declaraes declaram objetos locais ao bloco e podem ser qualquer uma das seguintes;

USE --clausula
Subprograma -- declarao e corpo
Tipo, constantes, sinais -- declaraes
Componente declarao

A ordem das sentenas concorrentes num bloco no importante pois todas as sentenas esto sempre
executando. Os blocos podem ser aninhados no cdigo fonte para organizar e criar a hierarquia. Objetos
declarados dentro de um BLOCK so visveis dentro daquele bloco e todos os seus sub-blocos
(aninhados a ele). Se um bloco filho (dentro de um bloco pai) declara um objeto com o mesmo nome
do bloco pai, tal declarao redefine a declarao do bloco pai (overwrite).

B1 : block
Signal S: BIT; -- Declarao de S no bloco B1
Begin
S <= A and B; -- S de B1
B2 : block
Signal S: BIT; -- Declarao de S, bloco B2
Begin
S <= C and D; -- S de B2
B3: block
Begin
Z <= S; -- S de B2
End block;
End block;
Y <= S;
End block;

45 VHDL ESTRUTURAL

17
18