Différence entre un signal et une variable en VHDL

Dans le tutoriel précédent, nous avons appris à déclarer une variable dans un processus. Les variables sont utiles pour créer des algorithmes au sein d'un processus, mais elles ne sont pas accessibles au monde extérieur. Si la portée d'une variable ne se trouve que dans un seul processus, comment peut-elle interagir avec une autre logique ? La solution pour cela est un signal .

Les signaux sont déclarés entre le architecture <architecture_name> of <entity_name> is ligne et le begin instructions dans le fichier VHDL. C'est ce qu'on appelle la partie déclarative de l'architecture.

Cet article de blog fait partie de la série de didacticiels VHDL de base.

La syntaxe pour déclarer un signal est :
signal <name> : <type>;

Un signal peut éventuellement être déclaré avec une valeur initiale :
signal <name> : <type> := <initial_value>;

Exercice

Dans ce didacticiel vidéo, nous apprenons à déclarer un signal. Nous apprendrons également la principale différence entre une variable et un signal :

Le code final que nous avons créé dans ce tutoriel :

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 sortie vers la console du simulateur lorsque nous avons appuyé sur le bouton d'exécution dans 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
...

Analyse

Nous avons créé un signal et une variable avec la même valeur initiale de 0. Dans notre processus, nous les avons traités exactement de la même manière, mais les impressions révèlent qu'ils se sont comportés différemment. Nous avons d'abord vu que l'affectation à une variable et à un signal a une notation différente en VHDL. L'affectation des variables utilise le := tandis que l'affectation du signal utilise le <= opérateur.

MyVariable se comporte comme on s'attendrait à ce qu'une variable se comporte. Dans la première itération de la boucle, il est incrémenté à 1, puis à 2. La dernière impression de la première itération montre que sa valeur est toujours 2, comme on pouvait s'y attendre.

MySignal se comporte légèrement différemment. Le premier incrément de +1 ne semble pas avoir d'effet. L'impression révèle que sa valeur est toujours 0, la valeur initiale. Il en va de même après le deuxième incrément de +1. Maintenant la valeur de MyVariable est 2, mais la valeur de MySignal est toujours 0. Après wait for 10 ns; la troisième impression montre que la valeur de MySignal est maintenant 1. Les impressions suivantes suivent également ce schéma.

Quelle est cette sorcellerie? Je vais vous donner un indice, le wait for 10 ns; a quelque chose à voir avec ça. Les signaux ne sont mis à jour que lorsqu'un processus est en pause. Notre processus s'arrête à un seul endroit, à wait for 10 ns; . Par conséquent, la valeur du signal ne change qu'à chaque fois que cette ligne est atteinte. Les 10 nanosecondes sont une valeur arbitraire, cela peut être n'importe quoi, même 0 nanoseconde. Essayez !

Une autre observation importante est cet événement bien que le signal ait été incrémenté deux fois avant le wait , sa valeur n'est incrémentée qu'une seule fois. En effet, lors de l'affectation à un signal dans un processus, la dernière affectation « l'emporte ». Le <= l'opérateur programme uniquement une nouvelle valeur sur le signal, elle ne change pas avant le wait . Par conséquent, au deuxième incrément de MySignal , 1 est ajouté à son ancien évaluer. Lorsqu'il est à nouveau incrémenté, le premier incrément est complètement perdu.

À emporter

• Une variable peut être utilisée dans un processus tandis que les signaux ont une portée plus large
• L'affectation des variables prend effet immédiatement, tandis que les signaux ne sont mis à jour que lorsqu'un processus s'interrompt
• Si un signal est assigné plusieurs fois sans wait , le dernier devoir "gagne"

Aller au tutoriel suivant »