VHDL variable Vs. Signal
J'ai lu un texte (Je ne l'ai pas devant donc je ne peux pas donner le titre) sur la programmation VHDL. Un problème que j'ai du mal à comprendre à partir du texte est de savoir quand utiliser une variable vs un signal. Je pense que j'ai une compréhension claire du moment d'utiliser un signal (signal interne) mais pas tellement pour une variable.
J'ai remarqué que le texte déclare et initialise généralement les signaux avant de définir un processus alors qu'une variable est déclarée (et je suppose que jamais initialiser..) à l'intérieur d'un processus.
De toute façon pour éclaircir cela, soit par définition ou par exemple serait génial!
5 réponses
Les Variables sont utilisées lorsque vous souhaitez créer du code sérialisé, contrairement au code parallèle normal. (Sérialisé signifie que les commandes sont exécutées dans leur ordre, l'une après l'autre au lieu de Ensemble). Une variable ne peut exister qu'à l'intérieur d'un processus, et l'affectation de valeurs n'est pas parallèle. Par exemple, considérons le code suivant:
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;
Mettra dans b
la valeur de a
avant l'exécution du processus, et non '11111
'. D'autre part, le code:
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;
Mettra le valeur '11111'
dans a
et b
.
Franchement, dans mon expérience, la plupart du temps vous n'avez pas besoin d'utiliser des variables, le seul endroit où je l'ai utilisé était dans une boucle où je devais vérifier si l'un des signaux est 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 =>
--...
Les Variables sont destinées à être utilisées pour stocker une valeur dans un processus. En tant que tel, sa portée est limitée. Il tend à y avoir une relation moins directe avec le matériel synthétisé.
Les Variables obtiennent également une valeur immédiatement, alors que les signaux Ne le font pas. les deux processus suivants ont le même effet:
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;
C'est parce que les mises à jour sont planifiées, mais n'ont pas encore changé. le <=
comprend un élément temporel.
variables : emplacement temporaire; elles sont utilisées pour stocker des valeurs intermédiaires dans "process".
signaux : Mise à jour des valeurs du signal. Exécuter le processus activé par les changements sur le signal.Pendant que le processus est en cours d'exécution, tous les signaux du système restent inchangés.
Différences:
variables : elles sont locales; pas de délai; déclarées dans le processus
signaux : ils sont globaux (avant le début); retard dû au fil; déclaré avant le mot clé commencer
Sur une note de côté, les variables ne peuvent pas seulement vivre dans des processus (mais aussi par exemple dans des procédures), en outre, elles peuvent être des variables partagées accessibles à partir de plusieurs processus (voir: http://www.ics.uci.edu/~jmoorkan/vhdlref/var_dec.html).
Variables, elles sont locales à un processus, leur valeur est mise à jour dès que la variable reçoit une nouvelle valeur.
Variables partagées-sont comme des variables, mais elles sont accessibles à partir de différents processus.
Signaux - leur portée est plus grande, chaque processus peut accéder aux signaux déclarés dans l'architecture ou un bloc spécifique( s'il y en a). Il y a des mises à jour de valeur après que le processus est suspendu ou rencontre une instruction wait.