Folha de consulta de VHDL

De MediaWiki do Campus São José
Ir para navegação Ir para pesquisar

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];
Disponível em “https://wiki.sj.ifsc.edu.br/index.php?title=Folha_de_consulta_de_VHDL&oldid=194189”