chap4_logique_séquentielle_2007

IUT Vélizy - GTR / Emmanuelle Peuch

I.U.T. de VELIZY

UNIVERSITE DE VERSAILLES-SAINT-QUENTIN-EN-YVELINES

RESEAUX ET

TELECOMUNICATIONS

Cours d’informatique : module I2

Logique séquentielle

Emmanuelle Peuch

Chapitre 4 : Logique séquentielle


INTRODUCTION

Nous avons étudié jusqu’à maintenant des circuits logiques combinatoires : les sorties, à un instant donné, ne dépendent que des valeurs présentent sur les entrées. Toute condition antérieure n’a aucun effet sur les valeurs actuelles des sorties, parce que les circuits combinatoires n’ont pas de mémoire. Ainsi, à chaque état des variables d’entrée correspond un seul état des variables de sortie et inversement. Avec les circuits séquentiels, il n’en est plus de même : l’état présent de la sortie dépend non seulement de la combinaison appliquée à l’entrée mais aussi de son état antérieur. Ces circuits ont donc un effet mémoire (ils se souviennent de leur état précédent). Ainsi, à un état des variables d’entrée peut correspondre plusieurs états différents. Nous présenterons dans un premier temps les opérateurs séquentiels de base, les bascules, ainsi que leur description VHDL. Ensuite nous décrirons quelques fonctions séquentielles synchrones courantes telles les compteurs, les registres à décalage. Pour terminer, nous étudierons une méthode de synthèse d’un système séquentiel synchrone et son implantation dans un FPGA.



Table des matières

I. Les bascules asynchrones _______________________ 1

1 Introduction _____________________________________ __________ 1

2 Latch D ou verrou ________________________________ __________ 1

3 Synchronisation des systèmes séquentiels _________ ____________ 2

II. Les bascules synchrones ___________________________ 3

1 Les bascules D___________________________________ __________ 4

2 Bascule JK _______________________________________ _________ 9

3 Exigences de synchronisation _____________________ __________ 12

3.1 Temps de pré-positionnement ____________________ _ 12

3.2 Temps de maintien ______________________________ 13

3.3 Fréquence maximale de fonctionnement ___________ _ 15

3.4 Synchronisation des entrées asynchrones d’un sy stème synchrone_________________________________________ 1 6

III. Les compteurs binaires / diviseurs de fréquence synchrones ________________________________________ 19

1 Généralités et définitions _______________________ ____________ 19

2 Réalisation VHDL d’un compteur synchrone _________ __________ 20

3 Réalisation matérielle d’un compteur synchrone___ _____________ 24



IV. Les registres et registres à décalage ______________ 26

1 Définition d’un registre (entrées parallèles et s orties parallèles) ___ 26

2 Les registres à décalage _________________________ ___________ 27

2.1 Applications des registres à décalage : ________ _____ 29

2.2 Description VHDL _______________________________ 30

ANNEXES _________________________________________ 31



1

Opérateurs séquentiels - fonctions séquentielles

L’élément de mémorisation de base est la bascule. Elle est constituée de une

ou plusieurs entrées et de deux sorties complémentaires Q et Q.

I. Les bascules asynchrones

1 Introduction Les deux principaux types de bascules asynchrones sont le latch D et la bascule R-S. La transition d’un état à un autre est provoquée par des changements de niveaux d’une ou plusieurs entrées.

2 Latch D ou verrou Cette bascule constitue la version la plus simple de la mémoire élémentaire. �� Son principe est le suivant :

- Une entrée D de données - Une entrée L de commande - Deux sorties Q et son complément.

L D Qn 0 X Qn-1 1 0 0 1 1 1



2

� Si L est au niveau haut alors la sortie Q recopie l’entrée D.

� Si L est au niveau bas alors la sortie conserve sa valeur quelle que soit l’entrée D : c’est le mode mémoire.

(Les niveaux actifs de l’entrée de commande L peuvent être inversés).

�� Exemple de réalisation :

&0

0

0

&0

0

0

>=10

0

0

1

LD

Q

�� Description VHDL :

VHDL ne connaît pas la fonction mémoire comme élément primitif. -- D Latch -- GATE: in STD_LOGIC; entrée de commande active à l’état haut -- DIN: in STD_LOGIC; entrée de données -- DOUT: out STD_LOGIC; process (GATE, DIN) begin if GATE='1' then DOUT <= DIN; end if; end process;

3 Synchronisation des systèmes séquentiels

�� Quelques définitions :

Dans les systèmes asynchrones, la sortie des circuits logiques peut changer d’état à tout moment quand une ou plusieurs entrées changent. Un système asynchrone est difficile à concevoir et à dépanner.

Par contre, dans un système synchrone, le moment exact où la sortie change d’état est commandé par un signal que l’on appelle signal d’horloge.



3

Ainsi, dans une bascule synchrone, le changement d’état de la sortie qui correspond à une nouvelle combinaison d’état des entrées ne peut

s’effectuer que sur le front actif, montant ou descendant, d’un signal de synchronisation ou signal d’horloge.

La majorité des systèmes numériques existants sont surtout des machines synchrones (même si certaines parties sont asynchrones), du fait que les circuits synchrones sont simples à concevoir et à dépanner. Leur dépannage est plus facile parce que leur sorties ne peuvent changer qu’à des instants précis bien connus.

La solution couramment adoptée est de construire les systèmes séquentiels avec des bascules synchrones qui disposent d’une entrée qui fixe les instants des éventuels

changements d’état : l’horloge.

II. Les bascules synchrones Il existe plusieurs types de bascules synchrones. Les points communs à ces bascules sont : 1- Une entrée d’horloge CLK

CLK

Actif sur frontmontant

CLK

Actif sur frontdescendant

2- Au moins une entrée de commande. Ces entrées sont désignées

par différentes lettres, selon leur fonction. Ce sont ces entrées qui déterminent l’état de sortie de la bascule, mais cet état n’apparaît en sortie de la bascule qu’au moment de la transition active de



4

l’horloge. L’effet de ces entrées est donc synchronisé avec l’application du signal d’horloge : ce sont des entrées dites synchrones.

3- Deux sorties complémentaires Q et Q.

1 Les bascules D

�� Symbole

�� Table de vérité

Horloge D Q

↑ 0 0

↑ 1 1

�� Formes d’ondes

�� Remarque La majeure partie des bascules synchrones possède, en plus, des entrées asynchrones qui agissent indépendamment du signal d’horloge et des entrées synchrones. Ce sont des entrées qui permettent, à n’importe quel

Cette bascule possède une entrée de commande D (Data) synchrone . Fonctionnement : sur le front actif de l’horloge (ici sur le front montant), la sortie Q recopie l’entrée D.



5

moment, de forcer à 1 ou à 0 la sortie Q de la bascule quelles que soient les conditions des entrées (initialisation du circuit). Dans l’exemple de la bascule D on voit qu’il y a deux entrées asynchrones CLR (Clear = initialisation à 0) et SET (initialisation à 1).

Doc.technique

Symbole logique :

Ces bascules sont dotées de deux entrées supplémentaires CLR (Clear) et PRE (Preset). Ces deux entrées sont indépendantes de l’horloge (elles agissent quelque soit le niveau ou front de l’horloge). Elles sont dites entrées asynchrones. Ici, elles sont actives à l’état bas.

Extrait de la documentation du constructeur du circuit intégré 74HC74



6

�� Diagramme d’état :

Voir annexe de ce polycopié (diagramme d’état) p.33

�� Description VHDL d’une bascule D :

entity bascule_D is Port ( CLK : in std_logic; D : in std_logic; Q : out std_logic); end bascule_D; architecture version_1 of bascule_D is begin process (CLK) -- le process n’est activé que si un front d’horloge se

-- présente (voir table de vérité : Q recopie D que si un -- front actif d’horloge se présente !)

begin if CLK'event and CLK='1' then --actif sur front montant Q <= D; -- Q recopie alors D end if; end process;

end version_1;

Schéma correspondant après synthèse :

Etat 0 : la sortie est à 0. Le système passera dans l’état 1 si il y a un front actif d’horloge qui se présente (implicite mais il ne faut pas l’oublier) et si l’entrée D est à 1. La sortie se positionnera alors à 1. …..



7

�� Description VHDL avec entrées Reset et Set asynchrones : L’entrée de mise à zéro RESET est prioritaire sur l’entrée de mise à un SET

entity bascule_d1 is Port ( D : in std_logic; CLK : in std_logic; SET : in std_logic; RESET : in std_logic; Q : out std_logic); end bascule_d1; architecture version_2 of bascule_d1 is begin process (CLK, RESET, SET) begin if RESET = '1' then -- entrée la plus prioritaire ! Q <= '0'; elsif SET = '1' then Q <= '1'; elsif CLK'event and CLK='1' then -- actif sur front montant Q <= D; end if; end process; end version_2;

Schéma correspondant après synthèse :



8

�� Description VHDL de la bascule vue comme une machine d’état :

On traduit directement le diagramme d’état en langage VHDL. On doit donc définir un type : voir syntaxe p 15 Nous utiliserons aussi l’instruction séquentielle CASE, voir p. 27

entity bascule_D is Port ( D : in std_logic; CLK : in std_logic; RESET : in std_logic; Q : out std_logic); end bascule_D; architecture version_3 of bascule_D is type bulle is (etat0, etat1); -- définition de l’ensemble des états signal etat : bulle ; begin -- Evolution de la machine d’états: description du diagramme d’états process (CLK, RESET) begin if RESET = '1' then -- remise à zéro asynchrone, actif état haut

etat <= etat0; -- on choisit de mettre la sortie Q à 0 lors d’ l’initialisation. La -- machine est donc dans l’état 0.

elsif ( clk’event and clk = ‘1’) then case etat is when etat0 => if D = ‘1’ then

etat <= etat1 else -- cas où D = 0 etat <= etat0

end if ; when etat1 => if D = ‘1’ then

etat <= etat1 else -- cas où D = 0 etat <= etat0

end if ; end case ; end if;

end process; -- Cablâge des sorties

Q <= ‘1’ when etat = etat1 else

‘0’ ; End version_3 ;



9

2 Bascule JK

�� Symbole

�� Table de vérité

Horloge J K Qn+1 ↑ 0 0 Qn Mémorisation (on garde le niveau de la sortie Q qui

était présent avant le passage du front actif) ↑ 0 1 0 mise à zéro ↑ 1 0 1 Mise à 1

↑ 1 1 Qn Commutation (passage à l’état opposé)

�� Formes d’ondes

Les entrées J et K sont les entrées synchrones .



10

Doc.technique

Ces bascules sont dotées de deux entrées asynchrones CLR (Clear) et PR (Preset).

�� Diagramme d’état :

�� Description VHDL :

Dans le diagramme d’état (ou la table de vérité), on voit que la sortie Q à l’instant n peut être égale à la sortie Q à l’instant n-1 (mémorisation) ou à son complément (commutation). Or le signal Q, est déclaré comme une sortie au niveau de l’entité (OUT) et ne peut donc pas être utilisé comme une entrée ! Pour contourner cette difficulté on va utiliser un signal interne qui, lui, peut être à la fois une entrée et une sortie (Q_inter dans notre exemple). Avec cette façon d’écrire, les signaux de sortie ne sont jamais utilisés comme des entrées. Cela permet une plus grande portabilité du code.

Extrait de la documentation constructeur du circuit intégré 74HC73



11

entity bascule_JK is Port ( CLK : in std_logic; J : in std_logic; K : in std_logic; Q : out std_logic); end bascule_JK;

architecture V1 of bascule_JK is --déclaration du signal intermédiaire signal Q_inter: std_logic; begin process(clk) begin if CLK'event and CLK='1' then --actif sur front montant

if J='0' and K='0' then Q_inter <= Q_inter;

elsif J='0' and K='1' then Q_inter <= '0';

elsif J='1' and K='0' then Q_inter <= '1';

else Q_inter <= not Q_inter;

end if; end if; end process; Q <= Q_inter; end V1;

�� Description VHDL de la bascule vue comme une machine d’état :

Exercice

Ecrire la description VHDL de la bascule JK vue comme une machine d’états.



12

3 Exigences de synchronisation Pour que le fonctionnement d’une bascule synchrone soit efficace, deux conditions sont nécessaires : l’une concerne la durée de stabilisation (temps de pré positionnement) et l’autre la durée de maintien. Les temps de pré positionnement (set up time, tsu) et de maintien (hold time, tH) concernent les positions temporelles relatives de deux entrées d’un même circuit : par exemple la position de l’entrée D et de l’horloge d’une bascule D synchrone qui réagit aux fronts montants de son horloge.

Pour que la bascule interprète correctement la valeur de l’entrée, quelle que soit cette valeur, celle-ci doit être stable avant la transition active d’horloge et maintenue stable

après cette transition.

3.1 Temps de pré-positionnement

Sur cet exemple : la sortie Q recopiera effectivement la donnée D = 1 au moment du front actif d’horloge uniquement si cette donnée D = 1 était présente depuis une certaine durée tsu avant le front actif d’horloge. Le constructeur fournit la durée de pré positionnement minimale admissible.



13

tsu = intervalle de temps qui précède immédiatement le front actif du signal d’horloge pendant lequel l’entrée synchrone doit être gardée au niveau approprié.

Si on ne respecte pas ce temps, il n’est pas garanti que la bascule réponde correctement à l’arrivée du front.

Pour la série CMOS-HC, le temps de pré positionnement minimal est de 14 à 20 ns pour une tension d’alimentation de 5V.

3.2 Temps de maintien

Si le retour de l’entrée de commande à l’état 0 (ici, entrée D) intervient trop tôt après le front actif du signal d’horloge, la variable de sortie peut reprendre la valeur 0.

Pour éviter ce mauvais fonctionnement, l’état 1 de l’entrée D doit être maintenue suffisamment longtemps (durée tH). Le constructeur fournit un temps de maintien minimal.

Pour la série CMOS-HC, le temps de maintient minimal est de 0 à 5 ns pour une tension d’alimentation de 5V.

L’intérêt d’avoir un temps de maintien nul apparaît dès que les entrées d’un circuit synchrone sont les sorties d’un autre circuit synchrone.

Ainsi, la valeur à prendre en compte au moment de la transition active de l’horloge est alors, sans ambiguïté, celle qui précède cette

transition.



14

� Pour illustrer ceci, étudions le montage suivant :

La bascule D, câblée de cette façon, réalise la fonction « diviseur de fréquence par 2 ». C’est un montage qui change d’état à chaque transition active. Si la bascule possède un temps de maintien nul, le montage fonctionne correctement pourvu que le temps de pré positionnement tsu soit supérieur à celui fournit par le constructeur.

Ainsi, le temps de maintien doit être nul ou, au pire, inférieur au

plus petit des temps de propagation.

� Autre exemple : dans nombre de circuits numériques, la sortie d’une bascule est couplée directement, ou par l’intermédiaire de portes logiques, à l’entrée d’une autre bascule, et ces bascules sont commandées par le même signal d’horloge.

Examinons le circuit ci-dessous :

J

Q

Q

K

SET

CLR

1

1

1

1

J

Q

Q

K

SET

CLR

2 2

2 2

Vcc

Vcc

Sortie

H

On rappelle la table de vérité de la bascule JK :

Horloge J K Qn+1

↓ 0 0 Qn Mémorisation

↓ 0 1 0 Reset

↓ 1 0 1 Set ↓ 1 1 Qn Commutation



15

Formes d’ondes :

3.3 Fréquence maximale de fonctionnement

Reprenons le circuit « diviseur par deux », mais en tenant compte cette fois ci des temps de propagation dans les bascules. On doit prendre en compte les défauts afin d’évaluer les limites de fonctionnement d’un montage.

Pour que le montage fonctionne correctement les paramètres des circuits doivent vérifier :

tH < min(tpHL, tpLH)

Relation indépendante de la fréquence de l’horloge. Cette relation est toujours vérifiée pour des circuits dont le temps de maintien est nul, d’où

l’intérêt de ces circuits.



16

tsu < TCK - max(tpLH, tpHL)

soit F1

t max(t , t )CK

su pHL pLH<

+

Remarques : un dysfonctionnement par violation de pré positionnement

(tsu) se corrige en réduisant la fréquence de l’horloge ou en choisissant une technologie plus rapide. Un dysfonctionnement par violation de temps de maintien (tH), par contre, est indépendant de la fréquence d’horloge et nécessite, en général, une refonte complète du système.

3.4 Synchronisation des entrées asynchrones d’un système synchrone

Pour qu’un système qui évolue à chaque transition d’horloge comme ceux étudiés précédemment fonctionne correctement, il faut s’assurer que les conditions sur les temps de maintien et la fréquence d’horloge sont respectées. Il faut également s’assurer que les entrées extérieures soient correctement positionnées par rapport à l’horloge. Cela peut être assuré en synchronisant, au moyen d’une bascule D, toute entrée asynchrone par rapport à l’horloge locale. Soit le système ci-dessous :

Il est impossible d’assurer que les règles précédentes sont respectées si les changements des entrées (p entrées) sont asynchrones de l’horloge. On risque alors de voir apparaître des transitions fausses. Pour éviter ce type de désagrément, la méthode consiste à systématiquement synchroniser les entrées asynchrones au moyen de bascules D (on réalise alors un registre de synchronisation) :



17

Les durées de tous les chemins sont définies, ce qui permet de contrôler le respect des temps de maintien et de pré positionnement.

Exemple

Un signal A est généré par un interrupteur antirebond qu’actionne un opérateur :

A passe au niveau haut lorsque l’interrupteur est ouvert et au niveau bas lorsque l’interrupteur est fermé.

Ce signal sert donc à commander le transfert du signal d’horloge sur la sortie X lorsque l’interrupteur est ouvert (A=1). Cette horloge est destinée à commander un système synchrone (un compteur par exemple).

Problème : comme A peut changer d’état à tout moment, on peut se

retrouver avec, sur la sortie X, des parties d’impulsion d’horloge. Ceci se produit lorsque A change d’état pendant que H est au niveau haut (voir tracé ci-dessus).

Solution : utilisation d’une bascule D pour synchroniser l’entrée A avec les fronts descendants de l’horloge H.

Les signaux asynchrones sont souvent lancés par un opérateur qui ouvre ou ferme un interrupteur à un moment quelconque par rapport au signal d’horloge . Ce manque de synchronisme peut parfois produire des résultats imprévisibles et indésirables.



18



19

III. Les compteurs binaires / diviseurs de fréquence synchrones

1 Généralités et définitions

Un compteur binaire est appelé compteur modulo N s’il compte de 0 à N - 1. La Nième impulsion d’horloge le remet obligatoirement à zéro. Nous verrons qu’un compteur modulo N = 2n comporte n bascules (on dit aussi compteur

n bits) et 2n états.

Exemple

Exemple : compteur de 0 à 3

Pour compter de 0 à 3 en binaire il faut deux bits que nous appellerons S0 (poids faible) et S1 (poids fort). Notre compteur est donc un système qui va nous fournir la séquence suivante :

00 � 01 � 10 � 11 � 00 � 01 � 10 � …..

Comme notre compteur est un système synchrone, il passera de 00 à 01 lorsqu’un front actif d’horloge se présentera et ainsi de suite…..

Comme tout système synchrone, il doit comporter une entrée d’initialisation asynchrone (ou prioritaire). Ici, nous choisirons de l’initialiser à zéro et cette entrée (RAZ) sera active à l’état haut.

Nous pouvons donc maintenant tracer le schéma de la vue externe de notre système ainsi que son diagramme d’état :

compteur_0_à_32

S

S1 S0

Clk

RAZ

Actif front montant

Actif état haut

Vue externe

Etat 0/00

Sortie = S1S0

RAZ

Etat 1/01

Etat 2/10

Etat 3/11



20

Nous allons également tracer les chronogrammes correspondant à notre système :

CLK

t

S1

RAZ

Initialisation à zéro du compteur

0

0

1

0

0

1

1

1 0

0S0

Remarque : Soit Fclk la fréquence du signal d’horloge :

La sortie S0 a une fréquence Fclk/2 : on a réalisé un diviseur de fréquence par deux. La sortie S1 a une fréquence Fclk/4 : on a réalisé un diviseur de fréquence par quatre.

Généralité : pour un compteur de 0 à 2n -1 (n sorties de S0 à Sn-1), sur la sortie poids faible S0 la fréquence de l’horloge est divisée par 2. Sur la sortie S1 la fréquence est divisée par 2

2 = 4. Sur la sortie S2 la fréquence est divisée par 23 = 8, …. Sur la sortie Sn-1 la fréquence est divisée par 2

n. On peut donc utiliser ces compteurs comme diviseur de fréquence. Ex : Si on souhaite faire un diviseur de fréquence par 8 = 23 , il faudra donc

réaliser un compteur de 0 à 7 (n = 3 sorties) et on n’utilisera alors que la sortie de poids fort S2.

2 Réalisation VHDL d’un compteur synchrone



21

L’opérateur arithmétique + est étendu à des objets de types bit_vector et std_logic_vector. On dit qu’il y a surcharge de l’opérateur +. Pour réaliser

nos compteurs, on va donc utiliser cet opérateur.

Exemple

Reprenons notre compteur de 0 à 3.

compteur_0_à_32

S

S1 S0

Clk

RAZ

Actif front montant

Actif état haut

Vue externe

Etat 0/00

Sortie = S1S0

RAZ

Etat 1/01

Etat 2/10

Etat 3/11

A chaque front actif d’horloge il faut donc incrémenter la sortie S de 1 soit l’instruction S <= S + 1 ; Or le signal S est déclaré comme un port de sortie dans l’entité (out) et ne peut donc pas être utilisé comme une entrée ! Pour contourner cette difficulté on va donc utiliser un signal interne qui, lui, peut être à la fois une entrée et une sortie (S_inter dans notre exemple). Avec cette façon d’écrire, les signaux de sortie ne sont jamais utilisés comme des entrées. Cela permet une plus grande portabilité du code.

-- Compteur binaire de 0 à 3 entity compteur_0_3 is Port ( clk : in std_logic; RAZ : in std_logic; S : out std_logic_vector(1 downto 0)); end compteur_0_3; architecture version1 of compteur_0_3 is signal S_inter: std_logic_vector(1 downto 0);



22

begin process (clk, RAZ) begin if RAZ = '1' then S_inter <= "00"; elsif (clk'event and clk = '1') then s_inter <= s_inter + 1; end if; end process; S <= S_inter; end version1;

Exemple

On souhaite maintenant réaliser un compteur de 0 à 9. Notre compteur aura une remise à zéro : l’entrée sera active à l’état bas.

En binaire il faut 4 bits pour coder 9. Notre système aura donc 4 sorties. Avec 4 sorties le compteur peut donc compter de 0 à 15 ! Il faut donc prévoir un retour dans l’état 0000 après l’état 1001 ! � Vue externe

compteur_0_à_94

S

S3 S2

Clk

Reset

Actif front montant

Actif état bas

Vue externe

S1 S0

� Diagramme d’état



23

Etat 0/0000

Sortie = S3S2S1S0

RAZ Etat 1/0001 Etat 2/

0010

Etat 3/0011

Etat 4/0100...

Etat 9/1001

� Description VHDL

-- compteur de 0 à 9 entity compteur_0_9 is Port ( CLK : in std_logic; reset : in std_logic; S : out std_logic_vector(3 downto 0)); end compteur_0_9; architecture version1 of compteur_modulo10 is signal S_inter: std_logic_vector(3 downto 0); begin process (CLK, Reset) begin If reset = '1' then -- entrée asynchrone S_inter <= "0000"; elsif (CLK'EVENT and CLK = '1') then if S_inter = "1001" then S_inter <= "0000"; else S_inter <= S_inter + 1; end if; end if; end process; S <= S_inter;



24

end version1;

3 Réalisation matérielle d’un compteur synchrone

Pour synthétiser un compteur synchrone, on utilise les tables de transition des bascules. La table de transition permet de connaître, pour chaque type de bascule, les valeurs à afficher sur les entrées pour obtenir une transition particulière Qn -> Qn+1. �� Table de transition d’une bascule D Transition désirée

Commande à appliquer

Qn -> Qn+1 D

0 -> 0 0 0 -> 1 1 1 -> 0 0 1 -> 1 1

�� Table de transition d’une bascule JK Transition désirée

Commande à appliquer

Qn -> Qn+1 J K

0 -> 0 0 X 0 -> 1 1 X 1 -> 0 X 1 1 -> 1 X 0

Ce qui correspond au diagramme d’état de la bascule D :

Etat 0/Q=0

Etat 1/Q=1

D=1

D=1

D=0

D=0

Ce qui correspond au diagramme d’état de la bascule JK :

Etat 0/Q=0

Etat 1/Q=1

1X

X0

X1

0X

JK



25

� Ces tables vont nous être utiles pour la détermination des circuits combinatoires de commande des bascules afin de réaliser un compteur synchrone:

Les blocs F0,… Fn-1, représentent les fonctions combinatoires à synthétiser afin de commander les bascules.

�� Compteur synchrone 2 bits (compteur modulo 4) :

On doit obtenir la séquence suivante : 00 - 01 - 10 - 11. Il y a quatre états : on utilise donc deux bascules JK comme élément de mémorisation.

Ecrivons la table de transition de notre compteur :

Etat du compteur

Q1 Q0 (état

présent)

Q1+ Q0+

(état futur)

J1 K1 J0 K0

0 0 0 0 1 0 X 1 X 1 0 1 1 0 1 X X 1 2 1 0 1 1 X 0 1 X 3 1 1 0 0 X 1 X 1

On utilise maintenant les méthodes classiques de synthèse des systèmes combinatoires (table de Karnaugh) afin de déterminer les commandes Ji et Ki de chaque bascule. Pour cela on va synthétiser les entrées JK à partir de l’état présent des bascules. On va utiliser les valeurs logiques indifférentes X (si cela est possible) afin de simplifier les équations logiques.

En fixant les états X on trouve par exemple : J1 = Q0

Si on n’utilise pas ses états indifférents, on obtient : J1 = .Q0Q1 De même, K1 = Q0 ou alors K1 = Q1.Q0 On choisit J0 = K0 = 1



26

Traçons les chronogrammes (on suppose que le compteur est initialisé à zéro de façon asynchrone) :

IV. Les registres et registres à décalage

C’est comme élément de mémorisation de données que les bascules sont les plus utilisées. Le stockage des données a lieu généralement dans des groupes de bascules appelés registres. Rappel : Une bascule est capable de mémoriser (ou stocker) un bit. Si on a

besoin de stocker n bits (mot de n bits), il faudra donc réaliser un registre composé de n bascules.

1 Définition d’un registre (entrées parallèles et sorties parallèles)

Un registre n bits comprend :

� un assemblage de n bascules (qui peuvent être du type D, JK). Il peut donc stocker un mot de n bits : n est sa capacité.



27

� Une entrée de signal d’horloge pour la synchronisation (commune à toutes les bascules).

Et éventuellement :

� Une commande pour le chargement, ou l’écriture, du mot à mémoriser. � Une commande pour l’activation des sorties, ou la lecture.

2 Les registres à décalage Un registre à décalage est un ensemble de bascules câblées de manière à ce que les nombres mémorisés dans les bascules soient déportés d’une bascule à la suivante à chaque impulsion d’horloge. Ci-dessous, les bascules JK sont connectées de façon à réaliser un registre à décalage de 4 bits :

Avant le premier front actif d’horloge, les bascules sont mises à zéro.

Les bascules JK sont telles que J = K . D’après la table de vérité de ces bascules, on est dans la configuration où la sortie recopie l’entrée J.



28

A l’arrivée du premier front descendant, en T1, X3 va recopier la donnée J = 1, donnée présente sur l’entrée juste avant le front actif d’horloge. Les autres bascules vont recopier J = 0, état présent sur l’entrée juste avant le front actif. On a donc X2 = X1 = X0 = 0. En t = T2, X3 = J = 0 (la donnée d’entrée est à zéro avant Le front actif). La deuxième bascule va recopier X3 qui était la donnée entrée en T1. Cette donnée a donc été transférée dans la deuxième bascule. Les sorties X1 et X0 restent à zéro.

Ainsi, à chaque front actif de l’horloge, les sorties des bascules prennent la valeur de sortie qu’avait la bascule immédiatement à gauche avant le front

actif.

En continuant ce raisonnement, on voit que le premier bit de données se retrouve en sortie du registre (sur X0) au bout de quatre périodes d’horloge (registre 4 bits). �� Remarque : temps de maintien à respecter Dans le montage d’un registre à décalage, il est nécessaire que les bascules aient un temps de maintien excessivement faible, du fait que les entrées J et K changent presque en même temps que le front actif. En réalité, le retard de propagation introduit par X3 par exemple fait en sorte que les entrées J et K resteront inchangés pendant une courte période après le front descendant. Il faut donc choisir des bascules dont le temps de maintien est plus petit que le temps de propagation d’une seule bascule. Heureusement, la majorité des bascules respectent cette exigence et, pour la plupart, ont un temps de maintien nul.

Décalage logique d’un nombre

Si on décale logiquement à gauche ou à droite de n pas, on multiplie ou on divise le nombre de 2n.

0 0 1 1

Décalageàgauche

On écrit dans le registre à décalage de 4 bits le nombre N = 3, soit N = % 0011 en binaire. On effectue un décalage à gauche. Tous les bits vont être décalés de la même façon et il apparaît des zéros à droite du registre.

Après décalage à On lit dans le registre la valeur binaire N



29

gauche :

0 1 1 0

= % 0110 soit N = 6. On a multiplié par 2 le nombre binaire initial.

2.1 Applications des registres à décalage :

� Réalisation de compteurs particuliers :

Compteur en anneau Il est constitué d’un registre à décalage à bascules D ; la sortie de la dernière bascule est reliée à l’entrée de la première.

Le registre est initialisé à la valeur 1000. A chaque impulsion d’horloge, le contenu du registre est décalé d’une position vers la droite. On obtient un code cyclique dont les états successifs sont les suivants : 1000, 0100, 0010, 0001 puis retour au premier état. On obtient n combinaisons avec un registre à décalage de n bits.

Info

Un code continu est un code dans lequel deux mots de code consécutifs sont adjacents (changement d’état d’un seul bit à la fois). Si de plus le premier mot est adjacent au dernier, le code est dit code cyclique.

Compteur de Johnson

Il est constitué d’un registre à décalage à bascules D ; la sortie Q de la

dernière bascule est reliée à l’entrée de la première. Le registre est initialisé à 0000. On obtient un code cyclique dont les états successifs sont :

0000, 1000, 1100, 1110, 1111, 0111, 0011, 0001 (et retour au début !).

On obtient 2.n combinaisons avec un registre à décalage de n bits.



30

� Générateur pseudo-aléatoire

Il est constitué d’un registre à décalage (bascules D) initialisé à une valeur différente de zéro et rebouclé sur lui-même à l’aide d’un ou de plusieurs OU exclusif. Sur une sortie quelconque du registre, on obtient une séquence binaire pseudo aléatoire de périodicité maximale de 2n - 1 (qui correspond au nombre d’états que l’on peut avoir au maximum). Cette structure sera étudiée en TD. En traitement du signal, on utilise cette structure comme brouilleurs de données ou encore comme générateur dit de bruit blanc.

2.2 Description VHDL

Il y a différentes façons de décrire un registre à décalage en VHDL. On peut utiliser :

� L’opérateur « concaténation » sreg <= sreg (6 downto 0) & SI ; -- SI = Serial Input

� Une boucle « for loop » :

for i in 0 to 6 loop sreg(i+1) <= sreg(i) ; end loop ; sreg(0) <= SI ;

Prenons l’exemple d’un registre à décalage droite Série / série :



31

library IEEE; use IEEE.STD_LOGIC_1164.ALL; use IEEE.STD_LOGIC_ARITH.ALL; use IEEE.STD_LOGIC_UNSIGNED.ALL; -- Registre à décalage série série, décalage --droite : Opérateur concaténation entity registre is Port ( s_input : in std_logic; s_output : out std_logic; horloge : in std_logic); end registre;

architecture version1 of registre is signal inter: std_logic_vector(3 downto 0); begin process (horloge) begin if horloge'event and horloge ='1' then inter <= s_input & inter(3 downto 1); end if; end process; s_output <= inter(0); end version1;

-- boucle FOR...LOOP architecture version2 of registre is signal inter: std_logic_vector(3 downto 0); begin process (horloge) begin if horloge'event and horloge ='1' then

for i in <lower_limit> to <upper_limit> loop instructions séquentielles ; end loop;



32

for I in 0 to 2 loop inter(i) <= inter(i+1); end loop; inter(3) <= s_input; end if; end process; s_output <= inter(0); end version2;

Annexes


33

Outils de description des systèmes séquentiels

Si l’outil d’analyse et de synthèse des fonctions combinatoires est la table de

vérité, le diagramme de transition constitue l’outil privilégié pour l’analyse et la synthèse des fonctions séquentielles.

Le diagramme de transition ou d’état

Pour tout système séquentiel : - A un instant donné, le système se trouve dans une situation particulière qui va dépendre des valeurs qui se sont succédées sur les entrées depuis l’instant initial. Cette situation particulière est appelée état du système : le système comprend autant d’états qu’il y a de situations particulières différentes possibles.

- Il comporte toujours un nombre fini d’états. Le premier travail consiste donc à dénombrer les différents états du système à partir du cahier des charges.

On utilise ensuite l’outil graphique « diagramme d’état ou transition » pour

représenter le fonctionnement du système (recenser tous les états possibles du système étudié).

� On associe un cercle à chaque état.

� L’évolution du système est représentée par des flèches entre chaque cercle qui traduisent les changements d’état possibles, les transitions possibles.

De chaque état doivent partir autant de flèches qu’il y a de

combinaisons binaires associées aux entrées.

Etat 0/S0=1S1=1

Etat 1/S0=0S1=1

E0=1E1=0

E0=1E1=1

Chaque flèche comporte la valeur de l’entrée E (mot de n bits si n entrées) qui provoque la transition correspondante. Les valeurs des sorties sont représentées dans les cercles du diagramme.

Annexes


34

Synthèse d’un système séquentiel synchrone : machine d’états

� Dans un système séquentiel : une même combinaison des entrées à deux

instants différents peut conduire à deux résultats différents (contrairement aux systèmes combinatoires). En effet, cela dépend aussi de l’état précédent. Ce qui implique la présence d’un bloc de mémorisation (ensemble de bascules, soit un registre).

Définition : Pour tout système séquentiel, à un instant donné, le système se trouve dans une situation particulière qui va dépendre des valeurs qui se sont succédées sur les entrées depuis l’instant initial. Cette situation particulière est appelée état du système et le système comprend autant d’états qu’il y a de situations particulières différentes possibles.

� Le premier travail consistera donc à dénombrer les différents états du système à partir du cahier des charges : on utilisera alors l’outil « diagramme d’états ».

� Tout système séquentiel synchrone peut être réalisé grâce à une structure

appelée machine de Moore (machine à états de type Moore).

Soient Ei = entrée du système à l’instant présent (ti) Si = sortie du système à l’instant présent Yi = l’état du système à l’instant présent

Dans une machine de Moore, la sortie S dépend uniquement de l’état présent Yi. Les équations du système sont donc :

Equation de la sortie : Si = f(Yi) Equation d’évolution du système : Yi+1 = g(Ei, Yi)

Cette dernière équation permet de déterminer l’état suivant Yi+1 quand on connaît l’état présent Yi et les entrées présentes Ei.

Annexes


35

G( )

Fonction

combinatoire:

calcul de l’état

futur

Registre

d’état

F( )

Système

combinatoire de

sortie

Entréesp

n

Etat futur

Yi+1

nn

Etat présent

Yi

Etat présent Yi

MACHINE DE MOORE

CLK

Le registre d’état est constitué de n bascules synchrones. Le contenu du registre d’état représente l’état de la machine (nombre codé en binaire sur n bits dans un code choisi par le concepteur).

L’entrée du registre d’état constitue l’état futur : celui qui sera chargé lors du prochain front actif d’horloge.

Il constitue la mémoire de la machine, l’élément qui matérialise l’histoire de son évolution. La description VHDL de la machine de Moore est donc effectuée en deux temps. Au cours du premier temps est décrit le cycle produit par la machine d’état : c’est la partie séquentielle (process) ; dans un deuxième temps la spécification du niveau des sorties en fonction de l’état courant est définie : c’est la partie combinatoire.

Annexes


36

BIBLIOGRAPHIE Electronique numérique et séquentielle - pratique des langages de description de haut niveau Noël Richard

DUNOD

Circuits numériques et synthèse logique - un outil : VHDL J. Weber et M. Meaudre

MASSON

Initiation au langage VHDL Michel Aumiaux

MASSON

Logique combinatoire et séquentielle : méthodes, outils et réalisations Claude Brie

ELLIPSES

Sur le Web : http://perso.wanadoo.fr/xcotton/index.htm

chap4_logique_séquentielle_2007

Documents