Filière GTE : Automatismes & circuits

Logique Séquentielle 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

I Logique séquentielle Horloge : composant passant indéfiniment et régulièrement d’un niveau

Sortie haut à un niveau bas (succession de 1 et de 0), chaque transition s’appelle
Entrée Logique un top.
Combinatoire La prise en compte du top se fait pendant les transitions de l’horloge.
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  Deux types de logique séquentielle :
précédent de la sortie.
Les systèmes séquentiels introduisent État  asynchrones :La sortie change d’état « en même temps » que l’état des
donc la notion de mémoire (pour future entrées.
stocker l’état du système) et
 synchrones :La sortie change d’état quand un signal de commande (horloge)
d’horloge (pour déterminer les Élément de mémoire
l’autorise. Cette horloge peut intervenir par :
instants de mesure)
front montant : 0→1
Les systèmes séquentiels apportent un aspect mémoire à la logique front descendant : 1→0

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. 1 1 1 1 1 1 1
h 0 0 0 0 0 0 0

T
Front montant Front descendant

R Skouri AU 2019/2020 Chapitre logique séquentielle 1

Filière GTE : Automatismes & circuits

Eléments de Mémoire Bascule RS asynchrone

 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 R=0 , S=0 et Q = 0 S R Qn Qn+1 Qn+1
élémentaires et d'opérateurs de logique combinatoire. 0 0 0

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

Commande Qn Qn+1
Qn: Etat présent
Set X 1 0
Qn+1 ou Q+: Etat suivant
Reset X 0 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 (Hold State)
L’élément de mémoire est dit dans l’état « Reset » si Q=0 et Q’=1
7

Bascule RS asynchrone
Bascule RS asynchrone
2 portes NOR Schéma équivalent
R
Q __
S Q S R Qn Qn+1 Qn+1
Q' R Q' 0 0 0 0 1
S
0 0
 2 entrées: S et R 1
 2 Sorties: Q et Q’
Elle est formé de deux portes NOR en connectant leurs sorties à
l’entrée de l’autre porte. 0 1
0
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)’ (Hold State)
Q’n+1 = (S + Qn)’
8

R Skouri AU 2019/2020 Chapitre logique séquentielle 2

Filière GTE : Automatismes & circuits

Bascule RS asynchrone Bascule RS asynchrone

__
R=1 , S=0 __
R=0 , S=0 et Q = 0 S R Qn Qn+1 Qn+1 S R Qn Qn+1 Qn+1
0 0 0 0 0 0 0 0 0 0
0 1 0 0 1 1 0 0 0 1 1 0
0 1 0 0 1
0 1 0 0 1

1 0
0 1
0 0

(Hold State) (Set State)

9 11

Bascule RS asynchrone Bascule RS asynchrone

__
R=0 , S=1 __
S R Qn Qn+1 Qn+1 S R Qn Qn+1 Qn+1
0 0 0 0 0 0 0 0 0 0
0 1 0 0 1 1 0 0 0 0 1 1 0
0 0 0 1 0 0 1
0 1 1 0 1
1 0 0

1 0 0 0
0 1

(Hold State) (Set State)

Qn+1=Qn Etat Hold (mémorisation)
10 12

R Skouri AU 2019/2020 Chapitre logique séquentielle 3

Filière GTE : Automatismes & circuits

Bascule RS asynchrone Bascule RS asynchrone

R=0 , S=1 et Q = 1 __ __
S R Qn Qn+1 Qn+1 S R Qn Qn+1 Qn+1
0 0 0 0 0 0 0 0 0 0
0 1 0 0 1 1 0 1 0 0 0 1 1 0
0 0 1 0 0 1 1 0 1 0 0 1
0 1 1 0 1 0 1 1 0 1
1 0 0 1 0 1 0 0 1 0
1 0 1 1 0 1 0 1 1 0
1 0 0 1
1 1

(Set State) (Invalid State) Etat invalide

13 15

Bascule RS asynchrone Table de vérité S R Qn+1

0 0 Mémorisation
R=1 , S=1 0 (reset)
__ __ 0 1
S R Qn Qn+1 Qn+1 1 0 1 (set)
S R Qn Qn+1 Qn+1
0 0 0 0 0
0 0 0 0 1
1 0 0 1 1 0 Sortie Figée  Aucune action
0 0 0 1 1 0
0 1 0 0 1
0 1 1 0 1 0 1 0 0 1 Mise à 0  Reset
1 0 0 1 0 0 1 1 0 1
1 0 1 1 0 1 0 0 1 0
0 Mise à 1  Set
1 1 1 0 1 1 0
1
1 1
1 1 0 0 0
État à éviter (Qn+1 = Qn+1)
1 1 1 0 0
(Invalid State)
14 Les sorties sont toujours complémentées, sauf pour S = R = 1

R Skouri AU 2019/2020 Chapitre logique séquentielle 4

Filière GTE : Automatismes & circuits

Bascule S’R’
Bascule formé de deux portes NAND en connectant leurs
sorties à l’entrée de l’autre porte NAND.
S R Qn+1 S' S’ R’ Q
Q
0 0 Figée 1 1 No change
1 0 0 (reset)
0 1 0 (reset) Q' 0 1 1 (set)
R' 0 0 Interdit
1 0 1 (set) 0 Set 0 0
S 0
PS NS
0 0 Reset 0
R 0 S’ R’ Qn Qn Qn+1 Qn+
1
1 PS: Etat présent Qn
Q 0 0 0 0 1 X X 1 0 set NS: Etat suivent Qn+1
1 1 1 1 0 X X 0 1 reset
/Q 0 1 1 0 1 0 1 hold
Mise à 1 Figée Mise à 0 1 1 1 0 1 0 hold
0 0 X X 1 1 interdit

Qn+1 Équation des sorties

Bascule RS SR
Qn 00 01 11 10 Bascule RSH
0 0 0 X 1 Qn+1 = S + RQn
Une amélioration de la bascule RS (verrou) consiste à ajouter un signal
S R Qn+1 1 1 0 X 1
interdisant ou autorisant la modification de la sortie. Si ce signal est à 1, l’état de
0 0 Mémorisation la sortie peut être modifié, sinon il ne change pas quel que soit l’état des entrées
S et R.
0 1 0 (reset) Graphe d’état S Q
1 0 1 (set)  Les états internes (Q) définissent les
C
sommets du graphe
 Les états d’entrée (R et S) définissent R Q'
Etat présent Etat suivant
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 C= 1 on est dans le cas de fonctionnement normale de la bascule RS.

R Skouri AU 2019/2020 Chapitre logique séquentielle 5

Filière GTE : Automatismes & circuits

1*Q = Q
Bascule D 1/ 0 S 1/ 0/ 1
D 1/ 0
(Data) Q
C=1
Qn S R Qn+1 0/ 1 0/ 1
D Q H
0 0 0 0 1
0 0 1 0
H Q R Q
0 1 0 1 0/ 1
0 1 1 indéterminé 0/ 1 1/ 0
Symbole logique
1 0 0 1

Mode transparent

Mode transparent
Verrouillées sur
Verrouillées sur

Verrouillées sur
Mode transparent
Mode transparent
1 0 1 0
1 1 0 1

Q=0
Q=1

Q=0
1 1 1 indéterminé
H
Table de vérité
S R Qn+1 C S R S’ R’ Q
0 x x 1 1 mémorisation H D Qn+1 D
0 0 Qn mem 1 0 0 1 1 mémorisation
0 1 0 Reset 1 0 1 1 0 0 (reset) 0 X Qn Q
1 0 1 Set 1 1 0 0 1 1 (set)
1 1 indéterminé 1 1 1 0 0 indéterminé 1 0 0
Quand H = 1, Qn+1= D, mode transparent
1 1 1
Qn+1 = S + R'.Qn Dans ce cas si D change, Q suit fidèlement D
Qinitial=0
Avec S.R = 0
Quand H = 0, Qn+1= Qn, sorties verrouillées

Bascule D H D Qn+1
Bascule D asynchrone Bascule D: bascule de recopie. 0 X Qn
• H=0 : mode mémorisation 1 0 0
 Une bascule D (" Données " ou " Data ") est en fait une bascule RSH
particulière, pour laquelle on a en permanence D=S=R’. • H=1: mode d’acquisition (recopie D) 1 1 1
C D Q
 D (“data”) et C (“control”). 0 x mémorisation Différentiation des entrées:
 Quand C = 0, S’= R’ = 1, mémorisation. 1 0 0
1 1 1
• D: entrée des données
 Quand C = 1, la sortie Q est égal à l’entrée D.
• H(Horloge): entrée de contrôle de commande

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

0 0 1 1 Mem Qn Qn
0 1 1 1 Mem Qn Qn Etat présent Etat Suivante
1 0 1 0 Reset 0 1 Qn Qn+1
1 1 0 1 Set 1 0 D=1
D=0 1
Bascule D à contrôle par niveau (Latch-D) 0 0 1 0 1
Son fonctionnement est simple : si C est égal à 0, les sorties Q et /Q gardent leur état précédent 1 0 1 D=0
(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). D=0 D=1

R Skouri AU 2019/2020 Chapitre logique séquentielle 6

Filière GTE : Automatismes & circuits

Bascule bistable D (flip-flop) Bascule D synchrone active sur front montant

Maître Esclave
Qm Qn Au front montant de Clk, Qn+1 = D
D D Q D Q Front montant si non Qn+1 = Qn
Clk
Clk H H
/Qn D Clk Qn+1 Qn+1
D Q
Maitre actif Maitre inactif Maitre actif 0 0 1
Esclave inactif Esclave actif Esclave inactif
Clk Q’ 1 1 0
Maitre Esclave X 0 Qn Qn

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

Clk=1, Qn+1=D “actif” Clk
Clk=1, Qm+1=Qm “inactif”
Front montant
D
Principe de fonctionnement: D
A tout moment une et une seule des bascules fonctionne l’autre est figée. Q
 Clk=0 Bascule 1 « Maitre » active et bascule 2 « esclave » est figée. Q
 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 Q Q

sorties.

Bascule D synchrone: active sur front descendant

Principe de fonctionnement: Maître Esclave
A tout moment une et une seule des bascules QM Q Master Slave
fonctionne l’autre est figée D D Q D Q S D D Q
Qm
D Q
Qs
Q

Clk H H Clock Clk Q Clk Q Q

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

(a) Circuit
D Q
D Clock
Q
D
CLK
Qm

QM Q = Qs

QS Bascule actif sur front

montant de l’horloge,
Qs=D D Q
Maitre inactif Maitre actif
Esclave actif Esclave inactif Q

R Skouri AU 2019/2020 Chapitre logique séquentielle 7

Filière GTE : Automatismes & circuits

Bascule D Bascule JK
Bascule D asynchrone  J=K=0 bascule figée mémorisation
D  J=1 et K=0, la bascule met la sortie Q à 1 au front montant de l’horloge.
D Q
CLK  J=0 et K=1, la bascule met la sortie Q à 0 au front montant de l’horloge.
CLK
 J=K=1 l’état se sortie Q change après chaque front d’horloge montant suivant.
Q
H
Mode transparent
J H J n Kn Qn+1
Bascule D synchrone
↑ 0 0 Qn
D K ↑ 0 1 0
↑ 1 0 1
D Q CLK ↑ 1 1 /Qn
CLK Q X X X Qn
Q
set
Active sur front montant toggle J=K=0 reset J= 1 K=0
J=K=1 figée J= 0 K=1

La bascule JK Bascule T
T Q
J T
J Q D
J H T Q H
K H
D Q
K K H

H /Q
T=J=K H T Qn+1
D = T Q n + T Qn
H=0, Qn+1 = Qn
x 0 Qn
H=0, Qn+1 = Qn 1 /Qn
H
D = J Qn + K Q n Au front montant Qn+1 = D
J=K=1 , Qn+1 = Qn
H , Qn+1 = D
JK J=K=0 , Qn+1 = Qn T = 0 D = Qn Qn+1 = T Qn + T Qn
H J n Kn Qn+1 T T = 1 D = /Qn
1X 0 1 1
0X ↑ 0 0 Qn Mémorisation
0 1 X0
↑ 0 1 0 reset 0 1
X1 ↑ 1 0 1 set
Pas de front ↑ 1 1 /Qn Togle 0
montant X X X Qn Mémorisation

R Skouri AU 2019/2020 Chapitre logique séquentielle 8

Filière GTE : Automatismes & circuits

Preset et Clear: Entrées de forçage Bascule D: Preset et Clear

Pr Preset active au niveau bas => Qn+1 = 1
• Permettent de commander les bascules indépendamment du signal d’horloge H
mise à 1 Set asynchrone
Pr (preset) force la sortie à 1, indépendamment des autres entrées D Q Clear active au niveau bas => Qn+1 = 0
Cr (Clear) force la sortie à 0, indépendamment des autres entrées mise à 0. Reset asynchrone
Pr et Cr ne sont pas simultanément activés H
Q*

Cr
? Pr Q ? Pr Q Pr Cr Dn Qn+1 H
H H
0 1 X 1 D
? Cr Q ? Cr Q
1 0 X 0
Pr
Cr et Pr actives au niveau haut
0 0 X Interdit
Cr et Pr actives au niveau bas
1 1 0 0 Clr
1 1 1 1 Q

Bascule D 7474 Preset et Clear : entrée asynchrone

Preset
Data
D
Pr
Q
Normale
PRE PRESET
Entrée FF Sortie J Q Active au niveau bas Q=1
Clock CLK Q Complémenté Clk
__ CLEAR
CLR K Q CLR
Clear
Active au niveau bas Q=0

 Table de vérité Opération Entrées Sorties

Pr Clr Clk J K Qn+1Q’n+1
Operation Entrées Sorties
Asynchrone Synchrone Set asynchrone 0 1 x x x 1 0
Pr CLR CLK D Q Q Reset asynchrone 1 0 x x x 0 1
Set asynchrone 0 1 X X 1 0 Etat interdit 0 0 x x x 1 1
Reset asynchrone 1 0 X X 0 1 -------------------------------------------------------------------------
Hold 1 1 0 0 Mem
Etat interdit 0 0 X X 1 1
Reset 1 1 0 1 0 1
Set 1 1 L to H 1 1 0 Set 1 1 1 0 1 0
Reset 1 1 L to H 0 0 1 Toggle 1 1 1 1 Qn’ Qn

R Skouri AU 2019/2020 Chapitre logique séquentielle 9

Filière GTE : Automatismes & circuits

Résumé
PRE
Circuit Séquentiel
Flip-flops J Q

CLK

Determiner la sortie Q de la bascule Souvent sous forme SOP

K Q
JK , logique AND-OR
CLR

Set Toggle Set Reset Toggle Latch Souvent des bascules D mais
CLK on peut avoir les 4 bascules
(SR, JK, D or T) T
J

K Set
Le nombre de bascules utilisé
PRE Reset dépend du nombre d’état J
CLR K

Q
39

Résumé II Machine de Moore et de Mealy

Machine à états finis: c’est une machine qui a une quantité finie de mémoire
Bascule D pour représenter les états.
D Qn+1 Opération Il existe deux grandes catégories de machine séquentielle à état finis.
0 0 Reset  Machine de Moore: Sorties en fonction des états seulement.
1 1 Set Qn+1 = Dn  S = g( État _présent )
 Machine de Mealy: Sorties en fonction des états et des entrées

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

Bascule JK
J K Q n+1 Opération A toute machine de Mealy correspond une machine de Moore et réciproquement
0 0 Qn Mem
0 1 0 Reset Qn+1 = K’Qn + JQ’n
1 0 1 Set Dans une machine de Mealy, une variation des entrées entraîne
1 1 Q’ n Complément immédiatement une variation de sortie
Dans une machine de Moore les variations de sorties n’interviennent
Bascule T qu’aux moments des variations d’état.
T Q n+1 Opération
Les machines de Mealy sont plus rapide, et ont moins d’états que les
Qn+1 = T’Qn + TQ’n machines de Moore, mais elles transmettent les parasites.
0 Qn Mem = T  Qn
1 Q’ n Complément Les machines de Moore sont plus simples à concevoir

R Skouri AU 2019/2020 Chapitre logique séquentielle 10

Filière GTE : Automatismes & circuits

Machines de Mealy et de Moore

Diagrammes, Tables et variables d’états

Machine de Moore  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
Entrées Sorties manipuler
Circuit Flip Circuit
Combinatoire Flops Combinatoire o A chaque état on affecte un symbole

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

Machine de Mealy un diagramme d’état ou l’on indique les états internes et les
transitions entre ces états

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 Implantation à l’aide des bascules JK
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 Table d’excitation
du cercle (séparée du nom de l’état par un trait oblique : /)
Une table de vérité ne donne pas assez d’informations sur le passé de la bascule. Une
Diagramme d’états: machine de Moore table de transition ne s’intéresse pas à la sortie en fonction d’un état particulier de
X=0 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
Dans le graphe des états de la machine de Moore:
Y /Z - chaque sommet correspond à un état présent y
Table de vérité Table d’excitation
- chaque flèche correspond à un état d’entrée x et
pointe vers un état futur yn+1 J K Qn Qn+1 Qn Qn+1 J K Opération
X=1 - l’état de sortie z est indiqué dans les sommets
0 0 0 0 0 0 0 X Figée/reset
Diagramme d’états: machine de Mealy 0 0 1 1 0 1 1 X Set/complément
0 1 0 0 1 0 X 1 Reset/complément
X=0/Z 0 1 1 0 1 1 X 0 Figée/set
1 0 0 1
 chaque sommet correspond à un état présent y 1 0 1 1
Y  chaque flèche correspond à un état d’entrée x et 1 1 0 1
pointe vers un état futur yn+1 1 1 1 0
 l’état de sortie z est indiqué sur les flèches
X=1/Z

R Skouri AU 2019/2020 Chapitre logique séquentielle 11

Filière GTE : Automatismes & circuits

II 1 La méthode FSM Exemple 1 suite

 Circuit séquentiel
QA’ QA QB ’ QB
Q' Q Q' Q
Pour la conception d’un circuit séquentiel, on doit suivre les étapes K J K J
ci dessous Clk
KA JA KB JB

 1. Spécifie le problème 4 états  2 bascules JK QA ' circuit Sortie

QA
 2. Diagramme d’état QB Combinatoire
QB '
 3. Minimisation d’état x

 4. Attribution d’état Circuit à

Entrée

 5. Table de transition concevoir?

 6. Equation de conception Il est important de comprendre le rôle de ce circuit combinatoire :
 7. Réalisation du circuit 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: compteur modulo 4 / Implémentation Exemple 1 suite Etat

présent Entrée
Etat
Suivant
Entrées des bascules
JK

à l’aide des bascules JK Table de transition QA QB

0 0
x
0
QA+
0
QB+
0
JA
0
KA
X
JB
0 X
KB

+ 1 X
Q Q J K 0 0 1 0 1 0 X
0 1 0 0 1 0 X X 0
0 0 0 X 0 1 1 1 0 1 X X 1
Soit le diagramme d’état suivant qui correspond à un compteur modulo 4 avec une 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
entrée X tel que: X 0
0 1 1 X 0 1 1 0 1 1 X 0
X= 0 Circuit figé 2. Diagramme d’état 1 1 1 0 0 X 1 X 1
X=1 Circuit compte 00
Etat Etat suivant  Equation de conception QBx QB
1 1 présent x=0 x=1 QA 00 01 11 10
0
0 QAQB QA+QB+ QA+QB+ 1

01 11 0 0 0 0 0 1 QB QB QA 1 X X X X
QBx QBx
0 0 1 0 1 1 0 QA 00 01 11 10 QA 00 01 11 10 x
1 0 1 0 1 1 0 0
1 X X X X 1 JA = QB.x
1 1 1 1 1 0 0
1 QA 1 0 1 X X QA 1 X X 1
10 QB
x x QBx
QA 00 01 11 10
0 JB = x KB = x 0 X X X X
On apprend à transformer un diagramme d'état en équations de QA 1 1
récurrences. Cela se fait très simplement à l'aide d'un tableau état x
présent/état futur. KA = QB.x

R Skouri AU 2019/2020 Chapitre logique séquentielle 12

Filière GTE : Automatismes & circuits

Exemple 1 Suite Implantation à l’aide des bascules D

 Circuit séquentiel
0
Etat Etat Entrée des
00 présent Entrée suivant Bascules
QA+ QB+
JA =KA = QB x JB = KB= x 1 1
QA QB x DA DB
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 = [Link]'+ xQA’QB +QAx' DB = QB'.x + QB.x’
= QB xor QA

Implantation à l’aide des bascules T Exemple 1 DA = [Link]‘ + xQA’QB +QAx'

0
00 Etat Etat Entrée des DB = QB'.x + QB.x’
présent Entrée suivant Bascules
1 1 QA QB x QA+ QB+ TA TB
0 0 0 0 0 0
01 11
0 0 1 0 1  Circuit séquentiel:
0 1 0 0 1
0 0 1 1 1 0
1 0 0 1 0 [Link]‘
1 1 0 1 1 1
1
10 1 1 0 1 1
D Q QA
1 1 1 0 0 QA.x
0 x
xQA’.QB
Bascule T  Bascule JK pour T=J=k Q' QA'

QA
QB
Qn Qn+1 J K T D Q QB
Q' Q Q' Q
0 0 0 X 0 T T
Q' QB'
0 1 1 X 1 Clk
1 0 X 1 1 Clk
1 1 X 0 0
TA = QB x, TB = x
x 51

R Skouri AU 2019/2020 Chapitre logique séquentielle 13

Filière GTE : Automatismes & circuits

Compteurs asynchrones modulo 2n (n bascules)

IV Compteurs binaire Compteurs à cycle complets
 Exemple: compteurs modulo 4 (n = 2 bits ).(0 1  2  3  0…..)
Compteur binaire asynchrone 1
J Q0 J Q1
Dans ce type de structure, l’impulsion de progression du CLK C C
Q0
compteur est appliquée sur l’entrée d’horloge du premier étage, K K
les entrées d’horloge des autres bascules reçoivent le signal de FF0 FF1
sortie de l’étage précédent. CLK 1 2 3 4

Compteur binaire synchrone Q0 0 1 0 1 0

frequence
Q0 FQ0 = FCLK 2
Dans la structure synchrone, l’horloge est la même pour tous
FQ1 = FCLK 4
les étages : le basculement de toutes les bascules se fait en Q1 0 0 1 1 0
même temps
Q1Q0 00  01  10  11  00 ...

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
clk q0 fréquence f/2
Entrée d’horloge CLK, H : Signal permettant l’évolution des sorties q1
(freq. f) compteur fréquence f/4
Entrée dynamique État interne = 1 sur le front montant du signal q2
n-bit fréquence f/8
Entrée dynamique avec négation O État interne = 1 sur le front

…
logique descendant du signal
qn-1
H : niveau haut (stable) fréquence f/2n
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).

R Skouri AU 2019/2020 Chapitre logique séquentielle 14

Filière GTE : Automatismes & circuits

Compteurs asynchrones modulo 2n (n bascules) Compteur Diviseur de Fréquence

Compteurs à cycle complets
CLK 1 2 3 4 5 6 7 8
 Exemple: Compteur asynchrone modulo 8 (n = 3 bits). Q0 0 1 0 1 0 1 0 1 0

HIGH Q1 0 0 1 1 0 0 1 1 0

J Q0 J Q1 J Q2
4
CLK C Q0 C Q1 C
8 200 Hz
K K K
FF0 FF1 FF2
100 Hz 400 Hz

CLK 1 2 3 4 5 6 7 8
50 Hz 2
Q0 0 1 0 1 0 1 0 1 0
 16
Q0
Horloge
Q1 0 0 1 1 0 0 1 1 0

Q1
800 Hz
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) Compteur modulo 8 : Bascule JK

Dans le cas des bascule JK, en prenant J=K=1, on Qn+1 = /Qn.
Compteurs à cycle complets
 Exemple: Compteur asynchrone modulo 16 (n = 4 bits )
Clk J Qa J Qb J Qc
1 1 1
HIGH >Clk >Clk >Clk
1 K Qa 1 K Qb 1 K Qc
Q0 Q1 Q2 Q3
J J J J
Top Qc Qb Qa
0 1 2 3 4 5 6 7
CLK C C C C 0 0 0 0
K K K K
1 0 0 1
FF0 FF1 FF2 FF3
Front Descendant 2 0 1 0
Qa au front descendant de l’horloge Qa, n+1= /Qa,n:Togle .
3 0 1 1
En
Auconnectant 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 onfront
Au connecte une 3ièmede
descendant Qb: QJk
bascule à la=/Q
c,n+1 sortie toggle.
c,n 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
Q[3..0] 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 0 Valeur décimale de 0 à 7 .

R Skouri AU 2019/2020 Chapitre logique séquentielle 15

Filière GTE : Automatismes & circuits

Décompteur Mod 8 : Compteur Up/Down er :

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. Clk = Up/Down*Q + Up/Down*Q

1
0 Qa•1
0 1
0 Qb•1
0
Input
1 J Qa 1 J Qb 1 J Qc 1 J Qa 1 J Qb 1 J Qc
>Clk >Clk >Clk >Clk >Clk >Clk
1 K Qa 1 K Qb 1 K Qc 1 K Qa 0 1 K Qb 0 1 K Qc
0
1 Qa•1 0
1 Qb•1
In Qc Qb Qa
0
1
Au front
0 descendant
0 0 de0 l’horloge
on a: Qa,n+1 = /Qa,n toggles . Up/Down
1 1 1 1

Qa 2 descendant
Au front 1 1 de 0 /Q
a Quand l’entrée Up/Down=0 l’horloge Clk est reliée à la sortie Q de la bascule
on a: 3Qb,n+1 =
1 /Q0b,n,toggle
1 précédant.
Qa
Qb Le front4 descendant
1 0 de0/Qa
correspont au front montant
Le compteur compte.
de Qa. 5 0 1 1
Au front
6 montant
0 1 de0 Qb
Qc on a Qc,n+1= /Qc,n Quand l’entrée Up/Down = 1 l’horloge Clk est reliée à la sortie /Q de la
bascule précédant.
7 0 0 1
toggles .

Le compteur décompte.
Si on place des LEDs à la sortie de chaque bascule on aura.

Compteurs asynchrones modulo N < 2n

Compteur / Décompteur asynchrone modulo 2n Compteurs à cycle incomplets
 Exemple: compteur / décompteur (MOD-23) . (Avec une entrée Up/Down)
Initialisation et prépositionnement des compteurs
Up/Down = 0 fonction comptage
HB = Q A Très souvent, il convient de positionner les sorties du compteur de
1 manière à connaître la condition initiale de fonctionnement de la
J Q
Q0 J Q
Q1 J Q
Q2 structure. Cette fonction est réalisée à partir d’entrées
CLK C
Q'
C C d’initialisation qui forcent toutes les sorties à l’état logique 0
K Q' K Q'
K
(CLR, Clear, RAZ, RESET…) ou à 1 (SET, RAU…) et d’entrées
HB = /QA de prépositionnement (LOAD) qui permettent de « charger » en
Up/Down = 1 fonction décomptage
sortie un mot binaire (0101 par exemple pour un compteur 4 bits).
1
Up/Down Clk Ces entrées sont le plus souvent asynchrones.
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

R Skouri AU 2019/2020 Chapitre logique séquentielle 16

Filière GTE : Automatismes & circuits

Compteurs asynchrones modulo N < 2n Compteurs asynchrones modulo < 2n

Compteurs à cycle incomplets
Utilisation de l’entrée /PRESET ou /SET pour réinitialiser le compteur dans 1 2 3 4 5 6 7 8 9 10 11 12
Clock
l’état de départ A 0 1 0 1 0 1 0 1

On détecte la valeur N et on s’en sert pour remettre le compteur à zéro B 0 0 1 1 0 0 0 0

C 0 0 0 0 1 1 0 0
NAND 1
Output 0
C B A
Q J Q J Q J
Tous les entrées CLK CLK CLK Bien que le compteur passe à l’état 110, c’est à peine quelques nanosecondes
J et K sont au Q K Q K Q K avant son recyclage à 000
CLR CLR CLR
niveau haut 111 000
Etat
B 001
C Temporaire
Compteur MOD-6.
Détecteur de N 110 010
….
101 011
Compteur n bits 100

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

quand le contenu du registre atteint six (110)

Compteurs asynchrones modulo N < 2n

Compteurs à cycle incomplets Compteurs asynchrones modulo < 2n
CBA  Exemple 1 compteur modulo 6:Clear Synchrone
000
001 610=1102 = CBA Quand CB=11 remettre le compteur à 0
010 C B A Quelle est la fonction réaliser par ce circuit ?
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 F E D C B A
compteur Q J Q J Q J Q J Q J Q J
C sont au niveau
1 (HIGH). Q K Q K Q K Q K Q K Q K
1 2 3 4 5 6 7 8 9 10 11 12 CLR CLR CLR CLR CLR CLR
Clock
La porte Nand
C
A remet la sortie D
à 000 quand la E Tous les entrées J, K
F
B valeur (110) sont à 1
apparait à la Quand FEDC = 1111: on a Clr = 0
C sortie
Sortie 1
NAND 0

R Skouri AU 2019/2020 Chapitre logique séquentielle 17

Filière GTE : Automatismes & circuits

n Compteurs asynchrones montés en cascade

Compteurs asynchrones modulo < 2  Le terme cascade indique que l’on peut mettre à la suite plusieurs
compteurs, permettant au final d’obtenir un compteur de plus grande
capacité
 Compteurs BCD: « ou compteur modulo 10, ou compteur à décade »
 Exemple: Un compteur modulo 32 peut être construit à partir d’un
 0000000100100011010001010110011110001 compteur modulo 8 en cascade avec un compteur modulo 4.
001 : 10 états (modulo 10).
Q0 Q1 Q2 Q3 Q4
1010=10102 = ABCD Quand AC=11 remettre le compteur à zéro
J J J J J
Q Q Q Q Q
ie Clr = (AC)’
CLK C C C C C
(A.C)'
Q' Q' Q' Q' Q'
K K K K K
HIGH
D C B A
J Q J Q J Q J Q

C C C C
compteur i Compteur i+1
CLK
modulo 8
K K K K modulo 4
CLR CLR CLR CLR

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é

Compteurs asynchrones modulo < 2n Compteur à décade

freq/10
1 CTEN Compteur
 Compteurs BCD à décade TC
CLK C Q3 Q2 Q1 Q0
HIGH D C B A freq
J Q J Q J Q J Q (A.C)'
CLK C C C C
K
CLR
K
CLR
K
CLR
K
CLR
La sortie TC indique quand le compteur est à 9 soit (1001)2

1 2 3 4 5 6 7 8 9 10 11
Clock 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 0
D 0 Clk
1 0 1 0 1 0 1 0 1 0
C 0 0 1 1 0 0 1 1 0 0 0
Q0 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
B 0 0 0 0 1 1 1 1 0 0 0
A 0 0 0 0 0 0 0 0 1 1 0 Q1 0 0 1 1 0 0 1 1 0 0 1 1 0 0 1 1
Sortie
NAND 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

R Skouri AU 2019/2020 Chapitre logique séquentielle 18

Filière GTE : Automatismes & circuits

En utilisant des bascules JK

Compteurs asynchrones en cascade Etat Etat Entrées Des 1
 Exemple: Compteur modulo 100 présent
Q1 Q0
suivant
Q1+ Q0+
bascules
J1K1 J0K0 J
Q0 J Q1
Q Q
La sortie de fin de comptage TC permet la mise en cascade du 0 0 0 1 C C
0 1 1 0 Q' K Q'
compteur. On obtient alors un compteur modulo les puissances de K
1 0 1 1
Unités Dizaines 1 1 0 0 CLK
freq/10
1 CTEN Compteur CTEN Compteur freq/100
En utilisant une bascule T et une bascule D
à décade TC à décade TC
CLK C C Etat Etat Entrées Des
Q3 Q2 Q1 Q0 Q3 Q2 Q1 Q0 présent suivant bascules
freq Q1 Q0 Q1+ Q0+ T D
0 0 0 1
0 1 1 0
1 0 1 1
TC = 1 quand le compteur des unités revient à 0 1 1 0 0
Qn Qn+1 D T S R J K
CTEN=1 Comptage
0 0 0 0 0 X 0 X
On obtient un compteur BCD en cascadant des 0 1 1 1 1 0 1 X
1 0 0 1 0 1 X 1
compteurs modulo 10 (compteurs à décade) 1 1 1 0 X 0 X 0

V Compteurs synchrones 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
 Exemple: Compteur 3 bits (en utilisant des bascules T, des bascules JK
avec des entrées J et K au même niveau). Q1
niveau.
Etat Etat Entrées Des Qn Qn+1 T
présent suivant bascules Etat Etat Entrées des 1
T2 = Q1.Q0
00 01 0 0 0 présent suivant Bascules T Q2
Q1 Q0 Q1+ Q0+ T1 T0 1
0 1 1 Q2 Q1 Q0 Q2+ Q1+ Q0+ T2 T1 T0
0 0 0 1 0 1 Q0
0 1 1 0 1 1 1 0 1 0 0 0 0 0 1 0 0 1 Q1
11 10 0 0 1 0 1 0 0 1 1
1 0 1 1 0 1
1 1 0
0 1 0 0 1 1 0 0 1 1 1
1 1 0 0 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
Q0 1 0 1 1 1 0 0 1 1 Q0
Q1 Q1
Logique 1 1 1 0 1 1 1 0 0 1
T1 = Q0 1 1 1 0 0 0 1 1 1 1 1 1 1
T0 = 1
T0 = 1 Q2 1 1 1 1
Clk Q2 Q1 Q0
Q0

Clk Q Q Q
T2 T1 T0
Q0 Clk
1
Q1

R Skouri AU 2019/2020 Chapitre logique séquentielle 19

Filière GTE : Automatismes & circuits

Exemple 4
 Example: Compteur 3 bits avec des bascules Jk
Compteur complexe: Séquence 000010011101110000
Etat Etat Entrées des État présent État suivant Entrée des bascules
Diagramme des états
QC,nQB,nQA,n QC,n+1QB,n+1QA,n+1 TCTBTA
présent suivant Bascules JK
Q2 Q1 Q0 Q2+ Q1+ Q0+ J2K2 J1K1 J0K0
0 0 0 0 0 1 000 010
0 0 1 0 1 0 0 0 0 0 1 0 0 1 0
0 1 0 0 1 1
0 1 1 1 0 0 0 0 1 X X X XXX
1 0 0 1 0 1 110 011 0 1 0 0 1 1 0 0 1
1 0 1 1 1 0 0 1 1 1 0 1 1 1 0
1 1 0 1 1 1 1 0 0 X X X XXX
1 1 1 0 0 0
101 1 0 1 1 1 0 0 1 1
Q2 Q1 Q0 1 1 0 0 0 0 1 1 0
Table d’excitation Table des états
1 1 1 X X X XXX
Q Q Q
QnQn+1 T
J K J K J K 00 0 QBQA QBQA QBQA
Clk 01 1 QC 00 01 11 10 QC 00 01 11 10 QC 00 01 11 10
1 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

Compteurs synchrones
 Remarque : Dans un compteur binaire , le nième bit (bleu souligné) est toujours
complémenté
QA’
011…11  100…00 QA QB
QB’ TB QC’
ou 111…11  000…00 TA
QC
 Donc, Xn est complémenté si Xn-1Xn-2 ... X1X0 = 11…11.
 Comme résultat, si nous utilisons des bascules T, alors Q B’
QA
Tn = Xn-1 . Xn-2 . ... . X1 . X0 TC QC
Exemple n=3 QC
Horloge Q 2Q 1Q 0 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. TC QC TB TA
TS TS TS
3 0 1 1
Donc T2=Q1Q0 QB QA
4 1 0 0
En général, pour un compteur n bits, CLK CLK CLK
5 1 0 1 R R R
une bascule i change d’état si les 1
6 1 1 0 états des bascule précédentes sont Count 0
7 1 1 1 dans l’état 1.
8 0 0 0
/Reset
Ti=Qi-1Qi..Q0

R Skouri AU 2019/2020 Chapitre logique séquentielle 20

Filière GTE : Automatismes & circuits

Exemple 5
Compteur à décade BCD: Bascules T Compteurs/Décompteurs synchrones

 Exemple: Compteur à décade BCD en utilisant des bascules T  Exemple: Compteur/Décompteur binaire synchrone 3-bit
T0 = 1
T0 = 1 T1 = ([Link]) + (Q0'.Up' )
T1 = Q3'.Q0 T2 = ( [Link] ) + (Q0'. Q1'. Up' )
T2 = Q1.Q0
T3 = Q2.Q1.Q0 + Q3.Q0
Q0 Q1

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

CLK CLK

Compteurs/Décompteurs synchrones Compteur code gray 3-bit: Bascule JK

000
 Exemple: Compteur/Décompteur binaire synchrone 3-bit  Exemple: Compteur code gray 3-bit (en 100 001
utilisant des bascules JK.
Clock pulse Up Q2 Q1 Q0 Down 101 011
Up=1 Compte
0 0 0 0
Up=0 Décompte 1 0 0 1 111 010
2 0 1 0
3 0 1 1
110
4 1 0 0 Etat Etat Entrée des
5 1 0 1 présent suivant bascules
6 1 1 0 Q2 Q1 Q0 Q2+ Q1+ Q0+ J2 K2 J1 K1 J0 K0
7 1 1 1
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
T0 = 1 Up =1 Up=0 0 1 1 0 1 0 0 X X 0 X 1
T1 = ([Link]) + (Q0'.Up' ) (Compte) (Décompte) 1 0 0 0 0 0 X 1 0 X 0 X
T0 = 1 T0 = 1 1 0 1 1 0 0 X 0 0 X X 1
T2 = ( [Link] ) + (Q0'. Q1'. Up' ) 1 1 0 1 1 1 X 0 X 0 1 X
T1 = Q0 T1 = Q0’ 1 1 1 1 0 1 X 0 X 1 X 0
T2 = Q0.Q1 T2 = Q0’.Q1’

R Skouri AU 2019/2020 Chapitre logique séquentielle 21

Filière GTE : Automatismes & circuits

Compteur code gray 3-bit: Bascule JK Registre

 Un registre est ensemble de I0 D Q Q0
 Exemple: Compteur code gray 3-bit (en bascules permettant de stocker une
utilisant des bascules JK. information sous forme de mots R
Q1Q0 Q1Q0 Q1Q0 binaires de n bits et, pour certains
Q2 Q2 Q2 I1 Q1
00 01 11 10
0
00 01 11
1 X
10
X
00
0 1
01 11
X X
10
types de registres, d'effectuer des D Q
0 1
1 X X X X 1 X X 1 X X 1 translations ou décalages sur ces
J1 = Q2'.Q0 J0 = Q2.Q1 + Q2'.Q1' mots R
J2 = Q1.Q0'
= (Q2  Q1)'
Exemple : registre mémoire 4 bits I2 D Q Q2
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 Au top de l’horloge, les 4 bits R
1 1 1 X X 1 1 X 1 X présents en entrée sont transférés
K2 = Q1'.Q0' K1 = Q2.Q0 K0 = Q2.Q1' + Q2'.Q1 en sortie. I3 D Q Q3
= Q2  Q1
CLK
↑Clk Q3Q2Q1Q0 = I3I2I1I0 R
Reset

Compteur code gray 3-bit: Bascule JK Registre

I0 D Q Q0
CLK
 Compteur code gray 3 bits.
I3 R
J2 = Q1.Q0' J1 = Q2'.Q0 J0 = (Q2  Q1)'
K2 = Q1'.Q0' K1 = Q2.Q0 K0 = Q2  Q1 I2 I1 D Q Q1
I1
R
I0
Q0 Q1 Q2
J Q J Q J Q
C C C Q3 I2 D Q Q2
Q1 Q2
K Q' K Q' ' K Q' '
Q0
Q2 R
'
CLK Q1
I3 D Q Q3
Q0
CLK
R
Reset

R Skouri AU 2019/2020 Chapitre logique séquentielle 22

Filière GTE : Automatismes & circuits

Registre 4 bits
Registre à chargement parallèle

Registre à chargement parallèle

Registre à chargement parallèle (entrées parallèles et
sorties parallèles ).

 Permet de charger une information sur N bits en

même temps
Load Q3+Q2+Q1+Q0+
0 Q3 Q2 Q1 Q0
1 I3 I2 I1 I0
Qi+ = [Link] + [Link]
Load = 0  état mémoire,
Load = 1  chargement en //

Qi
Qi+
Ii

Load = 1 Chg en // Load = 0 Figée

R Skouri AU 2019/2020 Chapitre logique séquentielle 23

Filière GTE : Automatismes & circuits

Registre à entrée série et sortie série Registre à décalage a droite Q3+ Q2+ Q1+ Q0+ = Din Q3 Q2 Q1
 Registre à décalage à gauche Q3+ Q2+ Q1+ Q0+ = Q2 Q1Q0 D0
PS NS
Top Q3 Q2 Q1 Q0 Din Q3+ Q2+ Q1+ Q0

↑Clk 0 0 0 0 1 0 0 0 1
↑Clk 0 0 0 1 0 0 0 1 0
↑Clk 0 0 1 0 0 0 1 0 0
↑Clk 0 1 0 0 0 1 0 0 0

Entrée Série Sortie Série

PS NS
Din est sur Q3 après 4 Top Q3 Q2 Q1 Q0 Din Q3+ Q2+ Q1+ Q0 Din est sur Q0 après 4
fronts actifs de CLK fronts actifs de CLK
↑Clk 0 0 0 0 1 1 0 0 0
↑Clk 1 0 0 0 0 0 1 0 0
↑Clk 0 1 0 0 0 0 0 1 0
↑Clk 0 0 1 0 0 0 0 0 1

Registre à décalage Q3+ Q2+ Q1+ Q0+ = Din Q3 Q2 Q1

Q3 Q2 Q1 Q0 Transfert série
Din D3 Q 3 D2 Q2 D1 Q1 D0 Q0 Dout

SI Registre à décalage A SO SI Registre à décalage B

CLK Clock CLK CLK

Shift
CLK Control
Din Clock
Q3
Shift
Q2 Control
Q1 CLK
Q0

Fonction décalage à droite Di = Qi+1

R Skouri AU 2019/2020 Chapitre logique séquentielle 24

Filière GTE : Automatismes & circuits

Registre à décalage Universel

 Entrée Parallèle - Sortie Parallèle
 Entrée Série – Sortie Série
 Entrée Série - Sortie Parallèle
 Entrée Parallèle - Sortie Série

D Q D Q D Q D Q

Registre à décalage Universel

Control
Fonction réalisée
S1 Q3 Q2 Q1 Q0 CLR S1 S0
S0 0 0 Figée
SRin 0 1 Décalage à droite
D3 D2 D1 D0 SLin
1 0 Décalage à gauche
1 1 Chg en // S2S1=00  Mémorisation
décalage à gauche Di = Qi-1
Control
Q3+ Q2+ Q1+ Q0+ décalage à gauche Di = Qi+1
S1 S0
0 0 Q3 Q2 Q1 Q0 Q3 I0
0 1 Dd Q3 Q2 Q1 Dd Mux Q3+
I1
Q2 2x1
1 0 Q2 Q1 Q0 Dg I2
1 1 E3 E2 E1 E0
E3 I3 S1 S0 S2S1=01  Décalage à droite

R Skouri AU 2019/2020 Chapitre logique séquentielle 25

Filière GTE : Automatismes & circuits

S2S1=10  Décalage à gauche

S2S1=11  Chargement en //

Registre en utilisant des bascules JK

Compteur Binaire à chargement en Parallèle
J K Q n+1 D Qn+1
0 0 Qn 0 0
0 1 0 1 1
1 0 1
E3 Q3
1 1 Q’ n CLR LD Count Fonction réalisé
J K Q n+1
E2 Q2
0 x x Mise à 0
0 0 Qn E1 Q1
D D’ D 1 0 0 Mémorisation
1 1 Q’ n E0 Q0
1 0 1 comptage
LD
Control S1S0 JK Q3+ Q2+ Q1+ Q0+ 1 1 x Chg en //
Fonction réalisée Count
S1 S0 00 J=k’ Q3 Q2 Q1 Q0
0 0 Figée 01 J=k’ Dd Q3 Q2 Q1 CLR
0 1 Décalage à droite 10 J=k’ Q2 Q1 Q0 Dg
1 0 Décalage à gauche 11 J=k’ E3 E2 E1 E0
1 1 Chg en //

R Skouri AU 2019/2020 Chapitre logique séquentielle 26

Filière GTE : Automatismes & circuits

Compteur Binaire à chargement en Parallèle

PS NS Entrées Fonctions réalisées
Q3 Q2 Q1 Q0 Q3+ Q2+ Q1+ Q0 Clr LD Count

0 0 0 0 0 0 0 1 1 0 1
0 0 0 1 0 0 1 0 1 0 1
0 0 1 0 0 0 1 1 1 0 1
0 0 1 1 0 1 0 0 1 0 1
Comptage
0 1 0 0 0 1 0 1 1 0 1
0 1 0 1 0 1 1 0 1 0 1
0 1 1 0 0 1 1 1 1 0 1
1 0 0 0 1 0 0 1 1 0 1
1 0 0 1 0 0 0 0 1 1 X Chg en // de 0000

Donc Clr = 1,
LD= Q3Q0
Count =1
106 / 28

Exemple de Compteur BCD

LD
Donc Clr = 1, 0 E3 Q3
LD= Q3Q0
Count =1 0 E2 Q2
0 E1 Q1
0 E0 Q0
1
Count
CLR

1 CLK

R Skouri AU 2019/2020 Chapitre logique séquentielle 27