Vous êtes sur la page 1sur 95

Logique Séquentielle

I Logique séquentielle
Sortie
Entrée Logique
Combinatoire
En logique séquentielle, l’état de la
sortie dépend, non seulement de l’état
des entrées mais aussi de l’état
État suivant
précédent de la sortie.
Les systèmes séquentiels introduisent État
donc la notion de mémoire (pour future
stocker l’état du système) et
d’horloge (pour déterminer les Élément de mémoire
instants de mesure)

Les systèmes séquentiels apportent un aspect mémoire à la logique

on se rappelle que l'état présent est une sortie de l’élément mémoire, tandis que
l'état futur en est une entrée.
Notation des états
 Comment noter un état « Q » dans le passé, le présent ou le futur?
Passé Présent Futur
Qn , Qn-1, Qn+1 : état de Q respectivement à l'instant présent, précédent et suivant.

Qn-1 Qn Qn+1 Temps

 Pour déterminer l'état présent en sortie,il faut :


 L'état présent sur l'entrée
 L'état précédent de la sortie
Horloge : composant passant indéfiniment et régulièrement d’un niveau
haut à un niveau bas (succession de 1 et de 0), chaque transition s’appelle
un top.
La prise en compte du top se fait pendant les transitions de l’horloge.

 Deux types de logique séquentielle :


 asynchrones :La sortie change d’état « en même temps » que l’état des
entrées.
 synchrones :La sortie change d’état quand un signal de commande (horloge)
l’autorise. Cette horloge peut intervenir par :
front montant : 0→1
front descendant : 1→0

1 1 1 1 1 1 1
h 0 0 0 0 0 0 0

T
Front montant Front descendant
Eléments de Mémoire
 En logique séquentielle, les états précédents des sorties interviennent pour
l'élaboration de l'état des sorties. La fonction mémoire est le principal
constituant des systèmes séquentiels. Ainsi, un système séquentiel
complexe peut être élaboré à partir d'un ensemble organisé de mémoires
élémentaires et d'opérateurs de logique combinatoire.

Elément de Q
commande mémoire Valeur
mémorisé

Commande Qn Qn+1
Qn: Etat présent
Set X 1
Qn+1 ou Q+: Etat suivant
Reset X 0
0 0
Mémorisation 1 1

L’élément de mémoire est dit dans l’état « Set » si Q=1 et Q’=0


L’élément de mémoire est dit dans l’état « Reset » si Q=0 et Q’=1
Bascule RS asynchrone
2 portes NOR Schéma équivalent
R
Q
S Q

Q' R Q'
S

 2 entrées: S et R
 2 Sorties: Q et Q’
Elle est formé de deux portes NOR en connectant leurs sorties à
l’entrée de l’autre porte.

La bascule RS est dite dans l’état « Set » si Q=1 et Q’=0


La bascule RS est dite dans l’état « Reset » si Q=0 et Q’=1
Qn+1 = (R + Q’n)’
Q’n+1 = (S + Qn)’
Bascule RS asynchrone
__
R=0 , S=0 et Q = 0 S R Qn Qn+1 Qn+1
0 0 0
0

0
0

(Hold State)

7
Bascule RS asynchrone
__
S R Qn Qn+1 Qn+1
0 0 0 0 1
0 0
1

0 1
0

(Hold State)

8
Bascule RS asynchrone
__
R=0 , S=0 et Q = 0 S R Qn Qn+1 Qn+1
0 0 0 0 0
0 1 0 0 1

1
0
0

(Hold State)

9
Bascule RS asynchrone
__
S R Qn Qn+1 Qn+1
0 0 0 0 0
0 1 0 0 1 1 0
0

1 0
0

(Hold State)
Qn+1=Qn Etat Hold (mémorisation)
10
Bascule RS asynchrone
R=1 , S=0 __
S R Qn Qn+1 Qn+1
0 0 0 0 0
1 0 0 0 1 1 0
0 1 0 0 1
0 1 0 0 1

0
1
0

(Set State)

11
Bascule RS asynchrone
R=0 , S=1 __
S R Qn Qn+1 Qn+1
0 0 0 0 0
0 0 0 1 1 0
0 0 1 0 0 1
0 1 1 0 1
1 0 0

0 0
1

(Set State)

12
Bascule RS asynchrone
R=0 , S=1 et Q = 1 __
S R Qn Qn+1 Qn+1
0 0 0 0 0
0 1 0 0 1 1 0
0 0 1 0 0 1
0 1 1 0 1
1 0 0 1 0
1 0 1 1 0
1 0
1

(Set State)

13
Bascule RS asynchrone
R=1 , S=1 __
S R Qn Qn+1 Qn+1
0 0 0 0 0
1 0 0 0 1 1 0
0 1 0 0 1
0 1 1 0 1
1 0 0 1 0
1 0 1 1 0
0 1 1
1
1 1

(Invalid State)
14
Bascule RS asynchrone
__
S R Qn Qn+1 Qn+1
0 0 0 0 0
1 0 0 0 1 1 0
1 0 1 0 0 1
0 1 1 0 1
1 0 0 1 0
1 0 1 1 0
0 1
1

(Invalid State) Etat invalide

15
Table de vérité S R Qn+1
0 0 Mémorisation

__ 0 1 0 (reset)
S R Qn Qn+1 Qn+1 1 0 1 (set)
0 0 0 0 1
Sortie Figée  Aucune action
0 0 1 1 0
0 1 0 0 1 Mise à 0  Reset
0 1 1 0 1
1 0 0 1 0
Mise à 1  Set
1 0 1 1 0
1 1 0 0 0
État à éviter (Qn+1 = Qn+1)
1 1 1 0 0

Les sorties sont toujours complémentées, sauf pour S = R = 1


S R Qn+1
0 0 Figée
0 1 0 (reset)
1 0 1 (set) 0 Set 0 0
S 0

R 0 0 0 Reset 0
1
Q 0 0 0
1 1 1
/Q 0
Mise à 1 Figée Mise à 0
Qn+1 Équation des sorties
Bascule RS SR
Qn 00 01 11 10
0 0 0 X 1 Qn+1 = S + RQn
S R Qn+1 1 1 0 X 1
0 0 Mémorisation

0 1 0 (reset) Graphe d’état


1 0 1 (set)  Les états internes (Q) définissent les
sommets du graphe
Etat présent Etat suivant  Les états d’entrée (R et S) définissent
les flèches quittant les sommets
Qn Qn+1
SR=10
SR=00 01 10 11 1
0
0 0 0 1 X SR=01
1 1 0 1 X 00, 01 00, 10
Table d’états
Bascule S’R’
Bascule formé de deux portes NAND en connectant leurs
sorties à l’entrée de l’autre porte NAND.
S' S’ R’ Q
Q
1 1 No change
1 0 0 (reset)
Q' 0 1 1 (set)
R' 0 0 Interdit

PS NS
S’ R’ Qn Qn Qn+1 Qn+
1 PS: Etat présent Qn
0 1 X X 1 0 set NS: Etat suivent Qn+1
1 0 X X 0 1 reset
1 1 0 1 0 1 hold
1 1 1 0 1 0 hold
0 0 X X 1 1 interdit
Bascule RSH
Une amélioration de la bascule RS (verrou) consiste à ajouter un signal
interdisant ou autorisant la modification de la sortie. Si ce signal est à 1, l’état de
la sortie peut être modifié, sinon il ne change pas quel que soit l’état des entrées
S et R.
S Q
C
R Q'

C= 1 on est dans le cas de fonctionnement normale de la bascule RS.


C=1
Qn S R Qn+1
0 0 0 0
0 0 1 0
0 1 0 1
0 1 1 indéterminé
1 0 0 1
1 0 1 0
1 1 0 1
1 1 1 indéterminé

S R Qn+1
0 0 Qn mem
0 1 0 Reset C S R S’ R’ Q
1 0 1 Set 0 x x 1 1 mémorisation
1 1 indéterminé 1 0 0 1 1 mémorisation
1 0 1 1 0 0 (reset)
Qn+1 = S + R'.Qn 1 1 0 0 1 1 (set)
Avec S.R = 0 1 1 1 0 0 indéterminé
Bascule D asynchrone
 Une bascule D (" Données " ou " Data ") est en fait une bascule RSH
particulière, pour laquelle on a en permanence D=S=R’.
 D (“data”) et C (“control”).
 Quand C = 0, S’= R’ = 1, mémorisation. C D Q
0 x mémorisation
 Quand C = 1, la sortie Q est égal à l’entrée D.
1 0 0
1 1 1

C D S R Etat Qn+1 Qn+1


0 0 1 1 Mem Qn Qn
0 1 1 1 Mem Qn Qn
1 0 1 0 Reset 0 1
1 1 0 1 Set 1 0
Bascule D à contrôle par niveau (Latch-D)
Son fonctionnement est simple : si C est égal à 0, les sorties Q et /Q gardent leur état précédent
(qu’il soit 0 ou 1). Si C est égal à 1, on a : Q=D et /Q=/D.
Cette bascule réalise une fonction mémoire de la valeur D. (C=1, écriture dans la mémoire).
1*Q = Q
Bascule D 1/ 0 S 1/ 0/ 1
D 1/ 0
(Data) Q
0/ 1 0/ 1
D Q H
1
H Q R Q
1/ 0 0/ 1
Symbole logique 0/ 1

Mode transparent

Mode transparent
Verrouillées sur
Verrouillées sur

Verrouillées sur
Mode transparent
Mode transparent

Q=0
Q=1

Q=0
H
Table de vérité
H D Qn+1 D

0 X Qn Q
1 0 0
Quand H = 1, Qn+1= D, mode transparent
1 1 1
Dans ce cas si D change, Q suit fidèlement D
Qinitial=0
Quand H = 0, Qn+1= Qn, sorties verrouillées
Bascule D H D Qn+1
Bascule D: bascule de recopie. 0 X Qn
• H=0 : mode mémorisation 1 0 0
• H=1: mode d’acquisition (recopie D) 1 1 1
Différentiation des entrées:
• D: entrée des données
• H(Horloge): entrée de contrôle de commande

Etat présent Etat Suivante


Qn Qn+1 D=1
D=0 1
0 0 1 0 1
1 0 1 D=0
D=0 D=1
Bascule bistable D (flip-flop)
Maître Esclave
Qm Qn
D D Q D Q
Clk
Clk H H
/Qn

Maitre actif Maitre inactif Maitre actif


Esclave inactif Esclave actif Esclave inactif

Maitre Esclave

Clk=0, Qm+1=D “actif” Clk=0, Qn+1=Qn “inactif”


Clk=1, Qm+1=Qm “inactif” Clk=1, Qn+1=D “actif”

Principe de fonctionnement:
A tout moment une et une seule des bascules fonctionne l’autre est figée.
 Clk=0 Bascule 1 « Maitre » active et bascule 2 « esclave » est figée.
 Clk=1 Bascule 1 « Maitre » est figée et bascule 2 « esclave » est active.
Les 2 étages sont donc découplé et empêchent ainsi une propagation directe des entrées sur les
sorties.
Principe de fonctionnement: Maître Esclave
A tout moment une et une seule des bascules QM Q
fonctionne l’autre est figée D D Q D Q S

Clk H H
 Clk=0 , Qm+1=D “Bascule maitre actif”. /QS
 Clk=1 Qm+1=Qm “Bascule maitre figée”.

D Q
D
Q
CLK

QM

QS Bascule actif sur front


montant de l’horloge,
Maitre inactif Qs=D
Maitre actif
Esclave actif Esclave inactif
Bascule D synchrone
Actif au front montant de Clk, Qn+1 = D
Front montant si non Qn+1 = Qn
D Clk Qn+1 Qn+1
D Q
0 0 1
Clk Q’ 1 1 0
X 0 Qn Qn

Clk
Front montant
D
D
Q
Q
/
Q Q
Bascule D synchrone: active sur front descendant
Master Slave
Qm Qs
D D Q D Q Q

Clock Clk Q Clk Q Q

(a) Circuit

Clock

D
Qm

Q = Qs

D Q

Q
Bascule D
Bascule D asynchrone
D Q D
CLK
CLK

Mode transparent

Bascule D synchrone
D

D Q CLK
CLK
Q

Active sur front montant


La bascule JK

J H
D Q K
K

H /Q

D = J Qn + K Qn Au front montant Qn+1 = D

JK
H Jn Kn Qn+1
1X
0X ↑ 0 0 Qn Mémorisation
0 1 X0
↑ 0 1 0 reset
X1 ↑ 1 0 1 set
↑ 1 1 /Qn Togle
Pas de front
montant X X X Qn Mémorisation
Bascule JK
 J=K=0 bascule figée mémorisation
 J=1 et K=0, la bascule met la sortie Q à 1 au front montant de l’horloge.
 J=0 et K=1, la bascule met la sortie Q à 0 au front montant de l’horloge.
 J=K=1 l’état se sortie Q change après chaque front d’horloge montant suivant.

H
J H Jn Kn Qn+1

↑ 0 0 Qn
K ↑ 0 1 0
↑ 1 0 1
↑ 1 1 /Qn
Q X X X Qn

set
toggle J=K=0 reset J= 1 K=0
J=K=1 figée J= 0 K=1
Bascule T
T Q
T
J Q D
T Q H
H
K H

T=J=K H T Qn+1
D = T Qn + T Qn
H=0, Qn+1 = Qn
x 0 Qn
H=0, Qn+1 = Qn 1 /Qn
H
J=K=1 , Qn+1 = Qn
H , Qn+1 = D
J=K=0 , Qn+1 = Qn T = 0 D = Qn Qn+1 = T Qn + T Qn
T T = 1 D = /Qn
0 1 0

0 1

1
Preset et Clear: Entrées de forçage
• Permettent de commander les bascules indépendamment du signal d’horloge H
Pr (preset) force la sortie à 1, indépendamment des autres entrées
Cr (Clear) force la sortie à 0, indépendamment des autres entrées
Pr et Cr ne sont pas simultanément activés

? Pr Q ? Pr Q
H H
? Cr Q ? Cr Q

Cr et Pr actives au niveau bas Cr et Pr actives au niveau haut


Bascule D 7474
Preset
Data Pr Normale
D Q
Entrée FF Sortie
Clock CLK Q Complémenté
CLR
Clear

 Table de vérité
Operation Entrées Sorties
Asynchrone Synchrone
Pr CLR CLK D Q Q
Set asynchrone 0 1 X X 1 0

Reset asynchrone 1 0 X X 0 1

Etat interdit 0 0 X X 1 1

Set 1 1 L to H 1 1 0
Reset 1 1 L to H 0 0 1
Bascule D: Preset et Clear
Pr Preset active au niveau bas => Qn+1 = 1
mise à 1 Set asynchrone
D Q Clear active au niveau bas => Qn+1 = 0
mise à 0. Reset asynchrone
H
Q*

Cr
Pr Cr Dn Qn+1 H
0 1 X 1 D
1 0 X 0
Pr
0 0 X Interdit
1 1 0 0 Clr
1 1 1 Dn Q
Preset et Clear : entrée asynchrone
PRE PRESET
J Q Active au niveau bas Q=1
Clk
__ CLEAR
K Q CLR
Active au niveau bas Q=0

Opération Entrées Sorties


Pr Clr Clk J K Qn+1Q’n+1
Set asynchrone 0 1 x x x 1 0
Reset asynchrone 1 0 x x x 0 1
Etat interdit 0 0 x x x 1 1
-------------------------------------------------------------------------
Hold 1 1 0 0 Mem
Reset 1 1 0 1 0 1
Set 1 1 1 0 1 0
Toggle 1 1 1 1 Qn’ Qn
Résumé
PRE

Flip-flops J Q

CLK

Determiner la sortie Q de la bascule


K Q
JK ,
CLR

Set Toggle Set Reset Toggle Latch


CLK

K Set
PRE Reset
CLR

Q
Résumé

Bascule D
D Qn+1 Opération
0 0 Reset
1 1 Set Qn+1 = Dn

Bascule JK
J K Q n+1 Opération
0 0 Qn Mem
0 1 0 Reset Qn+1 = K’Qn + JQ’n
1 0 1 Set
1 1 Q’ n Complément

Bascule T
T Q n+1 Opération Qn+1 = T’Qn + TQ’n
0 Qn Mem = T  Qn
1 Q’ n Complément
Circuit Séquentiel

Souvent sous forme SOP


logique AND-
AND-OR

D
Souvent des bascules D mais
on peut avoir les 4 bascules
(SR, JK, D or T) T

Le nombre de bascules utilisé


dépend du nombre d’état J

39
II Machine de Moore et de Mealy
Machine à états finis: c’est une machine qui a une quantité finie de mémoire
pour représenter les états.
Il existe deux grandes catégories de machine séquentielle à état finis.
 Machine de Moore: Sorties en fonction des états seulement.

 S = g( État _présent )
 Machine de Mealy: Sorties en fonction des états et des entrées

 S = f( Entrée, État présent )

A toute machine de Mealy correspond une machine de Moore et réciproquement

Dans une machine de Mealy, une variation des entrées entraîne


immédiatement une variation de sortie
Dans une machine de Moore les variations de sorties n’interviennent
qu’aux moments des variations d’état.
Les machines de Mealy sont plus rapide, et ont moins d’états que les
machines de Moore, mais elles transmettent les parasites.
Les machines de Moore sont plus simples à concevoir
Machines de Mealy et de Moore

Machine de Moore

Entrées Sorties
Circuit Flip Circuit
Combinatoire Flops Combinatoire

Machine de Mealy

Entrées Circuit Flip Circuit Sorties


Combinatoire Flops Combinatoire
Les états sont représentés par des cercles avec leur nom inscrit à l’intérieur ; les transitions
entre les états sont représentées par des arcs dirigés reliant les cercles ; les conditions
enclenchant ces transitions sont notées sur les arcs ; et finalement la valeur des sorties est
généralement indiquée soit sur l’arc (séparée des entrées par un trait oblique : /) ou à l’intérieur
du cercle (séparée du nom de l’état par un trait oblique : /)

Diagramme d’états: machine de Moore


X=0

Dans le graphe des états de la machine de Moore:


Y /Z - chaque sommet correspond à un état présent y
- chaque flèche correspond à un état d’entrée x et
pointe vers un état futur yn+1
X=1 - l’état de sortie z est indiqué dans les sommets

Diagramme d’états: machine de Mealy


X=0 /Z

 chaque sommet correspond à un état présent y


Y  chaque flèche correspond à un état d’entrée x et
pointe vers un état futur yn+1
 l’état de sortie z est indiqué sur les flèches
X=1/Z
Diagrammes, Tables et variables d’états

 Pour concevoir un circuit séquentiel


o On détermine le nombre total d’états internes (les
différents états dans lesquels passe le circuit) qu’il faudra
manipuler
o A chaque état on affecte un symbole

 Le fonctionnement d’un tel circuit peut être schématisé par


un diagramme d’état ou l’on indique les états internes et les
transitions entre ces états
Implantation à l’aide des bascules JK
Table d’excitation
Une table de vérité ne donne pas assez d’informations sur le passé de la bascule. Une
table de transition ne s’intéresse pas à la sortie en fonction d’un état particulier de
l’entrée, mais à l’état d’entrée nécessaire à une transition particulière de la sortie.
Table d’excitation de la bascule JK

Table de vérité Table d’excitation


J K Qn Qn+1 Qn Qn+1 J K Opération

0 0 0 0 0 0 0 X Figée/reset
0 0 1 1 0 1 1 X Set/complément
0 1 0 0 1 0 X 1 Reset/complément
0 1 1 0 1 1 X 0 Figée/set
1 0 0 1
1 0 1 1
1 1 0 1
1 1 1 0
Implantation par des bascules D, T, RS et JK

Table d’excitation des bascules D, T, SR, JK

Tables d’excitation

Qn Qn+1 D T S R J K

0 0 0 0 0 X 0 X
0 1 1 1 1 0 1 X
1 0 0 1 0 1 X 1
1 1 1 0 X 0 X 0
II 1 La méthode FSM

Pour la conception d’un circuit séquentiel, on doit suivre les étapes


ci dessous

 1. Spécifie le problème
 2. Diagramme d’état
 3. Minimisation d’état
 4. Attribution d’état
 5. Table de transition
 6. Equation de conception
 7. Réalisation du circuit
Exemple 1: compteur modulo 4 / Implantation à
l’aide des bascules JK

Soit le diagramme d’état suivant qui correspond à un compteur modulo 4 avec une
entrée X.
0
X= 0 figé 2. Diagramme d’état
00
X=1 compte Etat Etat suivant
1 1 présent x=0 x=1
0 QAQB QA QB QA+QB+
+ +

01 11 0 0 0 0 0 1
0 0 1 0 1 1 0
1 0 1 0 1 1
1 1 1 1 1 0 0
1
10

0
On apprend à transformer un diagramme d'état en équations de
récurrences. Cela se fait très simplement à l'aide d'un tableau état
présent/état futur.
Exemple 1 suite
 Circuit séquentiel
QA’ QA QB’ QB
Q' Q Q' Q

K J K J
Clk
KA JA KB JB

4 états  2 bascules JK QA' circuit Sortie


QA
QB Combinatoire
QB'
x
Entrée
Circuit à
concevoir?
Il est important de comprendre le rôle de ce circuit combinatoire :
calculer l'état futur à partir de l'état présent.
Il faut utiliser Table d’excitation des bascules JK pour trouver les
équations de récurrences sur J et sur K.
Exemple 1 suite Etat
présent Entrée
Etat
Suivant
Entrées des bascules
JK

Table de transition QA QB x QA+ QB+ JA KA JB KB


0 0 0 0 0 0 X 0 X
Q Q+ J K 0 0 1 0 1 0 X 1 X
0 1 0 0 1 0 X X 0
0 0 0 X 0 1 1 1 0 1 X X 1
0 1 1 X 1 0 0 1 0 X 0 0 X
1 0 X 1 1 0 1 1 1 X 0 1 X
1 1 0 1 1 X 0 X 0
1 1 X 0 X 1
1 1 1 0 0 X 1

 Equation de conception QBx QB


QA 00 01 11 10
0 1
QB QB QA 1 X X X X
QBx QBx
QA QA
00 01 11 10 00 01 11 10 x
0 0
1 X X X X 1 JA = QB.x
QA 1 0 1 X X QA 1 X X 1
QBx QB
x x QA 00 01 11 10
JB = x KB = x 0 X X X X
QA 1 1

x
KA = QB.x
Exemple 1 Suite
 Circuit séquentiel
JA =KA = QB x JB = KB= x
Implantation à l’aide des bascules T
0

00 Etat Etat Entrée des


présent Entrée suivant Bascules
1 1 QA QB x QA+ QB+ TA TB
0 0 0 0 0 0
0 0 1 0 1
01 11 0 1 0 0 1
0 0 1 1 1 0
1 0 0 1 0
1 1 0 1 1 1
1
10 1 1 0 1 1
1 1 1 0 0
0
Bascule T  Bascule JK pour T=J=k
QA
QB
Qn Qn+1 J K T
Q' Q Q' Q
0 0 0 X 0 T T
0 1 1 X 1
1 0 X 1 1 Clk
1 1 X 0 0
TA = QB x, TB = x
x 51
Implantation à l’aide des bascules D
0
Etat Etat Entrée des
00 présent Entrée suivant Bascules
QA QB x QA+ QB+ DA DB
1 1 0 0 0 0 0 0 0
0 0 0 1 0 1 0 1
0 1 0 0 1 0 1
01 11 0 1 1 1 0 1 0
0 1 0 0 1 0 1 0
1 0 1 1 1 1 1
1
1 1 1 0 1 1 1 1
10 1 1 1 0 0 0 0

QBx QB
QA 00 01 11 10 QBx QB
0 1 QA 00 01 11 10
0 1 1
QA 1 1 1 1
QA 1 1 1
x
x
DA = QA.QB'+ xQA’QB +QAx' DB = QB'.x + QB.x’
= QB xor QA
Exemple 1 DA = QA.QB‘ + xQA’QB +QAx'
DB = QB'.x + QB.x’

 Circuit séquentiel:

QA.QB‘

D Q QA
QA.x
x
xQA’.QB Q' QA'

D Q QB

Q' QB'
Clk
Exemple 2
 Machine de Moore reconnaissant la séquence 10
S0: Pas d’élément de la séquence
S1: “1” observé 0 1
S2: “10” observé reset 0
1
S0/0 S1/0 1 S2/1
 Machine de Mealy
S0: Pas d’élément de la séquence 0
S1: “1” observé 0/0 1/0 1/0

S0 S1

reset 0/1
Chronogramme Moore & Mealy

Horloge
0 1 0 0 0
Entrée

Moore S0 S1 S2 S0 S0

Mealy S0 S1 S0 S0 S0

0 1 0/0
0 1/0 1/0
1 S1/0
S0/0 1 S2/1 S0 S1
reset reset 0/1
0
Exemple 3: Détecteur de la Séquence 101

w Z

Clock

X= 0 0 1 1 0 1 1 0 0 1 0 1 0 1 0 1 0 0
Z= 0 0 0 0 0 1 0 0 0 0 0 1 0 1 0 1 0 0

Z=1 quand une séquence 101 est détecté à l’entrée


pendant les trois dernières cycle de l’horloge, si non z=0
0/0
Mealy
Aucun Aucun élément de la séquence n’est détecté
Séquence à détecter: 101
1/0 1/0

0/0 un Un élément de la séquence est détecté

1/1 0/0

deux Deux élément de la séquence sont détectés

Etat Etat suivant Z


Présent w=0 w=1 w=0 w=1 Etat Code
Q1,nQ0,n
Aucun aucun un 0 0
Un deux un 0 0 Aucun 0 0
deux aucun un 0 1 Un 0 1
Deux 1 0
Table de codage
Table d’état
Q1,nQ0,n Q1,n+1Q0,n+1
état état suivant Z D1D0 wQ1,n
présent w=0 w=1 w=0 w=1 w=0 w=1 Q0,n 00 01 11 10
0 1
00 00 01 0 0 00 01
01 10 01 0 0 10 01 1 X X
10 00 01 0 1 00 01 Z= Q1,nw
Z
w w Q1,n
Q0,n 00 01 11 10
0 1 1
D0
Q0 1 X X 1
CK
D0 = w
Q1
wQ1,n
D1 Q0,n 00 01 11 10
CK
Horloge 0
D1 = Q0,nw
1 1 X X
Séquence 101
Diagramme de Mealy
0/0
0 Etat Etat suivant Z
Présent w=0 w=1
aucun Z=0
aucun
Aucun aucun un 0
1/0 1/0 Un deux un 0
1 1
deux aucun trouvé 0
0/0 un
Z=0
Trouvé deux un 0
0 un
1/1
0/0
0
Etat
Code
deux 1 deux Z=0 Q1 Q0
aucun 00
0 1
un 01
trouvé deux 10
Z=1 trouvé 11
Diagramme de Moore
Q1
Etat Présent Etat suivant Z 0 1
Q1,nQ0,n Q1,n+1Q0,n+1 D1 D0 Q0
0
w=0 w=1 w=0 w=1
Z= Q0Q1
1 1
00 00 01 0 00 01
01 10 01 0 10 01 wQ1
10 00 11 0 00 11 Q0 00 01 11 10
11 10 01 1 10 01 0 1 1
D0 = w
1 1 1

Q0 Z
w D0
CK wQ1
Q0 00 01 11 10
0 1

1 1 1
Q1
D1
CK

D1= Q0w + Q0Q1w


Horloge
Circuit détecteur de séquence: Mealy et
Moore
Mealy Moore
w Z

X Q0
D0 Z
CK
Q0
D0
CK

Q1
Q1
D1
D1
CK
CK
Clock

Clock

D0 = X D0 = X
D1= Q0X’
D1= Q0X’ + Q0’Q1X
Z= Q1X
Z= Q0Q1
IV Compteurs binaire
Compteur binaire asynchrone

Dans ce type de structure, l’impulsion de progression du


compteur est appliquée sur l’entrée d’horloge du premier étage,
les entrées d’horloge des autres bascules reçoivent le signal de
sortie de l’étage précédent.

Compteur binaire synchrone

Dans la structure synchrone, l’horloge est la même pour tous


les étages : le basculement de toutes les bascules se fait en
même temps
Références nominatives
CTR : compteur
Symbole distinctif des compteurs CTR DIV m : compteur-décompteur par
m ou modulo m
Entrée de comptage UP : Incrémente de 1 la sortie du compteur.
Entrée de décomptage DOWN : Décrémente de 1 la sortie du compteur.
Sortie fin de cycle de comptage CO : Carry. état indiquant que le Compteur est plein.
Sortie fin de cycle de décomptage BO : Borrow. État indiquant que le compteur est vide
Entrée de validation EN, CTEN, CE, OE : Valide le circuit, les sorties
Entrée d’horloge CLK, H : Signal permettant l’évolution des sorties
Entrée dynamique État interne = 1 sur le front montant du signal
Entrée dynamique avec négation O État interne = 1 sur le front
logique descendant du signal
H : niveau haut (stable)
L : niveau bas (stable)
X : niveau indifférent
Symbole des tables de ou : flanc ou front descendant
fonctionnement du signal (passage de H à L.
ou : flanc ou front ascendant (ou montant)
du signal (passage de L à H).
Compteurs asynchrones modulo 2n (n bascules)
Compteurs à cycle complets
 Exemple: compteurs modulo 4 (n = 2 bits ).(0 1  2  3  0…..)
1
J Q0 J Q1
CLK C C
Q0
K K
FF0 FF1

CLK 1 2 3 4

Q0 0 1 0 1 0
Q0 = CLK 2
Q0 Q1 = CLK 4
Q2 = CLK 8
Q1 0 0 1 1 0
Q3 = CLK 16
Q1Q0 00  01  10  11  00 ...
clk q0 fréquence f/2
(freq. f) compteur q1 fréquence f/4
q2
n-bit fréquence f/8


qn-1
fréquence f/2n
Compteurs asynchrones modulo 2n (n bascules)
Compteurs à cycle complets
 Exemple: Compteur asynchrone modulo 8 (n = 3 bits).
HIGH

J Q0 J Q1 J Q2
CLK C Q0 C Q1 C
K K K
FF0 FF1 FF2

CLK 1 2 3 4 5 6 7 8

Q0 0 1 0 1 0 1 0 1 0

Q0

Q1 0 0 1 1 0 0 1 1 0

Q1

Q2 0 0 0 0 1 1 1 1 0

Q[2..0] 0 1 2 3 4 5 6 7 0
Compteurs asynchrones modulo 2n (n bascules)
Compteurs à cycle complets
 Exemple: Compteur asynchrone modulo 16 (n = 4 bits )
HIGH
Q0 Q1 Q2 Q3
J J J J
CLK C C C C
K K K K
FF0 FF1 FF2 FF3

CLK 1 2 3 4 5 6 7 8

Q0

Q1

Q2

Q3

Q[3..0] 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 0 Valeur décimale


Compteur Diviseur de Fréquence
CLK 1 2 3 4 5 6 7 8
Q0 0 1 0 1 0 1 0 1 0

Q1 0 0 1 1 0 0 1 1 0

4
8 200 Hz

100 Hz 400 Hz
50 Hz 2
 16
Horloge

800 Hz
Compteur modulo 8 : Bascule JK
Dans le cas des bascule JK, en prenant J=K=1, on Qn+1 = /Qn.

Clk J Qa J Qb J Qc
1 1 1
>Clk >Clk >Clk
1 K Qa 1 K Qb 1 K Qc
Top Qc Qb Qa
0 1 2 3 4 5 6 7
0 0 0 0
1 0 0 1
2 0 1 0
Qa au front descendant de l’horloge Qa, n+1= /Qa,n:Togle .
3 0 1 1
En connectant
Au une autrede
front descendant bascule Qb,n+1
Qa : Jk =/Qb,n
à la sortie detoggle.
Qa
4 1 0 0
Qb
5 1 0 1
Si
Auonfront
connecte une 3ièmede
descendant Qb: QJk
bascule c,n+1 =/Qc,n toggle.
à la sortie de Qb, on aura:
6 1 1 0
Qc
7 1 1 1
Pour les 7 premières impulsions de l’horloge on la table suivante.

Cette table représente un compteur MOD 8. Le compteur revient à 000 a la 8ième impulsion de
l’horloge
Si on connectant les trois sorties Qa, Qb, et QC à 3 LED, cela représente un compteur qui compte
de 0 à 7 .
Décompteur Mod 8 :
Si cette fois ci on relie chaque sortie /Q de la bascule i à l’entrée clk de la
bascule i+1. On obtient un décompteur modulo 8.

Input J Qa J Qb J Qc
1 1 1
>Clk >Clk >Clk
1 K Qa 1 K Qb 1 K Qc

In Qc Qb Qa
Au front
0 descendant
0 0 de0 l’horloge
on a: Qa,n+1 = /Qa,n toggles .
1 1 1 1

Qa 2 descendant
Au front 1 1 de 0 /Q
a
on a: 3Qb,n+1 = /Q ,toggle
1 0b,n 1

Qa
Qb Le front4 descendant
1 0 de0/Qa
correspont au front montant
de Qa. 5 0 1 1
Au front
6 montant
0 1 de0 Qb
Qc on a Qc,n+1= /Qc,n
7 0 0 1
toggles .

Si on place des LEDs à la sortie de chaque bascule on aura.


Compteur / Décompteur asynchrone modulo 2n
 Exemple: compteur / décompteur (MOD-23) . (Avec une entrée Up/Down)

Up/Down = 0 fonction comptage


HB = QA
1
Q0 Q1 Q2
J Q J Q J Q
CLK C C C
Q' K Q' K Q'
K

Up/Down = 1 fonction décomptage HB = /QA


1
Up/Down Clk
Q0 Q1 Q2
J Q J Q J Q
CLK C C C 0 Q
Q' K Q' K Q'
K 1 /Q

Clk = Up/Down*Q + Up/Down*Q


Compteur Up/Down er :

Clk = Up/Down*Q + Up/Down*Q

1
0 Qa•1
0 1
0 Qb•1
0
1 J Qa 1 J Qb 1 J Qc
>Clk >Clk >Clk
1 K Qa 0 1 K Qb 0 1 K Qc
0
1 Qa•1 0
1 Qb•1
0
1
Up/Down

Quand l’entrée Up/Down=0 l’horloge Clk est reliée à la sortie Q de la bascule


précédant.
Le compteur compte.

Quand l’entrée Up/Down = 1 l’horloge Clk est reliée à la sortie /Q de la


bascule précédant.

Le compteur décompte.
Compteurs asynchrones modulo N < 2n
Compteurs à cycle incomplets

Initialisation et prépositionnement des compteurs

Très souvent, il convient de positionner les sorties du compteur de


manière à connaître la condition initiale de fonctionnement de la
structure. Cette fonction est réalisée à partir d’entrées
d’initialisation qui forcent toutes les sorties à l’état logique 0
(CLR, Clear, RAZ, RESET…) ou à 1 (SET, RAU…) et d’entrées
de prépositionnement (LOAD) qui permettent de « charger » en
sortie un mot binaire (0101 par exemple pour un compteur 4 bits).
Ces entrées sont le plus souvent asynchrones.
Compteurs asynchrones modulo N < 2n
Compteurs à cycle incomplets
Utilisation de l’entrée /PRESET ou /SET pour réinitialiser le compteur dans
l’état de départ
On détecte la valeur N et on s’en sert pour remettre le compteur à zéro

C B A
Q J Q J Q J
Tous les entrées CLK CLK CLK
J et K sont au Q K Q K Q K
CLR CLR CLR
niveau haut
B
C
Détecteur de N
….
Compteur n bits
Clr
Compteurs asynchrones modulo N < 2n
Compteurs à cycle incomplets
CBA  Exemple 1 compteur modulo 6:
000
001 610=1102 = CBA Quand CB=11 remettre le compteur à 0
010 C B A
Q J Q J Q J
011
100 CLK CLK CLK
101 Q K Q K Q K
Etat temporaire CLR CLR CLR
110 nécessaire à la Tous les
remise à zéro du B entrées J, K
compteur C sont au niveau
1 (HIGH).
1 2 3 4 5 6 7 8 9 10 11 12
Clock
La porte Nand
A remet la sortie
à 000 quand la
B valeur (110)
apparait à la
C sortie
Sortie 1
NAND 0
n
Compteurs asynchrones modulo < 2

1 2 3 4 5 6 7 8 9 10 11 12
Clock
A 0 1 0 1 0 1 0 1
B 0 0 1 1 0 0 0 0
C 0 0 0 0 1 1 0 0
NAND 1
Output 0

Bien que le compteur passe à l’état 110, c’est à peine quelques nanosecondes
avant son recyclage à 000
111 000
Etat 001
Temporaire
Compteur MOD-6.
110 010

101 011
100

Compteur modulo 6 obtenu en ramenant à 0 un compteur modulo 8


quand le contenu du registre atteint six (110)
Compteurs asynchrones modulo < 2n

Quelle est la fonction réaliser par ce circuit ?

F E D C B A
Q J Q J Q J Q J Q J Q J

Q K Q K Q K Q K Q K Q K
CLR CLR CLR CLR CLR CLR

C
D
E Tous les entrées J, K
F
sont à 1
Quand FEDC = 1111: on a Clr = 0
n
Compteurs asynchrones modulo < 2

 Compteurs BCD: « ou compteur modulo 10, ou compteur à décade »


 0000000100100011010001010110011110001
001 : 10 états (modulo 10).

1010=10102 = ABCD Quand AC=11 remettre le compteur à zéro


ie Clr = (AC)’
(A.C)'

HIGH
D C B A
J Q J Q J Q J Q

CLK C C C C
K K K K
CLR CLR CLR CLR
n
Compteurs asynchrones modulo < 2
 Compteurs BCD
HIGH D C B A
J Q J Q J Q J Q (A.C)'
CLK C C C C
K K K K
CLR CLR CLR CLR

1 2 3 4 5 6 7 8 9 10 11
Clock
D 0 1 0 1 0 1 0 1 0 1 0
C 0 0 1 1 0 0 1 1 0 0 0
B 0 0 0 0 1 1 1 1 0 0 0
A 0 0 0 0 0 0 0 0 1 1 0
Sortie
NAND
Compteurs asynchrones montés en cascade
 Le terme cascade indique que l’on peut mettre à la suite plusieurs
compteurs, permettant au final d’obtenir un compteur de plus grande
capacité
 Exemple: Un compteur modulo 32 peut être construit à partir d’un
compteur modulo 8 en cascade avec un compteur modulo 4.
Q0 Q1 Q2 Q3 Q4

J J J J J
Q Q Q Q Q

CLK C C C C C
Q' Q' Q' Q' Q'
K K K K K

compteur i Compteur i+1


modulo 8
modulo 4

Le MSB du compteur i est appliqué à l’horloge du compteur i+1


Chaque fois qu’un compteur repasse à 0, le compteur suivant est incrémenté
Compteur à décade
freq/10
1 CTEN Compteur
à décade TC
CLK C Q3 Q2 Q1 Q0
freq

La sortie TC indique quand le compteur est à 9 soit (1001)2

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 0
Clk

Q0 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1

Q1 0 0 1 1 0 0 1 1 0 0 1 1 0 0 1 1
Q2 0 0 0 0 1 1 1 1 0 0 0 0 1 1 1 1
0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1
Q3
Compteurs asynchrones en cascade
 Exemple: Compteur modulo 100
La sortie de fin de comptage TC permet la mise en cascade du
compteur. On obtient alors un compteur modulo les puissances de
Unités Dizaines
freq/10
1 CTEN Compteur CTEN Compteur freq/100
à décade TC à décade TC
CLK C Q3 Q2 Q1 Q0 C Q3 Q2 Q1 Q0
freq

TC = 1 quand le compteur des unités revient à 0

CTEN=1 Comptage

On obtient un compteur BCD en cascadant des


compteurs modulo 10 (compteurs à décade)
V Compteurs synchrones
 Exemple: compteur binaire synchrone 2-bit ( en utilisant des
bascules T , ou des bascules JK avec des entrées J et K au même
niveau.
Etat Etat Entrées Des Qn Qn+1 T
présent suivant bascules
00 01
Q1 Q0 Q1+ Q0+ T1 T0 0 0 0
0 0 0 1 0 1 0 1 1
0 1 1 0 1 1 1 0 1
11 10
1 1 0
1 0 1 1 0 1
1 1 0 0 1 1

Q0
Logique 1 Q1
T1 = Q0
T0 = 1
Clk

Clk

Q0
Q1
En utilisant des bascules JK

Etat Etat Entrées Des 1


présent suivant bascules
Q0 J Q1
Q1 Q0 Q1+ Q0+ J1K1 J0K0 J Q Q
0 0 0 1 C C
Q' K Q'
0 1 1 0 K
1 0 1 1
1 1 0 0 CLK

En utilisant une bascule T et une bascule D


Etat Etat Entrées Des
présent suivant bascules
Q1 Q0 Q1+ Q0+ T D
0 0 0 1
0 1 1 0
1 0 1 1
1 1 0 0
Qn Qn+1 D T S R J K

0 0 0 0 0 X 0 X
0 1 1 1 1 0 1 X
1 0 0 1 0 1 X 1
1 1 1 0 X 0 X 0
Compteurs synchrones
 Exemple: Compteur 3 bits (en utilisant des bascules T, des bascules JK
avec des entrées J et K au même niveau). Q1

Etat Etat Entrées des 1


T2 = Q1.Q0
présent suivant Bascules T Q2 1
Q2 Q1 Q0 Q2 Q1+ Q0+
+
T2 T1 T0
Q0
0 0 0 0 0 1 0 0 1 Q1
0 0 1 0 1 0 0 1 1
0 1 0 0 1 1 0 0 1 1 1
0 1 1 1 0 0 1 1 1 T1 = Q0
Q2 1 1
1 0 0 1 0 1 0 0 1
1 0 1 1 1 0 0 1 1 Q0
Q1
1 1 0 1 1 1 0 0 1
1 1 1 0 0 0 1 1 1 1 1 1 1
T0 = 1
Q2 1 1 1 1
Q2 Q1 Q0
Q0

Q Q Q
T2 T1 T0
Clk
1
 Example: Compteur 3 bits avec des bascules Jk
Etat Etat Entrées des
présent suivant Bascules JK
Q2 Q1 Q0 Q2 Q1+ Q0+
+
J2K2 J1K1 J0K0
0 0 0 0 0 1
0 0 1 0 1 0
0 1 0 0 1 1
0 1 1 1 0 0
1 0 0 1 0 1
1 0 1 1 1 0
1 1 0 1 1 1
1 1 1 0 0 0
Q2 Q1 Q0

Q Q Q
J K J K J K
Clk
1
Compteurs synchrones
 Remarque : Dans un compteur binaire , le nième bit (bleu souligné) est toujours
complémenté
011…11  100…00
ou 111…11  000…00
 Donc, Xn est complémenté si Xn-1Xn-2 ... X1X0 = 11…11.
 Comme résultat, si nous utilisons des bascules T, alors
Tn = Xn-1 . Xn-2 . ... . X1 . X0
Exemple n=3
Horloge Q2Q1Q0 Q1 change Q0 change à chaque cycle
0 0 0 0
Q2 change Le bit Q1 change quand Q0=1
1 0 0 1 Donc T1=Q0
2 0 1 0
Le bit Q2 change si à la fois Q1 et Q0
sont égaux à 1.
3 0 1 1
Donc T2=Q1Q0
4 1 0 0
En général, pour un compteur n bits,
5 1 0 1
une bascule i change d’état si les
6 1 1 0 états des bascule précédentes sont
7 1 1 1 dans l’état 1.
8 0 0 0 Ti=Qi-1Qi..Q0
Exemple 4
Compteur complexe: Séquence 000010011101110000
État présent État suivant Entrée des bascules
Diagramme des états
QC,nQB,nQA,n QC,n+1QB,n+1QA,n+1 TCTBTA

000 010
0 0 0 0 1 0 0 1 0
0 0 1 X X X XXX
110 011 0 1 0 0 1 1 0 0 1
0 1 1 1 0 1 1 1 0
1 0 0 X X X XXX
101 1 0 1 1 1 0 0 1 1
1 1 0 0 0 0 1 1 0
Table d’excitation Table des états
1 1 1 X X X XXX
QnQn+1 T
00 0 QBQA QBQA QBQA
01 1 QC 00 01 11 10 QC 00 01 11 10 QC 00 01 11 10
10 1 0 0 X 1 0 0 1 X 1 0 0 0 X 0 1
11 0
1 X 0 X 1 1 X 1 X 1 1 X 1 X 0

TB =QA +QB’ + QC TA =QA’QBQC’ + QB’QC


TC =QA  QC
QA’
QA QB
QB’ TB QC’ TA
QC

QB’
QA
TC QC
QC

TC QC TB TA
TS TS QB TS QA
CLK CLK CLK
R R R
1
Count 0
/Reset
Exemple 5
Compteur à décade BCD: Bascules T

 Exemple: Compteur à décade BCD en utilisant des bascules T

T0 = 1
T1 = Q3'.Q0
T2 = Q1.Q0
T3 = Q2.Q1.Q0 + Q3.Q0

Q0

1 T T Q1 T Q2 T Q3
Q Q Q Q
C C C C
Q' Q' Q' Q'

CLK
Compteurs/Décompteurs synchrones

 Exemple: Compteur/Décompteur binaire synchrone 3-bit


Clock pulse Up Q2 Q1 Q0 Down
Up=1 Compte
0 0 0 0
Up=0 Décompte 1 0 0 1
2 0 1 0
3 0 1 1
4 1 0 0
5 1 0 1
6 1 1 0
7 1 1 1

T0 = 1 Up =1 Up=0
T1 = (Q0.Up) + (Q0'.Up' ) (Compte) (Décompte)
T2 = ( Q0.Q1.Up ) + (Q0'. Q1'. Up' ) T0 = 1 T0 = 1
T1 = Q0 T1 = Q0’
T2 = Q0.Q1 T2 = Q0’.Q1’
Compteurs/Décompteurs synchrones

 Exemple: Compteur/Décompteur binaire synchrone 3-bit


T0 = 1
T1 = (Q0.Up) + (Q0'.Up' )
T2 = ( Q0.Q1.Up ) + (Q0'. Q1'. Up' )

Q0 Q1

1 T T T Q2
Q Q Q
Up C C C
Q' Q' Q'

CLK
Compteur code gray 3-bit: Bascule JK
000
 Exemple: Compteur code gray 3-bit (en 100 001
utilisant des bascules JK.
101 011

111 010
110
Etat Etat Entrée des
présent suivant bascules
Q2 Q1 Q0 Q2 Q1+ Q0+
+
J2 K2 J1 K1 J0 K0
0 0 0 0 0 1 0 X 0 X 1 X
0 0 1 0 1 1 0 X 1 X X 0
0 1 0 1 1 0 1 X X 0 0 X
0 1 1 0 1 0 0 X X 0 X 1
1 0 0 0 0 0 X 1 0 X 0 X
1 0 1 1 0 0 X 0 0 X X 1
1 1 0 1 1 1 X 0 X 0 1 X
1 1 1 1 0 1 X 0 X 1 X 0
Compteur code gray 3-bit: Bascule JK

 Exemple: Compteur code gray 3-bit (en


utilisant des bascules JK.

Q1Q0 Q1Q0 Q1Q0


Q2 Q2 00 01 11 10 Q2 00 01 11 10
00 01 11 10
0 0 1 X X 0 1 X X
1
1 X X X X 1 X X 1 X X 1

J2 = Q1.Q0' J1 = Q2'.Q0 J0 = Q2.Q1 + Q2'.Q1'


= (Q2  Q1)'
Q1Q0 Q1Q0 Q1Q0
Q2 00 01 11 10 Q2 00 01 11 10 Q2 00 01 11 10
0 X X X X 0 X X 0 X 1 X
1 1 1 X X 1 1 X 1 X
K2 = Q1'.Q0' K1 = Q2.Q0 K0 = Q2.Q1' + Q2'.Q1
= Q 2  Q1
Compteur code gray 3-bit: Bascule JK

 Compteur code gray 3 bits.


J2 = Q1.Q0' J1 = Q2'.Q0 J0 = (Q2  Q1)'
K2 = Q1'.Q0' K1 = Q2.Q0 K0 = Q2  Q1

Q0 Q1 Q2
J Q J Q J Q
C C C
Q1 Q2
K Q' K Q' ' K Q' '
Q0
'
CLK

Vous aimerez peut-être aussi