Examen VHDL 2eme session 2008

Exercice 1 : (7 points)

Le circuit d’un registre à décalage synchrone (front montant) est donné sur la
figure suivante :

1) Ecrire l’entité qui décrit la vue externe de ce registre.

2) Donner une architecture comportementale (tableau ci-dessus) en utilisant
un process. Dans le process, vous pouvez utiliser l’instruction if….
Then…..elsif et l’instruction for…..loop.

Exercice 2 : (7 points)

On considère le programme VHDL suivant qui décrit le fonctionnement d’une

bascule :

entity basc is
Port ( T, clk, init : in bit;
S: out bit);
end basc;

architecture primitive of basc is

signal etat : bit;

begin
 S <= etat;
process (clk)
begin
if (clk'event and clk='1') then
if ( init ='0') then
etat <= '1';
elsif (T='0') then
etat <= not etat;
end if;
end if;
end process;
end primitive;

1. A quoi reconnaît-on qu’il s’agit d’un circuit synchrone ?

2. La commande « init » est elle synchrone ou asynchrone ? (justifier)
3. Compléter le chronogramme ci-dessous.

4. Modifier le programme précédent pour qu’il rajoute à la bascule une commande

raz, de remise à zèro, asynchrone.
5.Transformer le programme pour qu’il utilise le type st-logic. Rajouter une
commande oe de contrôle qui fasse passer la sortie en haute impédence si oe=’0’.

Exercice 3 :(6 points)

Il s’agit de réaliser un signal d’horloge (CLOCK) à un fréquence de 1Hz à partir

d’un quartz (OSC) qui génère un signal d’horloge à 10 MHz, qu’il va donc falloir
diviser par 10.106 afin d’obtenir la fréquence voulue. Cette opération peut se faire en 2
étapes tout d’abord avec un diviseur par 5.106 puis un diviseur par 2.

1. Donner la description en langage VHDL (Entity et Architecture) d’un diviseur

par 5.106 à partir de 3 compteurs 8 bits. Utiliser pour cela 3 variables (COUNT_0,
COUNT_1, COUNT_2) de type integer, représentant chacune la valeur d’un compteur.

2. Donner la description d’un diviseur par 2 en utilisant la bascule D avec remise à zèro
asynchrone (RST).

Correction
Exercice 1 :

library ieee;
use ieee.std_logic_1164.all;

entity register1 is port (

H, IR,IL,S0,S1 : in std_logic;
I: in std_logic_vector (3 downto 0);
Q : buffer std_logic_vector (3 downto 0));
 end register1;

architecture arch of register1 is

Begin
process (S0, S1, H)
variable Z : integer;
variable N: Integer:=0;
begin
if (H'event and H ='1') then
if (S0='0' and S1= '0') then Q<=Q;
elsif (S0='0' and S1= '1') then Q<=I;
elsif (S0 ='1' and S1='0') then
Boucle1: For Z IN 3 downto 1 Loop
N:=Z-1;
Q(Z)<=Q(N);
End loop Boucle1;
Q(N)<=IR;
elsif (S0 ='1' and S1='1') then
Boucle2 : For Z IN 0 to 2 Loop
N:=Z+1;
Q(Z)<=Q(N);
End loop Boucle2;
Q(N)<=IL;
end if;
end if;
end process;
end arch;

Exercice 2 :

1. Seul le signal d’horloge clk fait partie de la liste de sensibilité de process.

Seul un changement d’état du signal clk va déclencher le process et par
conséquent évaluer les instructions de celui-ci.

1. La commande « init » est synchrone de l’horloge clk, et elle n’est pas

mentionnés dans la liste de sensiblité du process, par conséquence le
process ne sera déclenché que par le signal d’horloge clk. La commande ne
fera que si un front montant sur clk aura lieu.

1. chronogramme

4.
entity basc is
Port ( T, clk, init,raz : in bit;
S: out bit);
end basc;
architecture primitive of basc is
signal etat : bit;
begin
S <= etat;
process (clk,raz)
begin
if (raz='1') then etat<= '0';
 elsif (clk'event and clk='1') then
if ( init ='0') then
etat <= '1';
elsif (T='0')then
etat <= not etat;
end if;
end if;
end process;
end primitive;

5.
Library ieee;
use ieee.std_logic_1164.all;
entity basc is
Port ( T, clk, init,raz,oe : in std_logic;
S: out std_logic);
end basc;
architecture primitive of basc is
signal etat : std_logic;
begin
S <= etat;
process (clk,raz,oe)
begin
--wait until (clk = '1');
if (oe='0') then etat<= 'Z';
elsif (raz='1') then etat<= '0';
elsif (clk'event and clk='1') then
if ( init ='0') then
etat <= '1';
elsif (T='0')then
etat <= not etat;
end if;
end if;
end process;
end primitive;

Exercice 3 :
1.
Library ieee;
use ieee.std_logic_1164.all;
use ieee.std_logic_arith.all;
use ieee.std_logic_unsigned.all;

entity div_freq is port

(OSC : in std_logic;
CLOCK : inout std_logic);
end div_freq;
architecture arch_div_freq of div_freq is
begin
process (OSC)
variable COUNT_0, COUNT_1, COUNT_2 : integer range 0 to 250;
begin
if (OSC'event and OSC ='1') then
COUNT_0:= COUNT_0+1;
if COUNT_0=250 then
COUNT_1:= COUNT_1+1;
COUNT_0:=0;
 if COUNT_1=250 then
COUNT_2:= COUNT_2+1;
COUNT_1:=0;
if COUNT_2=80 then
COUNT_2:=0;
if CLOCK='1' then CLOCK<='0';
else CLOCK <='1';
end if;
end if;
end if;
end if;
end if;
end process;
end arch_div_freq;
2.
Library ieee;
use ieee.std_logic_1164.all;
entity div_2 is
Port ( CLOCK : inout std_logic; RST : in std_logic; Q: out std_logic);
end div_2;
architecture arch_div_2 of div_2 is
signal D,QN : std_logic;
begin
process (CLOCK,RST)
begin
if (RST='1') then Q<= '0'; QN<= '1';
elsif (CLOCK'event and CLOCK ='1') then Q<=D; QN<=not D;
end if;
end process;
D <= QN;
end arch_div_2 ;

Examen VHDL 1ere session 2009

Exercice 1 : Comparateur (3 points)

On veut modéliser un circuit permettant de comparer 2 bus de données de 8 bits, A

et B, et de générer 3 signaux de sortie :
EQUA si les données sur les deux bus sont égales,
SUPE si la donnée du bus A est supérieure à la donnée du bus B,
INFE si la donnée du bus A est inférieure à la donnée du bus B,
A et B sont des entrées du type std_logic_vecteur;
EQUA, SUPE, INFE sont des sorties de type std_logic ;
Ecrire l’entité de ce comparateur de 8 bits et coder l’architecture de ce modèle.

Exercice 2 : Modélisation et styles en VHDL (3 points)

Soit la description VHDL suivante:

entity exercice2 port (

x1, x2, x3, sel: in std_logic;
y: out std_logic);
end exercice2;
architecture archi of exercice2 is
signal a, b, c, d, e, f: std_logic;
begin
a <= x1 or x3;
b <= x1 and x3;
c <= x2 and a;
d <= b or c;
e <= x1 xor x2;
f <= x3 xor e;
P1: process (d, f, sel)
begin
if sel=’0’ then
y <= d;
else
y <= f;
end if;
end process P1;
end architecture archi;

1. Tracez à partir d’éléments de base le schéma correspondant.

2. Le processus P1 est-il combinatoire ou séquentiel? Justifiez.
3. Quel est selon vous la fonction de ce circuit?

4. À partir de la même entité, écrivez une architecture exploitant la logique 3-etats

pour la sélection de la sortie via le signal sel.

Exercice 3 : Diagramme d’état (4 points)

Le système à concevoir dispose de trois entrées et de deux sorties. Les entrées
sont l’horloge clk, RAZ et la commande x ; les sorties sont S0 et S1. Les entrées et
les sorties sont de type std_logic sauf x est de type bit. La description du système
se fait par un nombre fini d’états. Ci-dessous la représentation schématique d’un
système à 4 états (A, B, C et D) :
1. Donner la description en langage VHDL (Entité et Architecture) de ce système en
se basant sur le diagramme d’état. Le système est actif sur front montant.
2. Compléter le chronogramme suivant du système :

Exercice 4 : Registre à décalage (3 points)

Le registre à décalage commandé est représenté sur la figure suivant. Ce registre
doit être capable de réaliser un décalage vers la droite (commandé par le
signal ShiftR), et un décalage vers la gauche (commandé par le signal ShiftL) et
utilise des données de 8 bits.
Ce composant accepte deux entrées :
• Une entrée série (Sin), dont la valeur est copiée dans le bit de poids fort du
registre si le signal shiftR vaut ‘1’, ou dans le bit de poids faible si shiftLvaut ‘1’.
• Une entrée parallèle (Din) sur 8 bits, qui est chargée dans le registre sur un front
montant d’horloge si le signal Load vaut ‘1’.
Le composant dispose également de deux sorties :
• Une sortie série Sout qui correspond à la valeur courante du bit de poids le plus
faible.
• Une sortie parallèle (Dout) sur 8 bits, qui représente la valeur courante du
registre.
1. Donner la table de vérité de ce registre à décalage commandé.

1. Donnez la description en VHDL synthétisable de ce registre utilisant un

process. Dans le process, vous pouvez utiliser l’instruction if…. Then et
l’instruction for…..loop.

Correction

Exercice 1 :
Library ieee;
use ieee.std_logic_1164.all;
entity comparateur8bits is port
(A, B: in std_logic_vector (7 downto 0);
EQUA, SUPE, INFE: out std_logic);
end comparateur8bits;

architecture ARCH_comparateur8bits of comparateur8bits is

Begin
EQUA<='1' when A=B else '0';
SUPE<='1' when A>B else '0';
INFE<='1' when A<B else '0';
end ARCH_comparateur8bits;

Exercice 2 :
1- Le schéma correspondant

2- C’est une description comportementale, puisqu’il n’y a aucune composante.

C’est un processus combinatoire car il inclut toutes les entrées (signaux lus)
dans la
liste de sensitivité. De plus, toutes les valeurs possibles de sel sont traitées.

3 - C’est un plein additionneur avec multiplexage des sorties somme et retenue.

4- architecture archi2 of exercice2 is
signal a, b, c, d, e, f: std ulogic;
signal ytemp: std logic;
begin
a <= x1 or x3;
b <= x1 and x3;
c <= x2 and a;
d <= b or c;
e <= x1 xor x2;
f <= x3 xor e;
P1: process (d, f, sel)
begin
if sel=’0’ then
ytemp <= d;
else
ytemp <= ’z’;
end if;
end process P1;
P2: process (d, f, sel)
begin
if sel=’1’ then
ytemp <= f;
else
ytemp <= ’z’;
end if;
end process P2;
y <= ytemp;
end architecture archi;

Exercice 3 :

Library ieee;
use ieee.std_logic_1164.all;
-- entity statement
Entity Moore_Machine is port
(x, CLK : in BIT; S1,S2 : out BIT);
End Moore_Machine;
-- architecture statement

Architecture FSM of Moore_Machine is

type STATE_TYPE is (Etat0, Etat1, Etat2, Etat3);
signal STATE : STATE_TYPE := Etat0;
signal S :bit_vector (1 downto 0);
begin
--block funtion
NEXT_STATE: block (CLK'event and CLK='1')
begin
-- guarded conditional concurrent signal assignment statement
STATE <= guarded Etat0 when (STATE=Etat0 and x='0') else
Etat1 when (STATE=Etat0 and x='1') else
Etat2 when (STATE=Etat1 and x='1') else
Etat3 when (STATE=Etat2 and x='0') else
Etat2 when (STATE=Etat2 and x='1') else
Etat0 when (STATE=Etat3 and x='0') else
Etat1 when (STATE=Etat3 and x='1') else
Etat3 when (STATE=Etat1 and x='0') else
STATE;
end block NEXT_STATE;
-- unguarded selected concurrent signal assignment statement

with STATE select

S <= "00" when Etat0,
"10" when Etat1,
"11" when Etat2,
"01" when Etat3,
"00" when others;

S1<=S(0);
S2<=S(1);

End FSM;

library ieee;
use ieee.std_logic_1164.all;

--library SYNTH ;
--use SYNTH.vhdlsynth.all ;
----- Définition de l'entité----
ENTITY diagramme IS
PORT (raz, clk :IN STD_LOGIC; -- Ne pas oublier remise à 0 et horloge !
x :IN bit;
S1,S2 :OUT STD_LOGIC);
END diagramme;

------ Définir L'architecture de description d'état -----------------

ARCHITECTURE arch_diagramme OF diagramme IS
TYPE etat_4 IS (A, B, C, D); --définir une liste des états...
SIGNAL etat,etat_suiv :etat_4 := A; --et 2 signaux: états courant et –-
suivant, contenant la valeur d’un état de la liste (initialisée à M0) .
signal S :std_logic_vector (1 downto 0);
BEGIN
definir_etat:PROCESS( raz, clk) -- "definir_etat":label optionnel
BEGIN
If raz = '1' THEN
etat <= A; --Le PACKAGE
std_logic_1164
ELSIF rising_edge(clk) THEN --en permet
l’utilisation.
etat <= etat_suiv ;
END IF; --Mise à
jour de la variable
END PROCESS definir_etat;

------------ Définir les états des sorties-------------------

sorties : process (etat, x) --Le PROCESS doit contenir une...

BEGIN --structure de CAS
unique dépendant
--de la variable d’état.
CASE etat IS
--Le signal de l’état suivant n’est
--attribué que dans la structure CASE

WHEN A => S <= "00";

If x ='1' then etat_suiv <= B;

elsif x ='0' then etat_suiv <= A;
end if;

WHEN B => S <= "10";

If x ='1' then etat_suiv <= C;

elsif x ='0' then etat_suiv <= D;
end if;

WHEN C => S <= "11";

If x ='1' then etat_suiv <= C;

elsif x ='0' then etat_suiv <= D;
end if;

WHEN D => S <= "01";

If x ='1' then etat_suiv <= B;

 elsif x ='0' then etat_suiv <= A;
end if;
END CASE;
END process sorties ;
S1<=S(0);
S2<=S(1);

END arch_diagramme ; -- ne pas oublier de terminer

l’architecture !
Exercice 1 : Conception d'un système de gestion de parking (3 points)

Le but de notre système est de gérer la disponibilité des places de parking. Ce système
possède 4 signaux d’entrée (mode in) les captures d’entrée-sortie de type std_logic,
l’horloge et le nombre maximal de places dans le parking (mot binaire de 4 bits de type
std_logic_vector). Les entrées capteurs servent à incrémenter ou
à décrémenter le compteur (4 bits). La sortie de compteur est comparée au nombre
maximal de places dans le parking.
Les signaux de sortie (mode out) sont :

PD = 1 s’il reste des places disponibles si non PD=0 (type std_logic).

PC= 1 si le parking est complet si non PC=0 (type std_logic).

a. Ecrire l’entité qui décrit la vue externe de ce système.

b. Donner l’architecture comportementale en utilisant un process et de l’affectation
conditionnelle. Utilisez dans le process l’instruction if…. Then…..elsif...

Exercice 2 : Communication par liaison série (6 points)

Il s’agit de réaliser à partir d’un code source en VHDL une communication par liaison
série entre deux module, voir schéma ci-dessous.

I– Réalisation du MODULE A

1. Diviseur:
Ce sous module assure la division de l’horloge HOR à 48 MHz afin d’obtenir un signal
de fréquence 10 kHz permettant de cadencer l’envoi de chaque bit.
Réaliser ce diviseur à partir de 3 compteurs 8 bits. Utilisez pour cela 3 variables
(COUNT_0, COUNT_1, COUNT_2) de type integer, représentant chacune la valeur
d’un compteur.

2. Compteur Front Montant/Front Descendant :

Grâce à ce sous module, on compte les différents fronts montant et descendant de

l’horloge 10 KHz afin de pouvoir positionner la sortie clk au repos (clk = 0) ou active
(horloge 10 kHz).
Dans notre cas, la sortie clk se positionne au repos (niveau logique 0) lorsque 8 fronts
montant et descendant auront été comptés (correspondant à l’envoi de 8 bits). La sortie
clk sera à nouveau active si le signal raz est actif (envoi d’une nouvelle donnée).
Décrire le comportement en VHDL de ce sous module.

3. Sérialisation :

Ici, ce module effectue la sérialisation de la donnée 8 bits présente sur donnée Din, cette
donnée est sérialisée grâce au cadencement 10kHz (clk) du sous module sérialisation.
Pour se faire on va procéder par décalage du bus donné. C'est-à-dire que le bit 0 (LSB)
va être envoyé, ensuite on décale les bits 8 à droite et nous répétons cela 7 fois. On aura,
au total, envoyé nos 8 bits de commande un à un. La sortie du module A nommé data.
Donnez la description en VHDL synthétisable de ce registre à décalage à droite
chargement parallèle synchrone.

II- Réalisation du MODULE B :

Le module B nous permettra de réceptionner la donnée série émise par le module A puis
de l’envoyer à l'afficheur lcd. Le module permet simplement la désérialisation des
données reçus par le Module A nommée data et qui a été envoyé grâce à l’horloge
clk. RAZ remise à zéro (1 bit) asynchrone actif au niveau bas (‘0’).

Faire une description en langage VHDL (entity et architecture) d’un registre série-
parallèle à 8 bits pour le module B.
Exercice 3 : Diagramme d’état d’un circuit asynchrone (4 points)

Le système à concevoir dispose deux entrées R et P et une sortie Q. Les valeurs

d'entrée sont indiquées sur les arcs, les noms de l'état et les valeurs de sortie des états
stables sont indiquées dans les cercles. Sans oublier l’entrée d’horloge qui fait avancer
le processus, et celle de remise à zéro qui permet de l’initialiser le système: L’état initial
est l’état A.
La description du système se fait par un nombre fini d’états. Ci-dessous la
représentation schématique d’un système à 6 états (A, B, C, D, E et F) :

Donner la description en langage VHDL (Entité et Architecture) de ce système en se

basant sur le diagramme d’état. Le système est actif sur front montant.
Exercice 1 : (10 points)

Il s’agit de développer un modèle structurel d’un registre N bits avec une entrée série et
une sortie parallèle basé sur les composants des bascules D.

L’entrées: Horloge CLK (1 bit), reset RST_B remise à zéro (1 bit) asynchrone actif au
niveau bas (’0’), données série DIN (1 bit) et les Sorties: Contenu du registre DOUT (N
bits). N un paramètre générique. Faire une description structurelle en langage VHDL
(entity et architecture) d’un registre Registre série-parallèle à 16 bits (voir shéma ci-
dessus) . L’usage d’une instruction generate est requise.

Exercice 2: (5 points)

On considère le programme ci-dessous (écrit en VHDL) :

Library ieee;
use ieee.std_logic_1164.all;

entity transitm is port ( clk, e : in bit ;

s : out bit );
end transitm ;

architecture quasi_struct of transitm is

signal qa, qb : bit ;

begin
schem : process (clk)
begin
If ( clk'event and clk = '1') then
qa <= e ;
qb <= qa ;
end if;
end process schem ;
s <= qa xor qb ;
end quasi_struct ;
 1. Déduire de ce programme, par une construction méthodique, un schéma
(bascules
et portes logiques).
1. Compléter le chronogramme ci-dessous.

Exercice 3 : (5 points)

Le système à concevoir dispose de deux entrées et de deux sorties. Les entrées sont
l’horloge clk et la commande C ; les sorties sont S1 et S2. Les entrées et les sorties sont
de type std_logic sauf C est de type bit. Le système est actif sur front descendant. Le
système répond au chronogramme suivant :

Donner la description en langage VHDL (Entity et Architecture) de ce système en

utilisant un process. Dans le process, utiliser l’instruction case …. is when, et
l’instruction if ….. then …. else.

Correction
Exercice1:

Library ieee;
use ieee.std_logic_1164.all;

Entity D_RAZ is port

(D, clk, CLR : in std_logic;
Q : out std_logic);
End D_RAZ;

Architecture arch_D_RAZ of D_RAZ is

Begin
process (clk, CLR)

Begin

IF (CLR='0') then Q<='0';

ELSIF (clk'event and clk = '1') then Q<=D;
END IF;
END process;
END arch_D_RAZ;

Library ieee;
use ieee.std_logic_1164.all;

entity registre is port

(DIN, clk, REST_B : in std_logic;
DOUT : out std_logic_vector (15 downto 0));
End registre;

architecture arch_registre of registre is

component D_RAZ port (D, clk, CLR : in std_logic;
Q : out std_logic);
end component;

signal S : std_logic_vector (15 downto 0);

constant Nb_bits : integer :=15;

begin
cellule : for i in Nb_bits downto 0 generate

cellule_16 : if i = Nb_bits generate

D_RAZN_1 : D_RAZ port map ( DIN, clk, REST_B,S(15));
DOUT(i)<=S(i);
end generate cellule_16;

cellule_int : if (i<Nb_bits and i >0 ) generate

D_RAZint : D_RAZ port map ( S(i+1), clk, REST_B,S(i));

DOUT(i)<=S(i);
end generate cellule_int;

cellule_0 : if (i=0 ) generate

D_RAZ0 : D_RAZ port map ( S(i+1), clk, REST_B,S(i));

DOUT(0)<=S(0);
end generate cellule_0;

end generate cellule;

end arch_registre;

Exercice2:

Exercice 3 :

Library ieee;
use ieee.std_logic_1164.all;

entity seq is port (clk: in std_logic;

C: in bit; S1,S2: out std_logic);
end seq;

architecture arch_seq of seq is

signal Etat : std_logic_vector (2 downto 0);
begin
process (C,clk)

begin

if (clk' event and clk ='0') then

case Etat is
when "000" => S1<='0' ; S2<='0';
if C='1' then Etat <= "001";
else Etat <= "000";
end if;
when "001" => S1<='1' ; S2<='0';

if C='0' then Etat <= "010";

else Etat <= "001";
end if;

when "010" => S1<='1' ; S2<='1';

if C='0' then Etat <= "011";
else Etat <= "001";
end if;

when "011" => S1<='0' ; S2<='1';

if C='0' then Etat <= "100";
else Etat <= "001";
end if;

when "100" => S1<='0' ; S2<='0';

if C='0' then Etat <= "000";
end if;

When others => Etat <= "000";

end case;
end if;
end process;
end arch_seq;