una - VHDL Variable vs. Señal

variables en vhdl

Question

He estado leyendo un texto (no lo tengo enfrente, así que no puedo dar el título) sobre la programación de VHDL. Un problema que me ha costado entender el texto es cuándo usar una variable frente a una señal. Creo que tengo un claro entendimiento de cuándo usar una señal (señal interna que es) pero no tanto para una variable.

Noté que el texto generalmente declara e inicializa señales antes de definir un proceso, mientras que una variable se declara (y supongo que nunca se inicializa ..) dentro de un proceso.

De todos modos, para aclarar eso, ya sea por definición o por ejemplo, ¡sería genial!

Answer 1

En una nota lateral, las variables no solo pueden vivir en procesos (sino también, por ejemplo, en procedimientos), además, pueden ser variables compartidas accesibles desde múltiples procesos (ver: http://www.ics.uci.edu/~jmoorkan/vhdlref/var_dec.html ).

Answer 2

Las variables están destinadas a ser utilizadas para almacenar un valor dentro de un proceso. Como tal, su alcance es limitado. Tiende a haber una relación menos directa con el hardware sintetizado.

Las variables también obtienen un valor inmediatamente, mientras que las señales no lo hacen. Los dos procesos siguientes tienen el mismo efecto:

signal IP, NEXTP : STD_LOGIC_VECTOR(0 to 5);

process (CLK)
    Variable TEMP : STD_LOGIC_VECTOR(0 to 5);
    begin
        if (rising_edge(clk)) then
            TEMP := IP;
            IP <= NEXTP;
            NEXTP <= TEMP(5) & TEMP(0 to 4);
        end if;
end process;

signal IP, NEXTP : STD_LOGIC_VECTOR(0 to 5);

process (CLK)

    begin
        if (rising_edge(clk)) then
            IP <= NEXTP;
            NEXTP <= IP(5) & IP(0 to 4);
        end if;
end process;

Esto se debe a que las actualizaciones se programan, pero aún no han cambiado. el <= incluye un elemento temporal

Answer 3

Las variables se utilizan cuando se desea crear un código serializado, a diferencia del código paralelo normal. (Serializado significa que los comandos se ejecutan en su orden, uno después del otro en lugar de juntos). Una variable solo puede existir dentro de un proceso, y la asignación de valores no es paralela. Por ejemplo, considere el siguiente código:

signal a,b : std_logic_vector(0 to 4);

process (CLK)
    begin
        if (rising_edge(clk)) then
            a <= ''11111'';
            b <= a;
        end if;
end process;

pondrá en b el valor de a antes de que se ''11111 el proceso, y no ''11111 ''. Por otro lado, el código:

signal a,b : std_logic_vector(0 to 4);

process (CLK)
    variable var : std_logic_vector(0 to 4);
    begin 
        if (rising_edge(clk)) then
            var := ''11111'';
            a <= var;
            b <= var;
        end if;
end process;

pondrá el valor ''11111'' en a y b .

Francamente, en mi experiencia, la mayoría de las veces no necesita usar variables, el único lugar donde lo usé fue en un bucle en el que necesitaba comprobar si alguna de las señales es 1:

type    BitArray        is array (natural range <>) of std_logic;

--...

entity CAU_FARM is
    port
        (
            --   IN   --
              REQUEST         : in BitArray(0 to (FLOW_num -1));
              --..
        );
end CAU_FARM;
--...

farm_proc: process(CLK_FARM, RESET)
    variable request_was_made_var : std_logic;
    begin
    if RESET = C_INIT then 
       -- ...

    elsif rising_edge(CLK_FARM) then

            -- read state machine --
        case read_state is
            when        st_read_idle =>

                request_was_made_var := ''0'';
                for i in 0 to (FLOW_num -1) loop
                    if (REQUEST(i) = ''1'') then
                        request_was_made_var := ''1'';
                    end if;
                end loop;
                if (request_was_made_var = ''1'') and (chosen_cau_read_sig /= 8) then
                    read_state <= st_read_stage_1;
                    for i in 0 to (FLOW_num -1) loop
                        if (i = choice_out_sig) then
                            ACKNOWLEDGE(i) <= ''1'';
                        end if;
                    end loop;
                else
                    read_state <= st_read_idle;
                end if;
            ------------------------
            when        st_read_stage_1 =>
            --...

Answer 4

Variables: son locales a un proceso, su valor se actualiza tan pronto como la variable obtiene un nuevo valor.

Las variables compartidas son similares a las variables, pero se puede acceder a ellas desde diferentes procesos.

Señales: su alcance es mayor, todos los procesos pueden acceder a las señales declaradas en la arquitectura o en un bloque específico (si existe). Hay actualizaciones de valor después de que el proceso se suspende o encuentra una declaración de espera.

Answer 5

variables : ubicación temporal; se utilizan para almacenar valores intermedios dentro de "proceso".

Señales : Actualizar valores de señal. El proceso de ejecución se activa mediante cambios en la señal. Mientras el proceso ejecuta todas las señales en el sistema no se modifica.

Diferencias:

variables : son locales; sin demora; declarado dentro del proceso

Señales : son globales (antes de comenzar); retraso debido al cable; declarado antes de que comience la palabra clave