VHDL: conversión de un tipo INTEGER a un STD_LOGIC_VECTOR

Como han dicho otros, use ieee.numeric_std , nunca ieee.std_logic_unsigned , que no es realmente un paquete IEEE.

Sin embargo, si está utilizando herramientas compatibles con VHDL 2008, puede usar el nuevo paquete ieee.numeric_std_unsigned , que esencialmente hace que std_logic_vector se comporte como no firmado.

También, como no lo vi explícitamente, aquí está el ejemplo del código real para convertir de un entero (sin signo) a un std_logic_vector :

use ieee.numeric_std.all;
...
my_slv <= std_logic_vector(to_unsigned(my_int, my_slv'length));

Como dice LoneTech, use ieee.numeric_std es tu amigo. Puedes convertir un std_logic_vector en un integer , pero primero tendrás que convertirlo como signed o unsigned (ya que el compilador no tiene idea de lo que quieres decir). VHDL es un lenguaje fuertemente tipado. He escrito más sobre este tema en mi blog

Fundamentalmente, cambiaría el convertidor de 7seg para que ingrese un integer (o en realidad un natural , dado que solo tratará con números positivos): la conversión es una simple búsqueda de matriz. Configure una matriz constante con las conversiones y solo indexe con el entero que use en la entidad como entrada.

Puede estar interesado en usar los tipos unsigned y signed de ieee.numeric_std . Son compatibles con std_logic_vector , pero tienen una interpretación numérica (binario o 2-complemento). También existe la opción de poner tal interpretación en std_logic_vector , pero esta es no recomendado .

Digamos que su contador de 4 bits tuvo una salida INTEGER SOME_INTEGER, y quería convertirlo en un STD_LOGIC_VECTOR de 4 bits

SOME_VECTOR <= conv_std_logic_vector(SOME_INTEGER, 4);

También puede usar esto para inicializar vectores con números significativos

SOME_VECTOR <= conv_std_logic_vector(9, 4); -- instead of "1001"

Creo que es posible que deba agregar "use IEEE.STD_LOGIC_ARITH.ALL;" y / o STD_LOGIC_UNSIGNED.

La operación complementaria es conv_integer (vector). Me gusta usar esto cuando hago comparaciones. Así que podría declarar

constant SOME_CONSTANT : integer := 999;

Y luego, más adelante, puedo usar esto en una declaración if

if (conv_integer(SOME_VECTOR)=SOME_CONSTANT)
  then OTHER_VECTOR <= (others => '0');
end if;

EDITAR: no es necesario declarar la variable como un entero. Intenta cambiar la declaración a std_logic_vector en su lugar. Los operadores + y - trabajan en std_logic_vectors.

Como dice la respuesta principal, el método recomendado es el siguiente:

use ieee.numeric_std.all;
...
my_slv <= std_logic_vector(to_unsigned(my_int, my_slv'length));

Sin embargo, me gustaría explicar por qué se recomienda esto y por qué VHDL tiene una forma aparentemente complicada de convertir enteros en std_logic_vectors.

Se trata de cómo estos tipos son vistos por las herramientas.

Un standard_logic_vector es literalmente un grupo de 1s o 0s. Tengo 10001. ¿Qué número es este? Bueno, eso depende. ¿Está firmado o sin firmar? Ths SLV no sabe ni se preocupa. ¿Cuántos bits? Bueno, ¿cuánto tiempo es tu SLV?

Se firma un entero, y generalmente 32 bits (si recuerdo bien).

Etapa 1: Haz mi entero más corto, y sin firmar. Esa es la parte:

to_unsigned(my_int, my_slv'length));

  

"Tengo este entero, quiero que esté sin firmar y quiero que encaje   en la longitud de mi SLV ".

Etapa 2: Luego, toma esos bits y utilízalos para controlar my_slv.

my_slv <= std_logic_vector(...)

  

"Toma estos bits y utilízalos para conducir mi slv"

(Una nota sobre la terminología. A <= B en VHDL se lee en voz alta ya que "A es manejado por B")

Combinado, esto te pone:

my_slv <= std_logic_vector(to_unsigned(my_int, my_slv'length));

Al provenir de un fondo de programación tradicional, es muy fácil quedarse atascado en una forma de pensar de la programación. Pero en VHDL, el código que escribe tiene implicaciones físicas en el hardware. Saber por qué este método funciona y se recomienda es un paso más cerca de pensar en lo que está escribiendo en términos de hardware.

Bonus tip: las funciones con el prefijo to_ son aquellas que acortan / cambian los operandos. Los hacen sin firmar o una cierta longitud o ambos. Esta es la razón por la que to_unsigned requiere que especifique la longitud. Las funciones sin to_ (straight std_logic_vector (...) en este ejemplo) se usan cuando los tipos ya son directamente compatibles. "Tome estos bits y rellénelos en este tipo, no se requieren modificaciones". Estos no tienen un argumento de longitud porque ambos lados ya son iguales. Así que cuando construyo cosas como esta, no necesito buscarlas, solo pienso en cómo estoy cambiando los datos.