En qué se diferencia una señal de una variable en VHDL

En el tutorial anterior aprendimos cómo declarar una variable en un proceso. Las variables son buenas para crear algoritmos dentro de un proceso, pero no son accesibles para el mundo exterior. Si el alcance de una variable está solo dentro de un solo proceso, ¿cómo puede interactuar con cualquier otra lógica? La solución para esto es una señal .

Las señales se declaran entre el architecture <architecture_name> of <entity_name> is línea y el begin declaraciones en el archivo VHDL. Esto se llama la parte declarativa de la arquitectura.

Esta publicación de blog es parte de la serie Tutoriales básicos de VHDL.

La sintaxis para declarar una señal es:
signal <name> : <type>;

Una señal puede declararse opcionalmente con un valor inicial:
signal <name> : <type> := <initial_value>;

Ejercicio

En este video tutorial aprendemos a declarar una señal. También aprenderemos la principal diferencia entre una variable y una señal:

El código final que creamos en este tutorial:

entity T06_SignalTb is
end entity;

architecture sim of T06_SignalTb is

    signal MySignal : integer := 0;

begin

    process is
        variable MyVariable : integer := 0;
    begin

        report "*** Process begin ***";

        MyVariable := MyVariable + 1;
        MySignal   <= MySignal + 1;

        report "MyVariable=" & integer'image(MyVariable) &
            ", MySignal=" & integer'image(MySignal);

        MyVariable := MyVariable + 1;
        MySignal   <= MySignal + 1;

        report "MyVariable=" & integer'image(MyVariable) &
            ", MySignal=" & integer'image(MySignal);

        wait for 10 ns;

        report "MyVariable=" & integer'image(MyVariable) &
            ", MySignal=" & integer'image(MySignal);

    end process;

end architecture;

La salida a la consola del simulador cuando presionamos el botón ejecutar en ModelSim:

VSIM 2> run
# ** Note: *** Process begin ***
#    Time: 0 ns  Iteration: 0  Instance: /t06_signaltb
# ** Note: MyVariable=1, MySignal=0
#    Time: 0 ns  Iteration: 0  Instance: /t06_signaltb
# ** Note: MyVariable=2, MySignal=0
#    Time: 0 ns  Iteration: 0  Instance: /t06_signaltb
# ** Note: MyVariable=2, MySignal=1
#    Time: 10 ns  Iteration: 0  Instance: /t06_signaltb
# ** Note: *** Process begin ***
#    Time: 10 ns  Iteration: 0  Instance: /t06_signaltb
# ** Note: MyVariable=3, MySignal=1
#    Time: 10 ns  Iteration: 0  Instance: /t06_signaltb
# ** Note: MyVariable=4, MySignal=1
#    Time: 10 ns  Iteration: 0  Instance: /t06_signaltb
# ** Note: MyVariable=4, MySignal=2
#    Time: 20 ns  Iteration: 0  Instance: /t06_signaltb
...

Análisis

Creamos una señal y una variable con el mismo valor inicial de 0. En nuestro proceso, las tratamos exactamente de la misma manera, pero las impresiones revelan que se comportaron de manera diferente. Primero vimos que la asignación a una variable y una señal tiene una notación diferente en VHDL. La asignación de variables utiliza el := mientras que la asignación de señal usa el <= operador.

MyVariable se comporta como uno esperaría que se comportara una variable. En la primera iteración del bucle se incrementa a 1 y luego a 2. La última impresión de la primera iteración muestra que su valor sigue siendo 2, como era de esperar.

MySignal se comporta ligeramente diferente. El primer incremento de +1 no parece tener ningún efecto. La impresión revela que su valor sigue siendo 0, el valor inicial. Lo mismo ocurre después del segundo incremento de +1. Ahora el valor de MyVariable es 2, pero el valor de MySignal sigue siendo 0. Después de wait for 10 ns; la tercera impresión muestra que el valor de MySignal ahora es 1. Las impresiones posteriores también siguen este patrón.

¿Qué es esta hechicería? Te doy una pista, el wait for 10 ns; tiene algo que ver con eso. Las señales solo se actualizan cuando un proceso está en pausa. Nuestro proceso se detiene solo en un lugar, en wait for 10 ns; . Por lo tanto, el valor de la señal cambia solo cada vez que se toca esta línea. Los 10 nanosegundos es un valor arbitrario, podría ser cualquier cosa, incluso 0 nanosegundos. ¡Pruébalo!

Otra observación importante es que el evento aunque la señal se incrementó dos veces antes del wait , su valor solo se incrementa una vez. Esto se debe a que al asignar a una señal en un proceso, la última asignación “gana”. El <= el operador solo programa un nuevo valor en la señal, no cambia hasta el wait . Por lo tanto, en el segundo incremento de MySignal , se añade 1 a su antiguo valor. Cuando se incrementa de nuevo, el primer incremento se pierde por completo.

Para llevar

• Se puede usar una variable dentro de un proceso mientras que las señales tienen un alcance más amplio
• La asignación de variables es efectiva de inmediato, mientras que las señales se actualizan solo cuando un proceso se detiene
• Si una señal se asigna varias veces sin un wait , la última asignación "gana"

Ir al siguiente tutorial »