Introduction au langage VHDL

Deux types sont à la base de tout en VHDL : bit et bit_vector. Cependant, ils sont très crus, car seules deux valeurs sont possibles (vrai et faux) : comment représenter une haute impédance, par exemple ? Comment gérer les don't cares (dans certains cas, la valeur de sortie n'a aucune importance, on peut en profiter pour optimiser encore plus l'implémentation d'une fonction) ?

Le standard IEEE 1164 vient résoudre ce problème avec les types std_logic et std_logic_vector, respectivement un bit et un vecteur de bits. Les valeurs possibles sont principalement des booléens (vrai 1 et faux 2, d'intensité faible au besoin - L et H), le don't care - et la haute impédance Z, utile pour relier plusieurs sorties sans risque d'instabilité du circuit. D'autres valeurs sont également possibles (U pour une valeur non initialisée, X pour une valeur inconnue forte, W pour une valeur inconnue faible), bien que moins utilisées.

Au niveau de la syntaxe, pour indiquer la valeur d'un bit, scalaire, on met le symbole entre apostrophes droites : '1' ; dans le cas d'un vecteur, on utilisera des guillemets droits : "11".

Ces types sont définis dans la bibliothèque ieee.std_logic_1164.all (il faudra le spécifier dans chaque entité VHDL).

Tout programme VHDL contient au moins une paire entité/architecture. L'entité définit les entrées et sorties de l'architecture, l'implémentation proprement dite. L'entité est vue de l'extérieur du composant (interface) ; l'architecture explicitera les liens entre les entrées et les sorties (implémentation).

Dans l'entité, on doit définir les entrées (in) et sorties (out) ainsi que leur type. On en utilise principalement deux : std_logic et std_logic_vector.

Dans une architecture de type flot de données, on définit explicitement les expressions booléennes reliant les entrées et les sorties. Peu importe le style utilisé, l'implémentation produite par le compilateur sera identique si l'architecture fait exactement la même chose.

Les commentaires sont indiqués par -- en début de ligne.

III-B-1. Premier exemple : un demi-additionneur▲

-- Déclaration des bibliothèques utilisées
library IEEE; 
use IEEE.std_logic_1164.all;

-- Déclaration de l'entité du demi-additionneur (half-adder). 
entity HA is
    port(A, B: in  std_logic; 
         S, R: out std_logic); 
end HA; 

-- Déclaration de l'architecture en flot de données. 
architecture arch_HA_flow of HA is
begin
    S <= A xor B; 
    R <= A and B; 
end arch_HA_flow;

S = (Sxor);
R = (R_c);
A_c = (A);
B_c = (B);
Sxor.X1 = (A_c);
Sxor.X2 = (B_c);
R_c = (A_c & B_c);

L'entité sert principalement à définir les entrées et les sorties du composant :

entity NAME is
    port(IO); 
end NAME;

III-C-1. Attribution des pins▲

entity NAME is port(
        S: std_logic_vector(1 downto 0)
    ); 

    attribute pin_numbers of NAME: entity is
        "S(1):24 S(0):12"
end NAME;

entity NAME is port(
        S: std_logic_vector(1 downto 0) := "10"
    ); 

    attribute pin_numbers of NAME: entity is
        "S(1):24 S(0):12"
end NAME;

Une architecture décrit le fonctionnement du système, l'implémentation de la fonctionnalité voulue. Son fonctionnement peut être combinatoire ou séquentiel. Pour modéliser un système complet, on utilisera une série de paires entité-architecture.

On y définit des signaux, l'équivalent le plus proche des variables en programmation informatique : ils servent à passer les résultats intermédiaires d'un bloc fonctionnel à un autre. On les utilisera en pratique lors de la présentation des architectures comportementales.

• flot de données : on écrit explicitement les fonctions booléennes que l'on veut voir implémentées (à réserver aux plus petits circuits pour des raisons de lisibilité) ; c'est lui qu'on a utilisé pour implémenter le demi-additionneur ;
• structurel : on décrit le circuit comme une série de boîtes noires interconnectées au moyen de signaux (utilisé pour des circuits moyens ou grands) ; on procèdera de cette manière pour synthétiser un additionneur complet à l'aide de deux demi-additionneurs ;
• comportemental : de manière très semblable à un langage de programmation informatique, on précise le fonctionnement voulu à l'aide d'une suite d'instructions de contrôles plus ou moins évoluées (conditions, boucles, etc.), dans un process.

Comme précédemment, on décrit simplement les équations booléennes que l'on veut implémenter.

IV-A-1. Deuxième exemple : un multiplexeur 4-1 en portes logiques▲

library ieee;
use ieee.std_logic_1164.all;
use ieee.std_logic_arith.all;
use ieee.std_logic_unsigned.all;

entity MUX is port(
    E0, E1, E2, E3, SEL0, SEL1: in std_logic; 
    S: out std_logic); 
end;

architecture FLOT_MUX of MUX is
begin
    S <= ((not SEL0) and (not SEL1) and E0) or 
         (SEL0 and (not SEL1) and E1) or 
         ((not SEL0) and SEL1 and E2) or 
         (SEL0 and SEL1 and E3); 
end FLOT_MUX;

IV-A-2. Troisième exemple : un multiplexeur 4-1 avec un WHEN▲

library ieee;
use ieee.std_logic_1164.all;
use ieee.std_logic_arith.all;
use ieee.std_logic_unsigned.all;

entity MUX is port(
    E0, E1, E2, E3, SEL0, SEL1: in std_logic; 
    S: out std_logic); 
end;

architecture FLOT_MUX of MUX is
begin
    S <= E0 when (SEL0='0' and SEL1='0') else 
         E1 when (SEL0='1' and SEL1='0') else
         E2 when (SEL0='0' and SEL1='1') else
         E3; 
end FLOT_MUX;

library ieee;
use ieee.std_logic_1164.all;
use ieee.std_logic_arith.all;
use ieee.std_logic_unsigned.all;

entity MUX is port(
    E0, E1, E2, E3, SEL0, SEL1: in std_logic; 
    S: out std_logic); 
end;

architecture FLOT_MUX of MUX is
begin
    S <= E0 when (SEL0='0' and SEL1='0') else 
         E1 when (SEL0='1' and SEL1='0') else
         E2 when (SEL0='0' and SEL1='1') else
         E3 when (SEL0='1' and SEL1='1') else
         '-'; 
end FLOT_MUX;

IV-A-3. Quatrième exemple : un multiplexeur 4-1 avec un SELECT▲

library ieee;
use ieee.std_logic_1164.all;

entity MUX is port(
    E0, E1, E2, E3, SEL0, SEL1: in std_logic; 
    S: out std_logic); 
end;

architecture FLOT_MUX of MUX is
begin
    with SEL1 & SEL0 select
        S <= E0 when "00",
             E1 when "01", 
             E2 when "10", 
             E3 when others; 
end FLOT_MUX;

On assemble ici une série de boîtes noires déjà écrites pour former un circuit plus complexe.

C'est le principe utilisé pour des additionneurs à plusieurs bits : on branche en série une série d'additionneurs complets, chacun pouvant additionner trois bits. Leur sortie est composée du bit de somme et du bit de report, comme les demi-additionneurs. Alors que le bit de somme est directement transmis à la sortie du circuit, le bit de report est transmis comme troisième bit à additionner à l'additionneur complet suivant.

Cependant, ce principe n'est pas forcément généralisable à grande échelle, puisque chaque additionneur a besoin du bit de report de l'additionneur précédent pour effectuer son travail. Pour additionner kitxmlcodeinlinelatexdvpnfinkitxmlcodeinlinelatexdvp bits, on devra donc attendre kitxmlcodeinlinelatexdvpnfinkitxmlcodeinlinelatexdvp temps de propagation du signal à travers les portes logiques. On peut pallier ce problème, par exemple, en prévoyant le bit de report ou en calculant deux valeurs (quand le bit de report est kitxmlcodeinlinelatexdvp1finkitxmlcodeinlinelatexdvp ou kitxmlcodeinlinelatexdvp0finkitxmlcodeinlinelatexdvp).

IV-B-1. Cinquième exemple : additionneur complet▲

-- Entité demi-additionneur
library ieee;
use ieee.std_logic_1164.all;
entity HA is port(
    A, B: in  std_logic; 
    R, S: out std_logic); 
end HA; 

architecture FLOW of HA is 
begin
    S <= A xor B; 
    R <= A and B; 
end FLOW;

-- Entité OR
library ieee;
use ieee.std_logic_1164.all;
entity P_OR is port(
    C, D: in  std_logic; 
    E:    out std_logic); 
end P_OR;  

architecture FLOW of P_OR is
begin
    E <= C or D; 
end FLOW; 

-- Entité additionneur complet
library ieee;
use ieee.std_logic_1164.all;
entity FA is port(
    A, B, Ri: in  std_logic; 
    R, S:     out std_logic); 
end;

architecture FA_ARCH of FA is 
    component HA
        port(A, B: in  std_logic; 
             R, S: out std_logic); 
    end component HA; 

    component P_OR 
        port(C, D: in  std_logic; 
             E:    out std_logic); 
    end component P_OR; 

    signal S1, S2, S3: std_logic; 
begin
    i1: HA   port map(A,  B,  S1, S2); 
    i2: HA   port map(S2, Ri, S3, S); 
    i3: P_OR port map(S3, S1, R); 
end FA_ARCH;

On décrit alors l'architecture comme une suite d'instructions, comme en programmation informatique traditionnelle. On définit des process ainsi que leur liste de sensibilité : dès qu'un symbole change de valeur dans cette liste, le code est réexécuté. C'est utile notamment en logique séquentielle, pour lancer le code à chaque coup de l'horloge. Les instructions sont exécutées de manière séquentielle ; cependant, les signaux ne changent de valeur qu'à la fin du process.

On peut utiliser diverses constructions bien connues (fort semblables à l'Ada) : le if-then-else, le case-is when, etc. On dispose de plusieurs boucles, mais leur utilisation ne correspond pas à l'habitude informatique (elles correspondent plus à une simplification de l'écriture qu'à une exécution de code répétitive pour s'approcher du résultat final ou toute utilisation plus « traditionnelle » des boucles), de même pour les fonctions et procédures.

Les signaux sont définis dans l'en-tête de l'architecture ; les variables ne sont valables que dans un process. En dehors d'un process, tout se produit de manière concurrente : deux process peuvent être exécutés simultanément. Par contre, dans un process, toutes les instructions sont exécutées de manière séquentielle et les affectations sont réalisées à la fin.

IV-C-1. Sixième exemple : un multiplexeur comportemental avec IF▲

library ieee;
use ieee.std_logic_1164.all;

entity MUX is port(
    E0, E1, E2, E3: in std_logic; 
    SEL: in std_logic_vector(1 downto 0); 
    S: out std_logic); 
end;

architecture CMP of MUX is
begin
    process (E0, E1, E2, E3, SEL)
    begin 
        if SEL="00" then 
            S <= E0; 
        elsif SEL="01" then 
            S <= E1; 
        elsif SEL="10" then 
            S <= E2; 
        elsif SEL="11" then 
            S <= E3; 
        else
            S <= '-'; 
        end if; 
    end process; 
end FLOT_MUX;

IV-C-2. Septième exemple : un multiplexeur comportemental avec CASE▲

library ieee;
use ieee.std_logic_1164.all;

entity MUX is port(
    E0, E1, E2, E3: in std_logic; 
    SEL: in std_logic_vector(1 downto 0); 
    S: out std_logic); 
end;

architecture CMP of MUX is
begin
    process (E0, E1, E2, E3, SEL)
    begin 
        case SEL is
            when "00" => S <= E0; 
            when "01" => S <= E1; 
            when "10" => S <= E2; 
            when "11" => S <= E3; 
        end case; 
    end process; 
end FLOT_MUX;

IV-C-3. Huitième exemple : un décodeur avec FOR▲

library ieee;
use ieee.std_logic_1164.all;

entity DEC is port(
    E0, E1: in std_logic; 
    S: out std_logic_vector(3 downto 0)); 
end;

architecture FLOT_MUX of DEC is
begin
    process (E0, E1)
    variable N := integer; 
    begin 
        N := 0; 
        
        if E0 = '1' then N := N + 1; end if; 
        if E1 = '1' then N := N + 2; end if; 
        S <= "0000"; 
        
        for I in 0 to 3 loop 
            if I = N then 
                S(I) <= '1'; 
            end if; 
        end loop; 
    end process; 
end;

À titre d'exemple, on peut modéliser un flip-flop (ou bascule ou verrou) de type D, avec reset synchrone et asynchrone. Quand l'horloge est à kitxmlcodeinlinelatexdvp1finkitxmlcodeinlinelatexdvp, on recopie l'entrée kitxmlcodeinlinelatexdvpDfinkitxmlcodeinlinelatexdvp à la sortie kitxmlcodeinlinelatexdvpQfinkitxmlcodeinlinelatexdvp ; quand l'horloge est à kitxmlcodeinlinelatexdvp0finkitxmlcodeinlinelatexdvp, on mémorise la valeur kitxmlcodeinlinelatexdvpDfinkitxmlcodeinlinelatexdvp. Le reset permet de mettre le flip-flop dans un état stable et connu, ce qui n'est pas forcément le cas à la mise sous tension.

V-A-1. Neuvième exemple : un flip-flop D synchrone▲

library ieee;
use ieee.std_logic_1164.all;

entity FFD is port(
    D, RAZ, CLK: in std_logic; 
    Q: out std_logic);
end;

architecture ARCH_FFD of FFD is
begin
    process(CLK, RAZ)
    begin
        if rising_edge(CLK) then
            if RAZ = '1' then
                Q <= '0'; 
            else
                Q <= D; 
            end if; 
        end if; 
    end process; 
end ARCH_FFD;

V-A-2. Dixième exemple : un flip-flop D asynchrone▲

library ieee;
use ieee.std_logic_1164.all;

entity FFD is port(
    D, RAZ, CLK: in std_logic; 
    Q: out std_logic);
end;

architecture ARCH_FFD of FFD is
begin
    process(CLK, RAZ)
    begin
        if RAZ = '1' then
            Q <= '0'; 
        elsif rising_edge(CLK) then
            Q <= D; 
        end if; 
    end process; 
end ARCH_FFD;

Une machine à états est l'implémentation en électronique du concept d'automate : dans un circuit séquentiel, on mémorise une certaine forme des entrées précédentes (l'état) qui vont influencer la sortie courante. Par exemple, pour le circuit contrôlant une lampe clignotante, on aura une machine à états très simple : seuls deux états sont possibles (lampe allumée ou éteinte), on passe de l'un à l'autre à chaque coup d'horloge.

Ainsi, si on veut implémenter une machine à états, il suffit de définir une série de bits définissant l'état courant ; ainsi, à chaque coup d'horloge, on exécute un process qui va varier en fonction de l'état courant. On préférera utiliser un signal, étant donné qu'il n'est pas utile de transmettre cette valeur à l'extérieur ou de laisser la possibilité de l'altérer directement.

On peut donc implémenter cette lampe en VHDL. La machine à états ne contiendra que deux états et un bit suffira pour le retenir (kitxmlcodeinlinelatexdvp\log_2 2 = 1finkitxmlcodeinlinelatexdvp). La sortie O varie en même temps que le flanc montant d'horloge et servira à actionner la lampe (ce qui est fait du signal en sortie est à gérer manuellement à l'aide de DEL et résistances, en se basant sur les spécifications du composant utilisé notamment en ce qui concerne le courant de sortie).

entity NAME is port(
    CLK: in  std_logic; 
    O:   out std_logic; 
end;

architecture arch_NAME of NAME is
signal state: std_logic;
begin
    process(CLK)
    begin
        if rising_edge(CLK) then
            if state = '0' then 
                O <= '1'; 
                state <= '1'; 
            else 
                O <= '0'; 
                state <= '0'; 
            end if; 
        end if; 
    end process; 
end arch_NAME;

Si on veut utiliser la valeur d'une sortie comme base dans un bout de programme, ce n'est pas possible : il faut définir un signal qui sera recopié dans la sortie, de manière asynchrone. Pour ce faire, on met l'instruction de recopie dans la sortie en début d'architecture, avant de définir le moindre process.

architecture Arch of Sth is
    signal sOut: std_logic; 
begin
    Out <= sOut; 

    process(CLK)
    begin 
        -- ...
        -- On utilise sOut là où on voulait un accès à Out ; 
        -- on donne des valeurs à sOut là où on assignait Out. 
    end process
end Arch;