Vous êtes sur la page 1sur 51

Logique séquentielle en

VHDL

Chapitre 4

Olivier Romain
Professeur des Universités
Olivier.romain@gmail.com
http://olivieromain.free.fr
Plan du chapitre 4

• Logique séquentielle
• Asynchronisme / Synchronisme
• Les Lachs et les Bascules
• Les Registres
• Les Piles
• Les Compteurs
• Conclusion
Logique Séquentielle ?

Rappels
Combinatoire et séquentiel

• Combinatoire • Séquentiel

 Les sorties dépendent des  Les sorties dépendent de la


entrées uniquement à l’instant séquence des entrées du
t. Pas de mémorisation temps 0 au temps t.
 Il y a mémorisation.
 z(t) = F(x(t))
 z(t) = F(x(0,t))

x x
z z
temps temps
t t
Combinatoire et séquentiel

• Combinatoire • Séquentiel
 De manière idéale, les sorties  Circuit combinatoire rebouclé
sont définies au moment de  Les sorties dépendent de la
l’application de la nouvelle combinaison des entrées et de
combinaison des entrées l’état des variables internes (reflet
 Valeur instantanée de l’état antérieur des sorties)
 De manière réelle, les sorties sont
définies avec un retard
(temps de propagation, Δt)

Sortie Entrée Sortie


Entrée
z(t) e(t) z(t)
e(t) Logique Logique
Δt
combinatoire combinatoire

Elément
Mémorisant
(variable interne y)

Horloge
Logique séquentielle

• Définition
 Un circuit électronique est dit séquentiel si ses sorties sont déterminées
non seulement par la combinaison de ses variables d’entrées, mais
aussi par la séquence des combinaisons précédentes de ses entrées et
de l’état initial du système

• Conséquences
 Un système séquentiel est un système combinatoire des variables (en-1,
…, ei, …, e0, yp-1, …,yi, …, y0)
 Les variables internes (yp-1, …,yi, …, y0) indiquent l’état présent du
systèmes
 Les entrées et les variables internent préparent l’état futur du système
Asynchronisme
Synchronisme
Circuits séquentiels
asynchrones et synchrones
• Asynchrones : • Synchrones :
 Evolution spontanée des  les entrées sont prises en
sorties en fonction des entrées compte et les sorties évaluées
 Succession d’état transitoire à des instants discrets définis
avant l’apparition de l’état  par exemple un signal
stable d’horloge

horloge
Circuits séquentiels
asynchrones et synchrones
• Le synchronisme des sorties peut être donné de trois manière
différentes

 Sur niveau : la ou les sorties n’évolueront que si le signal de


synchronisation présente un niveau qui le rend actif
 Synchronisation à l’état haut
 Synchronisation à l’état bas

 Sur front du signal de synchronisation


 Front montant (passage de l’état bas à l’état haut)
 Front descendant (passage de l’état haut à l’état bas)

 Sur Impulsion : deux fronts


 Front montant pour les entrées
 Front descendant pour les sorties
Circuits séquentiels
asynchrones et synchrones
• Asynchrone • Synchrone

e e

z z
tps clk tps

Prise en compte des valeurs Prise en compte des valeurs


du signal d’entrée à chaque du signal d’entrée / front de
instant l’horloge
Horloge

• Signal périodique
• Entre 2 tops d’horloge, il n’y a pas de changement
d’états
 temps discrétisé

Front descendant
Front montant TH T = TH + TB
TH
Rapport cyclique = <1
T
T : Période TB 1
Fréquence F =
T
t1 t2 t3 tps
Horloge

• Dans un processus • Utilisation du type std_logic et de


la fonction
 utilisation wait
 rising_edge
 wait until clk’event and
 falling_edge
clk=‘1’;
Process(clk)
 wait until clk’event and begin
clk=‘0’;
if falling_edge(clk) then
end if;
Process end process;
Begin
wait until clk’event and clk=‘1’; Process(clk)
end process; begin
if rising_edge(clk) then
end if;
end process;
Les Bascules
Bascule D

• Echantillonnage des entrées sur front d’horloge


• Comportement indépendant de la largeur du signal
d’horloge CLK

D Q D Q

CLK CLK

CLK CLK

D D
Q Q
Bascule D

• Table de vérité
D Qn+1 Qn+1
0 0 1
1 1 0

• Expression caractéristique :
Qn+1=Dn

• Logigramme
D S Q D S Q
CLK CLK
R Q’ R Q’
Bascule D

• Circuits TTL • Circuits CMOS


 74LS74, 74LS174, 74LS175,  CD4013, CD40174, CD40175
74LS378, 74LS273, …
Bascule D en VHDL

Entity DFF is Architecture sequentiel2 of LatchD is


port ( Begin
D,clk : in std_logic; Process
Q, Q_bar : out std_logic ); Begin
end DFF; Wait until clk=‘1’;
Q <= D;
Architecture behav of DFF is Q_bar <= not D;
signal Q1, Q1_bar : std_logic; end process;
Begin end sequentiel2;
Process(clk)
Begin
if (clk=‘1’ and clk’event) then Architecture sequentiel3 of LatchD is
Begin
Q1 <= D;
Q <= D when clk=‘1’ and clk’event ;
Q1_bar <= not D;
Q_bar <= not D when clk=‘1’ and clk’event ;
else end process;
Q1 <= Q1; end sequentiel3;
Q1_bar <= Q1_bar;
end if;
end process;
end behav;
Contraintes temporelles

• Temps d’établissement (tsu):


 temps pendant lequel la donnée D Q
doit rester stable avant d’être
échantillonnée. CLK

• Temps de maintien (thold): tw


 temps pendant lequel la donnée
doit rester stable après CLK
l’échantillonnage.
D
• Temps de propagation (tp): tsu th
 temps écoulé entre le moment où
l’entrée est échantillonnée et le
moment où elle est disponible en Q
sortie de la Flip Flop. tp
Contraintes temporelles

• Exemple de caractéristiques temporelles d’une Flip


Flop
Les registres
Registres

• Ensemble de bascules identiques interconnectées entre-elles, soit


directement, soit par des opérateurs combinatoires
• La fonction du registre dépend de l’interconnexion entre entrées et
sorties
4 types :
Entrées //
•PIPO : Parallel In-
n Parallel Out
Entrée série Sortie série
1 1
•SISO : Serial In - Serial
Registre Out

n
•SIPO : Serial In -
Parallel Out
Commandes Sortie // •PISO : Parallel In -
Serial Out
Registres

• Les registres sont particulièrement utilisées en électronique


numérique pour
 Stockage temporaire des informations
 Transmissions des informations
 Conversion série/parallèle
 Ligne à retard numérique
 …

• 3 familles principales
 Registre à décalage
 Registre mémoire
 Registre de synchronisation
Registre à décalage

• Définition :
 Registre capable de transférer des données entre 2 cellules binaires
consécutives
 Sens du transfert :
 bidirectionnel
 unidirectionnel (gauche vers droite ou droite vers gauche)

• Caractéristiques d’un registre à décalage complet


 1 entrée x de chargement parallèle sur n bits
 1 entrée série xR pour le décalage série vers la droite
 1 entrée série xL pour la décalage série vers la gauche
 1 entrée de contrôle CTRL sur 2 bits pour le chargement parallèle ou le
décalage série
 1 entrée CLR d’initialisation (a)synchrone
 1 sortie z sur n bits
Registre à décalage

• Représentation symbolique
x
n

xR xL
Registre
clk
à décalage z0 : sortie série droite
CTRL CLR
2
zn-1 : sortie série gauche
n
z
xn- xn- xn-
1 2 3 x0
xR xL
clk n-1 n-2 n-3 0
CTRL
zn-1 zn-2 zn-3 z0
Registre à décalage

1 0 1 0
Clk↑
1 0
clk 1 0 1 0
CTRL

0 0 0 0
1 0 1 0
Clk↑
1 0
clk 1 0 1 0
CTRL

1 0 1
1 0
0
1 0
Clk↑
1 0
clk 0 1 0 0
CTRL

0 1 0 0
Clk↑
1 0 1 0
1 0
clk 0 0 1 0
CTRL

0 0 1 0
Registre à décalage

• Implémentation d’un registre à décalage sur 4 bits


x3 x2 x1 x0
xL
xR
3 2 1 0 3 2 1 0 3 2 1 0 3 2 1 0
MUX MUX MUX MUX
c1
c0

D Q D Q D Q D Q

clk
z3 z2 z1 z0

CTRL C1 C0
NONE 0 0
LEFT 0 1
RIGHT 1 0
LOAD 1 1
Registre à décalage

• Registre à décalage et multiplication-division


 Décalage vers la droite division /2
 Exemple : CTRL=RIGHT, xR=0 et x=1000(8)
 z=0100 (4), 0010(2), 0001(1)

 Décalage vers la gauche multiplication x2


 Exemple : CTRL=LEFT, xL=0 et x=0011 (3)
 z=0110(6), 1100(12)
Registre à décalage

• Circuits TTL • Circuits CMOS


 74LS91, 74LS95, 74LS164,  4014, 4015, 40194, 4031,
74LS166, 74LS194, … 4034, 4035, 4094, 4517
Registre en VHDL

• Exemple de registre SISO Entity SHIFTER_SISO is


Generic (

 Data_out(t)=data_in(t-N) );
nb_stage : integer := 32

 Ligne à retard numérique port (


data_in, clk : in std_logic;
data_out : out std_logic );
end SHIFTER_SISO;
• Le paramètre générique
Architecture behav of SHIFTER_SISO is
permet de définir la taille du signal registre : std_logic_vector (nb_stage-1 downto 0);
Begin
registre
Process
Begin
wait until clk=‘1’;
registre(0) <= data_in;
data_out <= registre(nb_stage-1);
data_in SISO data_in For i in nb_stage-1 downto 0 loop
1 1
registre(i)<=registre(i-1);
Size N
end loop;
clk end process;
end behav;
Registre en VHDL

• Exemple2 de registre SISO Entity SHIFTER_SISO is


Generic (
 Data_out(t)=data_in(t-N) nb_stage : integer := 32
 Ligne à retard numérique );
port (
data_in, clk : in std_logic;
data_out : out std_logic );
data_in SISO data_in end SHIFTER_SISO;
1 1
Size N
Architecture behav2 of SHIFTER_SISO is
clk signal registre : std_logic_vector (nb_stage-1 downto 0);
Begin

• Le décalage est réalisé au moyen de Process


l’opérateur de concaténation Begin
wait until clk=‘1’;
registre <= registre((nb_stage-1) downto 1) & data_in;
data_out <= registre(nb_stage-1);
À l’instant t 1 0 1 0 0 1 0 1 end process;
end behav;

À l’instant t+1

Data_in 1 0 1 0 0 1 0
Registre en VHDL

Entity SHIFTER_PISO is
• Exemple de registre PISO Generic (
nb_stage : integer := 32
 Conversion // série );
port (
 Sérialisation des données load, clk : in std_logic;
data_in : in std_logic_vector( nb_stage-1 downto 0);
data_out : out std_logic );
end SHIFTER_PISO;

Architecture behav of SHIFTER_PISO is


• La commande load permet de signal registre : std_logic_vector (nb_stage-1 downto 0);
Begin
charger le registre
Process
Begin
wait until clk=‘1’;
If (load=‘1’) then registre <= data_in;
data_out <= registre(nb_stage-1);
data_in data_in For i in nb_stage-1 downto 0 loop
N PISO 1
registre(i)<=registre(i-1);
load
1 Size N end loop;
end process;
clk end behav;
Registre en VHDL

• Exemple de registre SIPO Entity SHIFTER_SIPO is


Generic (

 Conversion série // );
nb_stage : integer := 32

 Parallelisation des données port (


data_in, clk : in std_logic;
data_out : out std_logic_vector (nb_stage-1 downto 0);
end SHIFTER_SIPO;

Architecture behav of SHIFTER_SIPO is


signal registre : std_logic_vector (nb_stage-1 downto 0);
Begin

Process
data_in SIPO data_in Begin
1 N
wait until clk=‘1’;
Size N registre(0) <= data_in;
clk data_out <= registre;
For i in nb_stage-1 downto 0 loop
registre(i)<=registre(i-1);
end loop;
end process;
end behav;
Registre en VHDL

• Exemple de registre PIPO Entity SHIFTER_PIPO is


Generic (

 Data_out(t)=data_in(t-1) );
nb_stage : integer := 32

 Buffer (tampon) port (


clk : in std_logic;
 Utiliser pour le pipeline data_in : in std_logic_vector (nb_stage-1 downto 0);
data_out : out std_logic_vector (nb_stage-1 downto 0)
);
end SHIFTER_PIPO;
• Le paramètre générique
Architecture behav of SHIFTER_PIPO is
permet de définir la taille du Process
registre Begin
wait until clk=‘1’;

data_out <data_in;

data_in PIPO data_in end process;


N N
end behav;
Size N
clk
Exemples d’utilisation
des registres
Registre mémoire

• Utilisée dans les ordinateurs


• Le registre comporte :
 une entrée x sur n bits
 une entrée de contrôle du chargement : LD
 une entrée d’initialisation (a)synchrone : CLR
 une sortie z sur n bits
x
n

LD
Registre mémoire
CLR
n
clk
z
Registre mémoire

• Implémentation d’un registre n bits

xn-1 xn-2 x0

10 10 10
LD
CLK
CLR
D D D
Q Q Q

zn-1 zn-2 z0
Registre mémoire en VHDL

Entity Reg_MEM is
• Exemple de registre mémoire Generic (
nb_stage : integer := 32
 Conversion de la donnée en sortie );
port (
tant que l’entrée load n’est pas load, clk : in std_logic;
active data_in : in std_logic_vector( nb_stage-1 downto 0);
data_out : out std_logic_vector( nb_stage-1 downto 0) );
end Reg_MEM;

• La commande clear efface le Architecture behav of Reg_MEM is


signal registre : std_logic_vector (nb_stage-1 downto 0);
contenu du registre Begin

data_out <= registre;

• La commande load permet de Process


Begin
charger le registre wait until clk=‘1’;
If (load=‘1’) then
registre <= data_in
elsif (clear=‘1’) then
data_in data_in registre <= (others=>’0’);
N MEM N else
load registre <= registre;
1 Size N end if;
clear end process;
1 end behav;
clk
Registre de synchronisation

• Problème

Flux de données

registre
arrivant sur a et b,
a
cadencé à Tclk Sortie

registre
a1, b1 ABS LOG
a2, b2 registre
indéterminée
a3, b3 b
…. clk
Tpcomb>Tclk

• Solutions
1. Augmenter la période de Tclk
2. Traitement parallèle
3. Pipeline
Registre de synchronisation

registre
• Traitement parallèle a

registre
ABS LOG
 Soit 2.Tclk<Tpcomb<3.Tclk

registre
b
 Le résultat en sortie sera exact clk

après 3 périodes d’horloges

registre
a
 Duplication du matériel 3 fois

registre
ABS LOG

registre
b

clk

registre
a

registre
ABS LOG

registre
b

clk
Tpcomb<3.Tclk
Registre de synchronisation

• Pipeline

registre
 Soit Tp+ et Tpabs et Tplog, tous < à a

registre

registre

registre
Tclk ABS LOG

registre
b
 Le résultat en sortie sera clk
disponible après 3 périodes
Tp+ < Tclk Tpabs < Tclk Tplog < Tclk
d’horloges

 Insertion de registre de
synchronisation entre chaque
étape de calcul

 Au bout de 3 clk (Taille du Pipe)


les données traitées sont
délivrées.

 Les données traitées ont un débit


(Troughouput) à Tclk
Les compteurs

0, 1, 2, 3, …
Introduction

• Les compteurs sont des éléments • Un compteur est caractérisé par


essentiels de logique séquentielle  Le code généré
 Binaire, BCD, Gray, circulaire, etc.

• Les compteurs permettent  Son architecture


 Asynchrone
d’établir une relation d’ordre  Synchrone
dans le séquencement
d’évènements.  Sa réversibilité
 Comptage
 Décomptage
• L’élément de base d’un compteur
est comme les registres, la  Sa programmation
 Initialisation dans un état particulier
bascule  Séquencement particulier

 Le nombre d’étages
 Nombre de Bascule
Compteur Asynchrone

• Les bascules possèdent toutes • Front montant


des horloges différentes J Q
1
D Q
CLK
• Généralement, la sortie d’une clk Q 1 K Q

bascule sert d’horloge à la


suivante 1 T Q

clk Q

• Principe : • Front descendant


 mettre en cascade des
diviseurs de fréquence par 2 1 J Q
D Q
 exemple de réalisation de CLK
clk Q 1 K Q
diviseurs de fréquence/2

1 T Q

clk Q
Compteur binaire asynchrone

• Exemple de compteur-décompteur modulo 8


1
Q0 Q1 Q2
T Q T Q T Q compteur

clk Q Q Q décompteur

Q0
compteur
Q1
Q2
0 1 2 3 4 5 6 7
Q0
Q1 décompteur
Q2
7 6 5 4 3 2 1 0
Compteur binaire asynchrone en
VHDL
Entity compteur_asynchrone is Entity BasculeT is
port (
port ( clk, T : in std_logic;
clk : in std_logic; Q : out std_logic );
Q : out std_logic_vector (3 downto 0) end BasculeT;
);
end compteur_asynchrone; Architecture sequentiel of BasculeT is
signal Q1 : std_logic;
Architecture behav of compteur_asynchrone is Begin
Signal temp : std_logic_vector (3 downto 0); Q<= Q1;

component BasculeT is Process


port ( Wait until clk’event and clk=‘1’;
clk, T : in std_logic; Begin
Q : out std_logic if (T=‘1’) then
); Q1 <= not Q1;
end component; else
Q1 <= Q1;
Q<= temp;
end if;
TFF1 : BasculeT port map (clk,’1’,temp(0));
end process;
TFF2 : BasculeT port map (temp(0),’1’,temp(1));
end sequentiel;
TFF3 : BasculeT port map (temp(1),’1’,temp(2));
TFF4 : BasculeT port map (temp(2),’1’,temp(3));
end behav;
Compteur binaire asynchrone

• Asynchrone : pas la même clk pour toutes les bascules


• Inconvénients
 accumulation des temps de propagation
 N-1 états transitoires si N bascules

Tmin>N.tpFF
clk
1 1 0 0 0
tpFF
Q0
1 1 1 0 0
Q1 tpFF
1 1 1 1 0
Q2 tpFF
7 7 6 4 0
Compteur binaire asynchrone
Modulo p
• Méthode de synthèse d’un diviseur de fréquence dont le code est
binaire pur et dont la mesure p n’est pas une puissance de 2
 nombre de bascule m tel que : 2m-1 < p < 2m
 assemblage des bascules comme montrés précédemment
 les p états se succèdent dans l ’ordre 0,1,…,p-1. Le 1er état indésirable
p est détecté par une fonction combinatoire Zp
 la fonction combinatoire Zp est appliqué à toutes les entrées CLR des
bascules. Le diviseur passe à l’état initial

• Il y a 2m-p états inutiles


Compteur binaire synchrone

• Toutes les bascules possèdent la même horloge


 Pas d’état transitoire indésirable en sortie

• Les entrées de chaque bascule sont pré -conditionnées en fonction


des états présents du compteur et de sont état futur
 Exemple
 Soit la séquence du compteur binaire
• Q1Q2 : 0-3-1-2
• Etat présent du compteur 3
• Etat futur du compteur 1
• Quelles doivent être les valeurs des prochaines entrées ?
 D1 = 1 et D2 =0

• Plusieurs méthodes de synthèse existent dont :


 Méthode de Marcus
 Fonction de Commutation
Méthode de Marcus

• Exemple
N Q1 Q2 D1 D2
 On veut réaliser le compteur
binaire synchrone dont la 0 0 0 1 1
séquence de sortie suit l’ordre 3 1 1 1 0
suivant : 1 1 0 0 1
 0-3-1-2
2 0 1 0 0

• Synthèse
 Table de vérité à
entrées=f°(sortie)
 Synthèse de karnaugh
 D1= Q1 XNOR Q2
 D2= Q2
D1 Q1 D2 Q2
 Logigramme : circuits
 Ou programmation VHDL CLK Q2
Compteur binaire synchrone en
VHDL
• Utilisation de l’opérateur Library ieee;
Use ieee.std_logic_1164.all;
d’addition + Use ieee.std_logic_unsigned.all;

Entity compteur_synchrone is

• Librairie unsigned port (


clk : in std_logic;
supplémentaire Q : out std_logic_vector (3 downto 0)
);
 Définition du Type end compteur_synchrone;

Architecture behav of compteur_asynchrone is


Signal temp : std_logic_vector (3 downto 0);

Q<= temp;
Process (clk)
Begin
if (clk’event and clk=‘1’) then
temp <= temp +1;
end if;
End process;
end behav;
Conclusion

• Logique séquentielle / logique combinatoire, décrit des circuits dont


les sorties dépendent des entrées et des valeurs antérieures

• L’élément de base est la bascule

• A partir de bascule, on peut réaliser des :


 Registres
 Compteurs

• La logique séquentielle va plus loin


 Notion de machine à états finis ou automates
 Machine de Moore, de Mealy, One Hot Encoding, etc…

Vous aimerez peut-être aussi