VHDL Exercices Du Cours

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

A15 Decod_Add
à réaliser. ROM2
A14
Libre
A13 IO
RAM
$FFFF
ROM1 Solution 1 « classique » : Tableau d’adressage
(8k)
$E000 @ A15 A14 A13 A12 A11 A10 A9 A8 A7 A6 A5 A4 A3 A2 A1 A0
$DFFF $FFFF
ROM2 $E000
(8k) $DFFF
$C000 $C000
$BFFF $BFFF
Libre $4000
(32k)
$3FFF
$4000
$2000
$3FFF
$1FFF
I/O
$0000
(8k)
$2000
Remarque : Les broches de sélection des boîtiers mémoires sont actives
$1FFF à l’état bas.
RAM Equations /Libre /A15./A14 /0A115.A14 A15.A14 A15./A14

(8k) /A13
/ROM1 =
$0000 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
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 & C ou B ≥1 C

A A
4
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 MUX
préalablement appliquée aux n entrées de N M
commande (appelées entrées de sélection ou
d’adresse).
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 S
0 0 0 X X X E2
0 0 1 X X X E3
MUX4_1
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 n1 E0 E1 E2 E3 S
1 1 X X x 1 0 0 X X X X E0
0 1 X X X X E1
X : Indifférent 1 0 X X X X E2
1 1 X X X X 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
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 -- Deuxième solution: affectation

concurente conditionnelle concurente sélective
s <= e0 when n = "00" else with n select

e1 when n = "01" else s <= e0 when "00",
e2 when n = "10" else e1 when "01",
e3 when n = "11"; e2 when "10",
e3 when others;
end Comporte_Mux4_1;
end Comporte_Mux4_1;
Remarque : Même schéma dans les deux cas.
6
1.3 Exercice 3 : Décodeur Hexadécimal / 7 segments
Organisation des afficheurs à commander (anodes communes)
"0" a "1" a
Segment éclairé Segment éteint
Caractères à afficher
Schéma fonctionnel du décodeur
MSB q3 a
Décodeur b
q2 c
Hexadécimal d
q1 / e
f
7 segments g
LSB q0
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
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 q2 q1 q0 a b c d e f g Affichage
0 0 0 0 0 0 0 0 0 0 1 0
0 0 0 1 1 0 0 1 1 1 1 1
0 0 1 0 2
0 0 1 1 3
0 1 0 0 4
0 1 0 1 5
0 1 1 0 6
0 1 1 1 7
1 0 0 0 8
1 0 0 1 9
1 0 1 0 A
1 0 1 1 b
1 1 0 0 c
1 1 0 1 d
1 1 1 0 E
1 1 1 1 F
a /q1./q0 /q1.q0 q1.q0 q1./q0
/q3./q2
a = ------------------------------------------------------ /q3.q2
q3.q2
q3./q2
Solution 2: Description comportementale en VHDL
entity Hex7seg is architecture comporte_Hex7seg of Hex7seg is
begin
end Hex7seg;
end comporte_ Hex7seg;
8
→ 8
1.4 Exercice 4 : Démultiplexeur 1→
→ 8 ci-dessous.
Ecrire le fichier .VHD correspondant au démultiplexeur 1→
S0
S1
I
S6
S7
3
SEL
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
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_OUT
D_IN
OEBA
entity Transceiver is architecture comporte_Trans of Transceiver is
begin
end comporte_Trans;
end Transceiver;
10
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.
8
D 8
Q
LE
entity Latch is architecture comporte_Latch of Latch is
begin
end Latch; end comporte_Latch;
Schéma RTL du LATCH
11
Circuits séquentiels synchrones
3.2 Exercice 8 : Registre 8 bits
Ecrire le fichier .VHD correspondant au registre ci-dessous.
8 Fonctionnement
D 8
Q Q <= D si ↑CLK
CLK
entity Reg is architecture comporte_Reg of 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
8
D Q
clk
rst
12
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

rst être prioritaire.
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
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.
CPTR 8
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
CMPL 8
D
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
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
3.7 Exercice 13 : Compteur/Décompteur binaire chargeable
Ecrire le fichier .VHD correspondant au compteur/décompteur ci-dessous.
8 CMPDEC 8 Fonctionnement attendu

D
Q
- chargement synchrone,
clk - reset asynchrone
UP DOWN___Comportement_______
load 0 0 Rien
1 0 compte
rst 0 1 décompte
1 1 Rien
down
up
entity CMP_DEC is architecture comporte_CMP_DEC of CMP_DEC is
begin
end CMP_DEC;
end comporte_CMP_DEC;
Fichier de simulation .abv
module testcpde
// input
clk, rst, load,up,down 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,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
« Fichier .vhd »
entity Div3b is architecture Comporte of Div3b is (A REFAIRE)
port( type liste_etat is (Etat0,Etat1,Etat2,Etat3);

E, Rc: in std_logic ; signal etat:liste_etat;
s: out std_logic );
begin
end Div3b; 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';
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 CFBS TSO5 Introduction au VHDL 21

VHDL_Exercices_du_cours_corr 14022011

VHDL Exercices Du Cours

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

VHDL Exercices Du Cours

Transféré par

Droits d'auteur :

Formats disponibles

Introduction au langage

2 Sorties trois états, entrées/sorties . ...........................................10

3 Circuits logiques séquentiels . ..................................................11

1 Fonctions logiques combinatoires

1.1 Exercice 1 : Décodage d’adresses

On donne ci-dessous un plan mémoire (mapping memory) ROM1

RAM Equations /Libre /A15./A14 /0A115.A14 A15.A14 A15./A14

Solution 2 : Description « flot de données » en VHDL (.vhd)

architecture flot_Decod_Add of Decod_Add is

Solution 3 : Descriptions comportementales en VHDL (.vhd)

Utilisation d’une affectation concurrente conditionnelle

On se limite à la sortie ROM1.

architecture comporte1_Decod_Add1 of Decod_Add1 is

Utilisation d’une affectation concurrente sélective

On se limite à la sortie ROM1.

architecture comporte2_Decod_Add1 of Decod_Add1 is

Pièges à éviter lors de la synthèse des fonctions combinatoires :

Les mémorisations implicites !

Remarque concernant les affectations ci-dessus

et se synthétise comme ci-contre !

C <= B when A=’1’ else ‘-‘;

qui se synthétise par : B & C ou B ≥1 C

1.2 Exercice 2 : Multiplexeur

Rappels : La fonction multiplexage est une

Réalisation d’un multiplexeur 4 -> 1

Solution 1 « classique » : Table de vérité partielle

Remarque : L’équation fait apparaître des sommes de produits faciles à

Solution 2 : Description comportementale en VHDL (.vhd)

Remarque : choisir une affectation concurrente.

architecture comporte_mux4_1 of mux4_1 is

Proposer les modifications à effectuer pour que le décodeur précédant traite

Schéma RTL: Multiplexeur 4 -> 1

architecture Comporte_Mux4_1 of Mux4_1 is architecture Comporte_Mux4_1 of Mux4_1 is

-- Première solution: affectation -- Deuxième solution: affectation

s <= e0 when n = "00" else with n select

Remarque : Même schéma dans les deux cas.

1.3 Exercice 3 : Décodeur Hexadécimal / 7 segments

Organisation des afficheurs à commander (anodes communes)

Segment éclairé Segment éteint

Schéma fonctionnel du décodeur

Solution 1 « classique » : Table de vérité et détermination des équations des

Pour chacune des combinaisons de Q, on détermine le code à envoyer sur les

Solution 2: Description comportementale en VHDL

entity Hex7seg is architecture comporte_Hex7seg of Hex7seg is

end comporte_ Hex7seg;

Solution 1 : utilisation d’un when… else

architecture comporte_Demux1_8 of Demux1_8 is

Solution 2: utilisation d’une instruction generate

Compte tenu de la répétition des instructions, il est interressant d’utiliser

entity GDemux1_8 is architecture comporte_GDemux1_8 of GDemux1_8 is

end GDemux1_8; end GDemux1_8;

2 Sorties trois états, entrées/sorties

2.1 Exercice 5 : Buffer trois états

Ecrire le fichier .VHD correspondant au buffer ci-dessous.

entity Buff_3_Etat is architecture comporte_Buff_3 of Buff_3_Etat is

Remarque: La formulation (others => Z) est équivalente à “ZZZZZZZZ”

2.2 Exercice 6 : Transceiver

Ecrire le fichier .VHD correspondant au transceiver ci-dessous.

entity Transceiver is architecture comporte_Trans of Transceiver is

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