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!

27
demandé sur doddy 2013-03-18 23:58:02

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 =>
            --...
34
répondu SIMEL 2017-01-03 18:17:25

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.

12
répondu Voider 2014-11-07 20:57:34

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

7
répondu deepika 2016-08-15 20:04:34

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).

1
répondu Piedone 2015-08-31 15:15:00

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.

-1
répondu user3094049 2017-05-12 11:37:54