Folha de consulta de VHDL

Estrutura do código VHDL

No código VHDL cada arquivo é composto pela estrutura básica na qual se declaram os LIBRARY / PACKAGE utilizados, em seguida se declara a ENTITY e a ARCHITECTURE.

• Declaração das bibliotecas e pacotes LIBRARY / PACKAGE

 library library_name;
 use library_name.package_name.all;

• Biblioteca std. Essa biblioteca e seus pacotes não necessitam ser declarados, pois já estão por default.

 library std;
 -- para utilizar os tipos BOOLEAN, CHARACTER, STRING, BIT, BIT_VECTOR, INTEGER, NATURAL, POSITIVE e suas funções
 use ieee.standard.all;

• Biblioteca ieee e seus pacotes mais utilizados:

 library ieee;
 -- para utilizar os tipos STD_LOGIC e STD_LOGIC_VECTOR e suas funções
 use ieee.std_logic_1164.all;

 -- para utilizar os tipos SIGNED e UNSIGNED e suas funções
 use ieee.numeric_std.all;

• Declaração da ENTITY

 ENTITY entity_name IS
   [generic (
     cons_name1: const_type const_value;
     cons_name2: const_type const_value;
     ...
     cons_nameN: const_type const_value);]
   [port (
     signal_name1: mode signal_type;
     signal_name2: mode signal_type;
     ...
     signal_nameN: mode signal_type);]
   [declarative_part]
 [begin
   statement_part]
 end [ENTITY] [entity_name];

• Declaração da ARCHITECTURE

 architecture arch_name of entity_name is
   [declarative_part]
 begin
   statement_part
 end [architecture] [arch_name];

• Declaração da CONFIGURATION

Essa declaração associa a ARCHITECTURE com a ENTITY. Se houver apenas uma arquitetura, ela não é necessária. Se houver mais de uma arquitetura para a mesma entidade, se não houver a declaração de configuração, a última arquitetura será associada a entidade.

CONFIGURATION nome_cfg OF nome_entity IS
	FOR nome_architecture END FOR;
END CONFIGURATION;

Tipos de dados

• Tipo BOOLEAN

Pode assumir os valores false e true

• Tipo BOOLEAN_VECTOR

É constituído de vários BOOLEAN agrupados. Pode ser declarado com índices ascendentes (TO) ou descendentes (DOWNTO).

NOTA - BOOLEAN_VECTOR apenas existe no VHDL 2008

• Tipo BIT

Pode assumir os valores

'0',  -- Forcing  0
'1',  -- Forcing  1

• Tipo BIT_VECTOR

É constituído de vários BITS agrupados. Pode ser declarado com índices ascendentes (TO) ou descendentes (DOWNTO).

-- Declaração de um SIGNAL do tipo BIT e BIT_VECTOR
SIGNAL <nome_b> : BIT;
SIGNAL <nome_bv> : BIT_VECTOR(<msb_index> DOWNTO <lsb_index>);
SIGNAL <nome_bv> : BIT_VECTOR(<lsb_index> TO <msb_index>);

-- Atribuição de valor a um SIGNAL do tipo BIT e BIT_VECTOR
<nome_b>   <= '0'; -- ou '1'
<nome_bv>  <= "01...0";

• Tipo INTEGER

Pode assumir valores inteiros de -2^(31) até 2^(31). Se não for limitado assume o RANGE máximo correspondente a 32 bits.

-- Declaração de um SIGNAL do tipo INTEGER
SIGNAL <nome_i> : INTEGER RANGE <low> TO <high>;
-- Atribuição de valor a um SIGNAL do tipo INTEGER
<nome_i>   <= 215;

• Tipo INTEGER_VECTOR

É constituído de vários INTEGER agrupados. Pode ser declarado com índices ascendentes (TO) ou descendentes (DOWNTO).

NOTA - INTEGER_VECTOR apenas existe no VHDL 2008

• Tipo STD_LOGIC

pode assumir os valores

'U',  -- Uninitialized
'X',  -- Forcing  Unknown
'0',  -- Forcing  0
'1',  -- Forcing  1
'Z',  -- High Impedance   
'W',  -- Weak     Unknown
'L',  -- Weak     0       
'H',  -- Weak     1       
'-'   -- Don't care

• Tipo STD_LOGIC_VECTOR

É constituído de vários STD_LOGIC agrupados. Pode ser declarado com índices ascendentes (TO) ou descendentes (DOWNTO).

SIGNAL <nome_sl>  : STD_LOGIC;
SIGNAL <nome_slv> : STD_LOGIC_VECTOR(<msb_index> DOWNTO <lsb_index>);
SIGNAL <nome_slv> : STD_LOGIC_VECTOR(<lsb_index> TO <msb_index>);

-- Atribuição de valor a um SIGNAL do tipo STD_LOGIC e STD_LOGIC_VECTOR
<nome_sl>   <= '0'; -- ou qual um dos valores possíveis 
<nome_slv>  <= "01...Z";

• Tipo UNSIGNED

É um STD_LOGIC_VECTOR sobre o qual se podem fazer operações aritméticas sem signal (apenas valores positivos). Deve ser declarado com índices descendentes (DOWNTO), para não haver problemas na interpretação dos resultados.

SIGNAL <nome_uns> : UNSIGNED(<msb_index> DOWNTO <lsb_index>);

-- Atribuição de valor a um SIGNAL do tipo UNSIGNED
<nome_uns>   <= "1101";   -- +13
<nome_uns>   <= "0101";   --  +5

• Tipo SIGNED

É um STD_LOGIC_VECTOR sobre o qual se podem fazer operações aritméticas com signal (pode ter valores positivos ou negativos). Deve ser declarado com índices descendentes (DOWNTO), para não haver problemas na interpretação dos resultados. O valor numérico corresponde ao complemento de 2.

SIGNAL <nome_sig> : UNSIGNED(<msb_index> DOWNTO <lsb_index>);

-- Atribuição de valor a um SIGNAL do tipo UNSIGNED
<nome_sig>   <= "1101";   --  -3
<nome_sig>   <= "0101";   --  +5

Instruções concorrentes

• Afirmação WHEN-ELSE

[rótulo:] <signal_alvo> <= 
	<valor> WHEN <condição> ELSE
	<valor> WHEN <condição> ELSE
	...
	<valor>;

• Afirmação WITH-SELECT

[rótulo:] WITH <expressão> SELECT
	<signal_alvo> <= 
		<valor> WHEN  <escolha>,
		<valor> WHEN  <escolha>,
	 	...
		<valor> WHEN OTHERS;

• Afirmação FOR-GENERATE

É preciso ter atenção que no VHDL apenas nas afirmação do tipo GENERATE o rótulo é obrigatório

 
  '''rótulo_obrigatório''': 
  FOR identificador IN faixa GENERATE
     [Parte_Declarativa
  BEGIN]
     afirmações_concorrentes
  END GENERATE [rótulo];

• Afirmação IF-GENERATE

É preciso ter atenção que no VHDL apenas nas afirmação do tipo GENERATE o rótulo é obrigatório

 
  '''rótulo_obrigatório''': 
  IF condição GENERATE
         afirmações_concorrentes
  END GENERATE [rótulo];

• Afirmação PROCESS

A afirmação PROCESS é uma instrução concorrente, mas internamente a ela todas as instruções/afirmações devem ser sequenciais

[rótulo:] PROCESS [(lista_de_sensibilidade)] [IS]
             [parte_declarativa]
         BEGIN
             afirmações_sequenciais;
         END PROCESS [rótulo];

Instruções sequencias

Essas instruções devem ser utilizadas dentro de um PROCESS, ou FUNCTION, ou PROCEDURE. Elas não podem ser usadas diretamente na ARCHITECTURE

• Atribuição de valor sobre SIGNAL:

[rótulo:] <signal_name> <= <expression>;

• Atribuição de valor sobre VARIABLE:

[rótulo:] <variable_name> := <expression>;

• Afirmação NULL que não faz nada

[rótulo:] NULL;

• Afirmação IF

[rótulo:] IF condição THEN
             afirmações_sequenciais;
         ELSIF condição THEN
             afirmações_sequenciais;
         ELSE
             afirmações_sequenciais;
         END IF [rótulo];

• Afirmação CASE

 [rótulo :] CASE expressão IS
              WHEN valor =>                             -- valor único
                 afirmações_sequenciais;
              WHEN valor1 | valor2 | ... | valorN  =>   -- lista de valores
                 afirmações_sequenciais;
              WHEN valor1 TO valor2 =>                  -- faixa de valores
                 afirmações_sequenciais;
              WHEN OTHERS  => 
                 afirmações_sequenciais;
          END CASE [rótulo];

• Afirmação LOOP incondicional:

[rótulo:] LOOP
                 afirmações_sequenciais;
          END LOOP [rótulo];

• Afirmação FOR-LOOP:

[rótulo :] FOR identificador IN faixa LOOP
                 afirmações_sequenciais;
          END LOOP [rótulo];

• Afirmação WHILE-LOOP:

[rótulo :] WHILE condição LOOP            -- Executa as "afirmações enquanto a "condição" for verdadeira
                 afirmações_sequenciais;
          END LOOP [rótulo];

• Afirmação LOOP com EXIT:

[rótulo :] [FOR identificador IN faixa] LOOP
             afirmações_sequenciais;;
             -- EXIT incondicional.
             EXIT [rótulo_loop];
             -- EXIT condicional.
             EXIT [rótulo_loop] WHEN condição;	-- Se a "condição" é verdadeira, termina o "LOOP"
             afirmações_sequenciais;
          END LOOP [rótulo];

• Afirmação LOOP com NEXT:

[rótulo :] [FOR identificador IN faixa] LOOP
             afirmações_sequenciais;
             -- NEXT incondicional.
             NEXT [rótulo_loop];                  -- Não executa as linhas até a linha "END LOOP", e incrementa o "identificador".
             -- NEXT condicional.
             NEXT [rótulo_loop] WHEN condição;	 -- Se a "condição" é verdadeira, não executa as linhas até a linha "END LOOP", e incrementa o "identificador".
             afirmações_sequenciais;
          END LOOP [rótulo];