Aritmética com vetores em VDHL

Um pouco de história..

Quando VHDL saiu em 1987, não havia previsão para tratamento lógico para valores com múltiplos valores. Os tipos de lógica estavam disponíveis apenas para bits ('0' e '1') e booleanos (TRUE e FALSE), os quais são apenas do tipo dois valores. Inicialmente, cada fornecedor de ferramenta de síntese criou seu próprio Pacote(Package) para o tratamento de múltiplos valores, o que levou a uma falta de portabilidade.

No padrão "IEEE Standard Multivalue Logic System for VHDL Model Interoperability (Stdlogic1164)" foi definido o valor resolvido para lógica com múltiplos valores do tipo std_logic. Assim o std_logic tornou-se o tipo de lógica padrão em projeto VHDL.

Uma segunda característica que faltava no VHDL original era uma maneira padrão de fazer operações aritméticas com tipos bit_vector e std_logic_vector. Novamente fornecedores de síntese desenvolvido seus próprios pacotes, alguns dos quais tornaram-se muito utilizado, mas em seguida, o IEEE criou "IEEE 1076.3 Standard VHDL Synthesis Packages". O qual definiu dois Pacotes: um para uso com tipos com base no bit numeric_bit e um para o uso com tipos com base na std_logic numeric_std.

FONTE: http://www.doulos.com/knowhow/vhdl_designers_guide/numeric_std/

Use apenas as bibliotecas da IEEE

Existem diversos forum sobre VHDL onde existem sugestões para uso das bibliotecas da Synopsis std_logic_arith e std_logic_unsigned no lugar das bibliotecas padrão do IEEE numeric_bit e numeric_std. Como a implementação da Synopsis não é padronizada, e diferentes fornecedores implementam o pacote de forma ligeiramente diferentes, o que pode resultar em problemas de portabilidade do código VHDL entre ferramentas de síntese de fabricantes diferentes. Dessa forma a melhor solução é adotar sempre que disponível as bibliotecas padronizadas pela IEEE.

Uma das principais diferenças é que a biblioteca numeric_std não dá uma interpretação numérica rígida para os tipos std_logic_vector, mas define os tipos relacionados unsigned e signed que podem ser interpretados numericamente ou bit a bit. Dessa forma as operações lógicas e aritméticas combinando operandos signed, unsigned e integer podem ser utilizados. Nas operações de soma o resultado será do tamanho do maior operando, sendo os bits de overflow (carry) e underflow (borrow) truncados. A std_logic_arith por outro lado assume que toda aritmética é do tipo unsigned'.

Funções e Conversões da biblioteca numeric_std e numeric_bit

Para utilizar essas bibliotecas inclua no código:

library IEEE;
use IEEE.std_logic_1164.all;
use IEEE.numeric_bit.all; ou use IEEE.numeric_std.all;

Pacote std_logic_1164.vhd

Este pacote prove a definição e uso dos tipos de sinais

• std_ulogic
• std_ulogic_vector
• std_logic
• std_logic_vector

Veja as definições das funções disponíveis no std_logic_1164

Pacote numeric_std.vhd

--============================================================================
-- Numeric array type definitions
--============================================================================
 type UNSIGNED is array (NATURAL range <>) of STD_LOGIC;
 type SIGNED is array (NATURAL range <>) of STD_LOGIC;

--============================================================================
-- Operações Arithméticas com um argumento:
--===========================================================================

 -- function "abs" retorna  o valor absoluto do ARG (|ARG|)
 function "abs" (ARG: SIGNED) return SIGNED; 

 --function "-" com apenas um argumento ARG. Retorna o valor negativo do ARG (-ARG)
 function "-" (ARG: SIGNED) return SIGNED;   

--============================================================================
-- Operações Arithméticas com dois argumentos:
-- os dois argumentos podem ser do tipo UNSIGNED, SIGNED, INTEGER ou  NATURAL, 
-- o tipo do valor retornado depende dos operandos.
 function "OPERACAO" (L, R: UNSIGNED) return UNSIGNED; 
 function "OPERACAO" (L, R: SIGNED) return SIGNED;
 function "OPERACAO" (L: UNSIGNED; R: NATURAL) return UNSIGNED;
 function "OPERACAO" (L: NATURAL; R: UNSIGNED) return UNSIGNED;
 function "OPERACAO" (L: INTEGER; R: SIGNED) return SIGNED;
 function "OPERACAO" (L: SIGNED; R: INTEGER) return SIGNED;
--===========================================================================

 -- function "+" retorna a soma de L e R, os quais podem ter tamanhos diferentes, (L+R)
 -- o valor retornado tem tamanho igual ao argumento maior
 -- o overflow e underflow não são tratados.
 function "+" (L, R: UNSIGNED) return UNSIGNED; 

 -- function "-" retorna a subtração de L de R, os quais podem ter tamanhos diferentes, (L-R)
 -- os argumentos podem ser UNSIGNED, SIGNED, INTEGER ou  NATURAL
 -- o valor retornado tem tamanho igual ao argumento maior
 -- o overflow e underflow não são tratados.
 function "-" (L, R: UNSIGNED) return UNSIGNED;

 -- function "*" retorna o produto de L e R (L*R)
 -- os argumentos podem ser UNSIGNED, SIGNED, INTEGER ou  NATURAL
 -- o valor retornado tem tamanho igual a soma dos tamanhos dos argumentos L'LENGTH+R'LENGTH
 function "*" (L, R: UNSIGNED) return UNSIGNED;;

 -- function "/" retorna a divisão de L por R (L/R)
 -- os argumentos podem ser UNSIGNED, SIGNED, INTEGER ou  NATURAL
 -- se o segundo argumento for zero um "severity level of ERROR" é informado
 function "/" (L, R: UNSIGNED) return UNSIGNED;

 -- function "rem" retorna o resto da divisão de L por R (L rem R)
 -- os argumentos podem ser UNSIGNED, SIGNED, INTEGER ou  NATURAL
 -- se o segundo argumento for zero um "severity level of ERROR" é informado
 function "rem" (L, R: UNSIGNED) return UNSIGNED;

 -- function "mod" retorna o modulus(parte inteira) da divisão de L por R (L mod R)
 -- os argumentos podem ser UNSIGNED, SIGNED, INTEGER ou  NATURAL
 -- se o segundo argumento for zero um "severity level of ERROR" é informado
 function "mod" (L, R: UNSIGNED) return UNSIGNED;

--============================================================================
-- Operações de comparação:
-- os dois argumentos podem ser do tipo UNSIGNED, SIGNED, INTEGER ou  NATURAL,
-- o tamanho dos argumentos pode ser diferente
-- o tipo do valor retornado é sempre BOOLEAN.
 function "COMPARACAO" (L, R: UNSIGNED) return BOOLEAN; 
 function "COMPARACAO" (L, R: SIGNED) return BOOLEAN;
 function "COMPARACAO" (L: NATURAL; R: UNSIGNED) return BOOLEAN;
 function "COMPARACAO" (L: INTEGER; R: SIGNED) return BOOLEAN;
 function "COMPARACAO" (L: UNSIGNED; R: NATURAL) return BOOLEAN;
 function "COMPARACAO" (L: SIGNED; R: INTEGER) return BOOLEAN;;
--===========================================================================

 function  ">" (L, R: UNSIGNED) return BOOLEAN;
 function  "<" (L, R: UNSIGNED) return BOOLEAN;
 function "<=" (L, R: UNSIGNED) return BOOLEAN;
 function ">=" (L, R: UNSIGNED) return BOOLEAN;
 function  "=" (L, R: UNSIGNED) return BOOLEAN;
 function "/=" (L, R: UNSIGNED) return BOOLEAN;