Introduction au langage VHDL
Exercices: 1 Fonctions logiques combinatoires . ................................................3 1.1 Exercice 1 : Décodage d’adresses . ..............................................3 1.2 Exercice 2 : Multiplexeur . .....................................................5 1.3 Exercice 3 : Décodeur Hexadécimal / 7 segments . ................................7 1.4 Exercice 4 : Démultiplexeur 1→ 8 . ..............................................9 2 Sorties trois états, entrées/sorties . ...........................................10 2.1 Exercice 5 : Buffer trois états . ..............................................10 2.2 Exercice 6 : Transceiver . .....................................................10 3 Circuits logiques séquentiels . ..................................................11 3.1 Exercice 7 : Latch . ...........................................................11 3.2 Exercice 8 : Registre . ........................................................12 3.3 Exercice 9 : Registre avec mise à zéro asynchrone . ............................12 3.4 Exercice 10 : Registre avec mise à zéro et mise à un synchrone ................13 3.5 Exercice 11 : Compteur binaire avec mise à zéro asynchrone ....................13 3.6 Exercice 12 : Compteur binaire chargeable .....................................14 3.7 Exercice 13 : Compteur/Décompteur binaire chargeable . .........................16
2
Introduction au langage VHDL
1 Fonctions logiques combinatoires 1.1 Exercice 1 : Décodage d’adresses Logigramme de la fonction à réaliser On donne ci-dessous un plan mémoire (mapping memory) à réaliser.
A15
Decod_Add
A14 A13
ROM1 ROM2 Libre IO RAM
$FFFF Solution 1 « classique » : Tableau d’adressage
ROM1 (8k) $E000 $DFFF
A15 A14 A13 A12 A11 A10 A9 A8 A7 A6 A5 A4 A3 A2 A1 A0 @ $FFFF $E000 $DFFF $C000 $BFFF $4000 $3FFF $2000 $1FFF $0000
ROM2 (8k) $C000 $BFFF Libre (32k) $4000 $3FFF I/O (8k) $2000 $1FFF RAM (8k)
Remarque : Les broches de sélection des boîtiers mémoires sont actives à l’état bas.
Equations $0000
/Libre /A13
/A15./A14
/0A115.A14
A15.A14
A15./A14
/ROM1 = A13
/ROM2 = /libre = /I_O
=
/RAM =
Solution 2 : Description « flot de données » en VHDL (.vhd) entity Decod_Add is
architecture flot_Decod_Add of Decod_Add is begin
end flot_Decod_Add; 3
Introduction au langage VHDL
Solution 3 : Descriptions comportementales en VHDL (.vhd)
Utilisation d’une affectation concurrente conditionnelle On se limite à la sortie ROM1. entity Decod_Add1 is port( BusAdd: in std_logic_vector (15 downto 13) ; ROM1: out std_logic ); end Decod_Add1 ; architecture comporte1_Decod_Add1 of Decod_Add1 is begin ROM1 <= '0' when (BusAdd = X"7") else '1' ; -- else indispensable end comporte1_Decod_Add1; -- voir remarque ci-dessous
Utilisation d’une affectation concurrente sélective On se limite à la sortie ROM1. architecture comporte2_Decod_Add1 of Decod_Add1 is begin with BusAdd select ROM1 <= '0' when "111", -- others indispensable '1' when others; -- voir remarque ci-dessous end comporte2_Decod_Add1;
Pièges à éviter lors de la synthèse des fonctions combinatoires : Les mémorisations implicites ! Remarque concernant les affectations ci-dessus Il est fortement conseillé de rendre les conditions listées exhaustives, c'est à dire de ne pas laisser de cas indéterminés. Sinon le compilateur risque de générer une logique inattendue appelée mémorisation implicite. Dans le cas d'une affectation conditionnelle, l'exhaustivité des conditions est obtenue par un else final. Dans le cas d'une affectation sélective, l'exhaustivité des conditions est obtenue par others.
Exemple:
B A
C <= B when A=’1’ ;
& ≥1
C
est interprété comme signifiant :
&
C <= B when A=’1’ else C; et se synthétise comme ci-contre !
Si le but est d’exprimer « C prend la valeur de B quand A = ‘1’, sinon n’importe quoi » il faut écrire : C <= B when A=’1’ else ‘-‘; qui se synthétise par :
B A
&
C
ou
B A
≥1
C
4
Introduction au langage VHDL
1.2 Exercice 2 : Multiplexeur Rappels : La fonction multiplexage est une fonction combinatoire qui possède N entrées et M sorties (M < N). Elle transmet sur une des sorties, une des entrées sélectionnées par une adresse préalablement appliquée aux n entrées de commande (appelées entrées de sélection ou d’adresse).
MUX
N
M
n
Réalisation d’un multiplexeur 4 -> 1
Solution 1 « classique » : Table de vérité partielle E0 n2 n1 E0 E1 E2 E3 S E1 0 0 0 X X X E2 0 0 1 X X X E3 0 1 X 0 X X 0 1 X 1 X X n2, n1 1 0 X X 0 X 1 0 X X 1 X 1 1 X X X 0 n2 1 1 X X x 1 0 0 X : Indifférent 1 1
S MUX4_1
n1 0 1 0 1
E0 X X X X
E1 X X X X
E2 X X X X
E3 X X X X
S E0 E1 E2 E3
S = -------------------------------------------
Remarque : L’équation fait apparaître des sommes de produits faciles à synthéthiser dans un PLD.
Solution 2 : Description comportementale en VHDL (.vhd) entity mux4_1 is
end mux4_1
Remarque : choisir une affectation concurrente. architecture comporte_mux4_1 of mux4_1 is begin
end comporte_mux4_1; 5
Introduction au langage VHDL
Proposer les modifications à effectuer pour que le décodeur précédant traite des vecteurs e3, e2, e1, e0 et s de 8 bits. entity mux4_1 is
end mux4_1 ;
Schéma RTL: Multiplexeur 4 -> 1
architecture Comporte_Mux4_1 of Mux4_1 is
architecture Comporte_Mux4_1 of Mux4_1 is
begin
begin
-- Première solution: affectation concurente conditionnelle
-- Deuxième solution: affectation concurente sélective
s <= e0 e1 e2 e3
with n select s <= e0 e1 e2 e3
when when when when
n n n n
= = = =
"00" else "01" else "10" else "11";
when when when when
"00", "01", "10", others;
end Comporte_Mux4_1; end Comporte_Mux4_1; Remarque : Même schéma dans les deux cas.
6
Introduction au langage VHDL
1.3 Exercice 3 : Décodeur Hexadécimal / 7 segments Organisation des afficheurs à commander (anodes communes)
a
"0"
a
"1"
Segment éclairé
Segment éteint
Caractères à afficher
Schéma fonctionnel du décodeur
MSB
q3 q2 q1
LSB
q0
Décodeur Hexadécimal / 7 segments
a b c d e f g
Fonctionnement attendu Les entrées q3, q2, q1 et q0 peuvent prendre l'état logique « 0 » ou « 1 ». Pour chacune des combinaisons possibles du mot binaire Q = q3q2q1q0, on doit afficher le caractère hexadécimal correspondant.
7
Introduction au langage VHDL
Solution 1 « classique » : Table de vérité et détermination des équations des segments Pour chacune des combinaisons de Q, on détermine le code à envoyer sur les commandes des segments a, b, c, d, e, f et g. Ceci peut être résumé dans une table de vérité. q3 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1
q2 0 0 0 0 1 1 1 1 0 0 0 0 1 1 1 1
q1 0 0 1 1 0 0 1 1 0 0 1 1 0 0 1 1
q0 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
a 0 1
b 0 0
c 0 0
d 0 1
a = ------------------------------------------------------
e 0 1
a /q3./q2 /q3.q2 q3.q2 q3./q2
f 0 1
/q1./q0
g 1 1
Affichage 0 1 2 3 4 5 6 7 8 9 A b c d E F /q1.q0
q1.q0
q1./q0
Solution 2: Description comportementale en VHDL
entity Hex7seg is
architecture comporte_Hex7seg of Hex7seg is begin
end Hex7seg;
end comporte_ Hex7seg;
8
Introduction au langage VHDL
1.4 Exercice 4 : Démultiplexeur 1→ → 8 Ecrire le fichier .VHD correspondant au démultiplexeur 1→ → 8 ci-dessous.
S0 S1 I S6 S7 SEL
3
Solution 1 : utilisation d’un when… else architecture comporte_Demux1_8 of Demux1_8 is entity Demux1_8 is begin
end Demux1_8; end Demux1_8;
Solution 2: utilisation d’une instruction generate Compte tenu de la répétition des instructions, il est interressant d’utiliser l’instruction generate. On remplace les sortie distinctes S0…S7 par un vecteur de bit de manière à disposer d’un indice variable :
entity GDemux1_8 is
architecture comporte_GDemux1_8 of GDemux1_8 is
begin
end GDemux1_8;
end GDemux1_8;
9
Introduction au langage VHDL
2 Sorties trois états, entrées/sorties
2.1 Exercice 5 : Buffer trois états Ecrire le fichier .VHD correspondant au buffer ci-dessous. OE
8
8
D_OUT
D_IN
entity Buff_3_Etat is
architecture comporte_Buff_3 of Buff_3_Etat is begin
end comporte_Buff_3; end Buff_Trois_Etat ;
Remarque: La formulation (others => Z) est équivalente à “ZZZZZZZZ”
2.2 Exercice 6 : Transceiver Ecrire le fichier .VHD correspondant au transceiver ci-dessous.
OEAB
8
8
D_IN
D_OUT
OEBA
entity Transceiver is
architecture comporte_Trans of Transceiver is begin
end comporte_Trans; end Transceiver;
10
Introduction au langage VHDL
Schéma RTL du Transceiver
3 Circuits logiques séquentiels
Circuit séquentiel asynchrone Rappel : Un latch (ou verrou) possède deux modes de fonctionnement : passant lorsque son entrée LE (Latch Enable) est à un (par exemple), verrouillé lorsque LE est à zéro.
3.1 Exercice 7 : LATCH Ecrire le fichier .VHD correspondant au Latch ci-dessous.
D
8
8
Q
LE
entity Latch is
architecture comporte_Latch of Latch is begin
end Latch;
end comporte_Latch;
Schéma RTL du LATCH
11
Introduction au langage VHDL
Circuits séquentiels synchrones
3.2 Exercice 8 : Registre 8 bits Ecrire le fichier .VHD correspondant au registre ci-dessous. D
8
8
Fonctionnement Q <= D si ↑CLK
Q
CLK
architecture comporte_Reg of Reg is
entity Reg is
begin
end comporte_Reg; end Reg;
Schéma RTL du registre 8 bits
3.3 Exercice 9 : Registre avec mise à zéro asynchrone Ecrire le fichier .VHD correspondant au registre ci-dessous (mise à zéro asynchrone). 8 D
8
Q
clk
rst
12
Introduction au langage VHDL
entity RegRAZAS is
architecture compRegRAZAS of RegRAZAS is begin
end RegRAZAS;
end compRegRAZAS;
Remarque: Etant asynchrone, le signal rst peut déclencher le processus. Il doit donc se situer dans la liste de sensibilité. 3.4 Exercice 10 : Registre avec mise à zéro et mise à un synchrone Ecrire le fichier .VHD correspondant au registre ci-dessous (mise à zéro et mise à un synchrone). set 8
8
D
Q
clk
La mise à zéro doit être prioritaire.
rst entity RegSync is
architecture comporteRegSync of RegSync is begin
end RegSync; end comporteRegSync; Remarque : Le processus est uniquement déclenché par le signal clk. La position de rst dans le processus le rend prioritaire sur le transfert Q <- D.
13
Introduction au langage VHDL
3.5 Exercice 11 : Compteur binaire avec mise à zéro asynchrone Ecrire le fichier .VHD correspondant au compteur binaire avec mise à zéro asynchrone ci-dessous. 8
CPTR
Q
clk rst
entity CPTR is
architecture comporteCPTR of CPTR is begin
end Reg_Sync; end comporteCPTR; 3.6 Exercice 12 : Compteur binaire chargeable Ecrire le fichier .VHD correspondant au compteur chargeable ci-dessous (chargement synchrone, reset asynchrone). 8 D
CMPL
8 Q
clk load rst
entity CMPL is
architecture comporteCMPL of CMPL is
begin
end CMPL;
end comporteCMPL;
Remarque: Le type unsigned est associé à des vecteurs de bits considérés comme représentant des nombres non signés. 14
Introduction au langage VHDL
Fichier de simulation .abv module testcptl // input clk, rst, load pin; D_7_,D_6_,D_5_,D_4_,D_3_,D_2_,D_1_,D_0_ pin ; // output Q_7_,Q_6_,Q_5_,Q_4_,Q_3_,Q_2_,Q_1_,Q_0_ pin istype 'reg_d,buffer'; // Vectors Q = [Q_7_,Q_6_,Q_5_,Q_4_,Q_3_,Q_2_,Q_1_,Q_0_]; D = [D_7_,D_6_,D_5_,D_4_,D_3_,D_2_,D_1_,D_0_]; // constantes c = .c.; x = .x.; X = [x,x,x,x,x,x,x,x]; equations test_vectors ([clk,rst, load, D] -> [Q]) [c,1,0,0] -> [X]; @repeat 5 {[c,0,0,X] -> [X];} [c,0,1,8] -> [X]; @repeat 20 {[c,0,0,X] -> [X];} end
Simulation fonctionnelle
15
Introduction au langage VHDL
3.7 Exercice 13 : Compteur/Décompteur binaire chargeable Ecrire le fichier .VHD correspondant au compteur/décompteur ci-dessous. 8
CMPDEC
D
8 Q
Fonctionnement attendu - chargement synchrone, - reset asynchrone
clk
UP DOWN___Comportement_______ 0 0 Rien 1 0 compte 0 1 décompte 1 1 Rien
load rst down up
architecture comporte_CMP_DEC of CMP_DEC is
entity CMP_DEC is
begin
end CMP_DEC; end comporte_CMP_DEC;
Fichier de simulation .abv module testcpde // input clk, rst, load,up,down D_7_,D_6_,D_5_,D_4_,D_3_,D_2_,D_1_,D_0_
pin; pin ;
// output Q_7_,Q_6_,Q_5_,Q_4_,Q_3_,Q_2_,Q_1_,Q_0_
pin istype 'reg_d,buffer';
// Vectors Q = [Q_7_,Q_6_,Q_5_,Q_4_,Q_3_,Q_2_,Q_1_,Q_0_]; D = [D_7_,D_6_,D_5_,D_4_,D_3_,D_2_,D_1_,D_0_]; // constantes c = .c.; x = .x.; X = [x,x,x,x,x,x,x,x]; equations test_vectors ([clk,rst,load,up,down,D] -> [Q]) [c,1,0,0,0,0] -> [X]; @repeat 10 {[c,0,0,1,0,X] -> [X];} [c,0,1,0,0,20] -> [X]; @repeat 10 {[c,0,0,0,1,X] -> [X];} end
16
Introduction au langage VHDL
« Fichier .vhd » entity Div3b is
architecture Comporte of Div3b is (A REFAIRE)
port(
type liste_etat is (Etat0,Etat1,Etat2,Etat3); signal etat:liste_etat;
E, Rc: in std_logic ; s: out std_logic );
begin process(E) begin if (E'event and E='1') then case etat is when Etat0 => s <= '1'; if Rc='1' then etat <= Etat3; else etat <= Etat1; end if; when Etat1 => etat <= Etat2; s <= '0'; when Etat2 => etat <= Etat0; s <= '0';
end Div3b;
when others => etat <= Etat2; s <= '1'; end case; end if; end process; -- Autre solution: affectation externe de la sortie -- s <= '1'when ((etat = Etat3) or (etat = Etat0)) else '0'; end Comporte;
Simulation fonctionnelle
Remarque : Décalage des valeurs du bus d’états : voir l’annexe 2 du cours « Introduction au langage VHDL »
VHDL
CORRECTION DES EXERCICES
VHDL_Exercices_du_cours_corr
14022011
CFBS
TSO5
Introduction au VHDL
21
