Base Sequentielle PDF

Base Sequentielle.
doc 1
COURS DE CIRCUITS NUMERIQUES
Poly 2
Logique Séquentielle
Circuits séquentiels de bases
Compteurs, décompteurs, registres à décalage
Génération d’impulsion analogique et numérique
Par G. PALLOT
DUT GEII_ 1 CNAM ed 2010

Base Sequentielle.doc 2
SOMMAIRE
1. INTRODUCTION A LA LOGIQUE SEQUENTIELLE 5
1.1. Généralités 5
1.2. Circuits séquentiels élémentaires 7
1.2.1. La bascule RS, ou Latch, ou Verrou. 7
1.2.2. Bascule RS synchronisée sur horloge à niveau : RSH 9
1.2.3. la bascule D à horloge à Niveau 9
1.2.4. Historiques bascules maître-esclave 10
1.2.5. Bascules D à front 11
1.2.6. Bascules D à front et entrée de validation E 12
1.2.7. Historiques et ‘Moyenâgeuses’ Bascules JK 13
1.2.8. Compteur 1 bit, bascule D montée en « Toggle » 13
1.2.9. Compteur élémentaire 1 bits à validation 14
1.3. Registre à décalage Synchrone, bascules D à front en cascade 16
2. COMPTEURS BINAIRES ASTYNCHRONES 17
3. SYSTEMES SYNCHRONES : ETUDE GLOBALE PAR LES MACHINES D’ETAT

19
3.1. Généralités : Les deux machines 19
3.2. Générateurs de petites séquences synchrones quelconques 19
3.3. Premier exemple: compteur par 3 : 1,2,3,1,2,3 21
3.4. Deuxième exemple: Les registres à décalages bouclés 22
3.4.1. Le compteur 1 parmi 3, ou « chenillard …. » 22
3.4.2. Le compteur Johnson 24
3.5. Diagrammes d’états 26
4. COMPTEURS BINAIRES SYNCHRONES 28

4.1. Méthode d’étude, par machines d’états (les Qi+) ? 28
4.2. Compteur 3 bits synchrone par mise en cascade de compteurs
élémentaires 1 bit 28
4.3. Compteurs Binaires Synchrones, N bits (modulo 2N) 29
5. COMPTEURS BINAIRE ET DECIMAL CODE BINAIRE 31

5.1. Généralités 31
5.2. Chronogrammes de compteurs 4 bits 32
5.2.1. Compteur Binaire Naturel 32
5.2.2. Compteur 4 bits, DCB 33
6. TECHNIQUES DE MISE EN CASCADE DE COMPTEURS 35

6.1. Mise en cascade série ou asynchrone 35
6.2. Mise en cascade, synchrone 35
6.2.1. Deux compteurs Binaires ou DCB de 4 bits 35
6.2.2. Ajouter un bit ou plus à un compteur quelconque 36
7. COMPTEURS BINAIRE OU DCB A CYCLE INCOMPLETS 37

7.1. Principe : compteur modulo M 37
7.2. Quelques exemples 37

7.3. Compteur DCB 1 chiffre à partir d’un compteur Binaire 4 bits 38

7.3.1. Compteur DCB élémentaire 38
7.3.2. Mise en cascade de ces compteurs DCB 38
8. DECOMPTEURS SYNCHRONES 39
8.1. Binaire : principe de base à partir de compteurs 1 bit à validation 39
8.2. DCB 4 bits à partir d’un décompteur binaire 4 bits 39
8.3. Décompteurs à partir de compteurs binaires 40
8.3.1. Décompteur binaire 40
8.3.2. Décompteur DCB 40
9. REGLES D’ASSOCIATION EN LOGIQUE SYNCHRONE 41
10. DEUX APPLICATIONS SIMPLES DE COMPTEURS 42

10.1. Principe d’une montre numérique 42
10.2. Principe d’une minuterie 42
11. GENERATION D'IMPULSIONS 43

11.1. Création d’une impulsion en Numérique 43
11.2. Création d’une impulsion en Analogique 43
11.2.1. Détection des fronts d'un signal par simple RC 43
11.2.2. Monostables réalisés à partir de portes. 46
11.2.3. Monostables de précision en circuits intégrés. 47
11.3. Initialisation d’un système à la mise sous tension 48
11.4. Mini retard d'un signal logique 49
11.5. Astables à portes logiques 49
11.5.1. A réseau RC 49
11.5.2. A Quartz. 50
11.5.3. Autres astables 51


1. INTRODUCTION A LA LOGIQUE SEQUENTIELLE
Dans un circuit combinatoire, une sortie est uniquement fonction des entrées. Par contre,
dans un circuit séquentiel, une sortie est une fonction des entrées mais aussi des sorties
précédentes du circuit. Il y a rétroaction des sorties sur les entrées.
Ceci permet de réaliser entre autre la fonction de base de tout système numérique : la
fonction mémoire.
1.1. Généralités
Système
Ensemble de circuits logiques assurant un cahier des charges donné.
Exemple très simple : un compteur 4 bits (de 0 à 15) avec entrée de comptage et de remise
à zéro.
Etats d’un système

Vu de l’extérieur, un système comprend des entrées et des sorties. Pour l’exemple
précédent (compteur de 0 à 15), nous avons: 2 entrées (comptage et remise à zéro), et 4 sorties
(les 4 bits du compteur). Cela fait 6 signaux logiques, donc 26 = 64 états possibles.
Vu de l’intérieur, un certain nombre de variables secondaires internes sont souvent
nécessaires à sa conception. D’où un bien plus grand nombre d’états si l’on tient compte de
toutes ces variables.
Selon les valeurs de toutes ces variables logiques, le système ou une partie du système se
trouve dans différents états.
Certains états peuvent être instables et durer le temps nécessaire à la commutation de
tous les circuits, ordre de grandeur pour des circuits logiques classiques : quelques ns (nano-
secondes ) à quelques dizaines de ns.
Exemple de la remise à zéro de notre compteur 4 bits,et si celle-ci agit immédiatement :
étudions les 4 bits de sortie et la commande de remise à zéro :
Etat stable 0111 0
Etat instable 0111 1 demande de remise à zéro
Etat stable suivant 0000 0
Exemple de trois variables quelconques devant passer par exemple de 011 à 100. On peut
imaginer, si la commutation n’est pas quasi simultanée, des états intermédiaires instables (en
petits caractères), ne durant que quelques nanosecondes :
011 010 000 100 ou bien 011 111 101 100 ou …..
Certains états peuvent être physiquement exploités, et d’autres non :

Exemple : un compteur décimal de 0 à 9 possède 4 bits de sorties, d’ou 10 états principaux du
système, les 6 autres états des sorties (codes hexa A,B,C,D,E,F) existent évidemment
physiquement, mais sont non exploités.
Horloge
On nomme horloge un signal qui déclenche ou cadence quelque chose.
Cadence régulière : lente ou rapide (de moins de 1 Hz à plusieurs centaines de MHz, cela
dépend des systèmes).
Cadence irrégulière, l’action sur un simple bouton poussoir peut parfois être considéré
comme un signal d’horloge.

Systèmes Asynchrones
- Les sorties des circuits logiques peuvent changer à tout moment dès qu’une ou
plusieurs entrées se modifient, avec des temps de propagation variables.
- Elles ne changent donc pas toutes en même temps, les temps de propagation
étant différents.
- Plusieurs horloges peuvent exister, à la limite une par circuit.
Sorties :
Système Variables
Entrées (Directement
utiles)
Variables internes
Plusieurs horloges possibles
Systèmes Entièrement synchrone
- Les entrées préparent le système complet à changer d’état.
Sorties :
Système Variables
Entrées (Directement
utiles)
Horloge Variables internes

H
- Toutes les sorties devant se modifier changent d’état en même temps après
l’évènement Horloge (signal noté Ck ou Clk ou H)
- L’horloge est unique
On observe un temps de propagation unique entre Le Ck et les transitions des
variables. Ce temps est du à des raisons physiques évidentes, ordre de grandeur en
électronique standard quelques ns.
- Conception et fiabilité améliorées.
Types d’entrées
- A action Synchrone
Elle prépare le circuit pour éventuellement changer d’état sur l’évènement horloge suivant.
- A action Asynchrone
Elle agit immédiatement (après juste un temps de propagation). Leur emploi est donc
limité lorsque l’on conçoit des systèmes totalement synchrones.
Horloge
- Action sur Front. C’est la transition montante (ou descendante) qui constitue
l’évènement et provoque éventuellement les changements d’états.
La plupart des circuits logiques séquentiels possèdent une entrée horloge sur front.
-Action sur niveau. Par exemple inactive à 0. Agit en permanence au niveau 1,

redevient inactive au niveau 0. Il ne faut donc pas que les conditions de
changement d’état se modifient pendant que H est au niveau 1, car alors le circuit
peut évoluer sans cesse.
Un circuit à horloge à action sur niveau rend délicate ou impossible la conception de
systèmes synchrones. Emploi limité.

Notations : Q et Q+ ou Qn et Qn+1 On utilisera l’une ou l’autre de ces notations

pour indiquer la valeur d’une sortie Q respectivement AVANT et APRES son
changement d’état éventuel dans un système séquentiel.
1.2. Circuits séquentiels élémentaires

1.2.1. La bascule RS, ou Latch, ou Verrou.
Cherchons à réaliser la forme la plus élémentaire de circuit séquentiel, que l’on appellera
un latch (verrou), ou un bistable. C’est aussi une mémoire élémentaire 1 bit.
Exemple concret et tout simple d’application : Allumer une lampe en appuyant sur un
bouton poussoir, et l’éteindre par un autre.
Table de vérité, on suppose les entrées actives à un, la logique positive est à priori plus
simple pour raisonner.
Entrée S comme SET, mise à 1
Entrée R comme RESET, mise à 0
S R Qn+1 commentaires
0 0 Qn Repos, mémoire
0 1 0 Mise à 0 (Reset)
1 0 1 Mise à 1 (set)
1 1 Absurde ……
A un instant donné t, la sortie stable vaut Qn , si à cet instant une modification d’une ou de
plusieurs entrées survient, la sortie change éventuellement d’état et soit Qn+1 la valeur
désirée lorsque tout est de nouveau stabilisé.
Utilisation du diagramme de Karnaugh Normal :
Donc : Qn + 1 = R.S + Qn.R R 0 0 1 1
Ou plus simple si on met 1 à la place des Qn S 0 1 1 0
tirets non utilisés :
0 0 1* - 0
Qn + 1 = S + Qn.R Qn+1
Les deux états marqués par * correspondent à - 0*
1 1 1
Qn+1 ≠ Qn donc à un état instable de durée
égale au temps de commutation des circuits
(quelques ns en réalité)
Utilisation du diagramme de Kanaugh « Compact »

Qn est une simple donnée, la fonction mémoire est la même pour S
Qn à 0 ou à 1. R et QS sont les deux commandes. Donc deux R 0 1
entrées seulement. 0 Qn 1
C’est en fait la recopie direct de la table de vérité initiale ou
figurait 1 0 -
Donc : Qn + 1 = S + Qn.S . R
Il faut par contre se rappeler de la formule magique de Tableau de Qn+1
simplification toujours très utile : X + X .Y = X + Y (ou Q+)
Ôn arrive alors à la même équation :
Qn + 1 = S + Qn.R

D’ou le montage, Qn+1 et Qn sont en fait physiquement la même variable logique Q prise
à deux instant différents, donc la même ligne.
S
Q Q = S + Q.R = S . (Q.R)
On s’aperçoit que cette fonction de
74LS00N
base est plus simple à réaliser avec en
entrée des variables en logique négative :
S et R plutôt que S et R.
R
Q sauf dans On voit aussi apparaître une variable
74LS00N le cas non secondaire (sortie de la porte du bas).
utilisé ! Sauf pour le cas normalement non utilisé
de mise à 0 et à 1 simultanément, cette
sortie est l’inverse de l’autre (facile à
vérifier)
On notera pourtant cette seconde sortie Q , en sachant que ce n’est pas mathématiquement
exact ! En effet pour le cas non utilisé, les deux sorties sont égales et à 1 !
Ce cas peut d’ailleurs être dangereux, car après avoir actionnées en même temps les deux
entrées, le circuit peut prendre aléatoirement l’un ou l’autre état au moment ou elles
redeviennent inactives, en fonction aussi du décalage temporel éventuel, même très faible,
entre les deux entrées.
R
Autre forme possible, avec entrées en logique Q
74LS02
positive
(mais les portes NOR sont moins polyvalentes que
les portes NAND)
Q
S 74LS02
Ces circuits sont asynchrones à action sur niveau, pas de notion d’horloge.
N’existe pas en circuit intégré. Existe en composant pour la logique programmable.
Exemples d’applications : :
Mise à un sur un signal ou interrupteur, Anti Rebond câblé

mise à zéro par un autre. VCC 5V
VCC 5V
10 kohm
10 kohm
S Q
S Q
1
R 2 3
1
R 2 3
10 kohm
10 kohm
5V VCC
5V VCC
Autre exemple à faire en exercice : une minuterie, mise à UN sur un bouton poussoir,
mise à ZERO sur un niveau indiquant la fin du comptage du temps (sans ajouter ici de
compteurs). On pourrait faire plusieurs câblages possibles selon les signaux (actifs à 1 ou 0).

1.2.2. Bascule RS synchronisée sur horloge à niveau : RSH
R S H Qn+1 Fonction : S s
X X 0 Qn mémoire Q
0 0 1 Qn mémoire
H
0 1 1 1 mise à 1
1 0 1 0 mise à 0 Q
1 1 1 X interdit R r
Quand H vaut 1, le bistable fonctionne normalement. Quand H vaut 0, il garde en

mémoire l’état antérieur. On appelle ce circuit un bistable RSH. Il est synchronisé sur le
niveau de l’horloge H.
1.2.3. la bascule D à horloge à Niveau
C’est une variante importante du circuit précédent :

D S Q
R RSH
H H Q
On pose S = D et R = D .
Elle permet la recopie (mémorisation) de D vers Q sur une impulsion de H
On a toujours R.S = 0.
Il réalise la fonction Q n+1 = H.Q n + H.D (la table de vérité compacte serait facile à
écrire, avec en entrée la seule vraie commande H, en sortie Qn+1, et comme valeurs internes :
0, 1, Qn et D).
Deux états selon H :

Etat recopie, nommé transparent : Qn+1= D pour H = 1 H Q+
Etat verrou, mémoire : Qn+1= Qn pour H= 0
D’où le tableau ci-contre avec ici la notation Q et Q+ pour changer… 0 Q
On n’exploite le plus souvent Q que pendant la phase verrou. 1 D
Existe en circuit intégré ou en composant pour logique programmable (4 ou 8 dans

un même boîtier), les Ck pouvant être commun.
Set
Il peut exister des entrées supplémentaires de mise à
8 8 Q
un et à zéro asynchrones, analogues à des entrées R et D 8D
S qui seraient nommées Clr et Set ou Clr et Set à niveau
Ck
Exemple de représentation externe :
Clr
On les nomme aussi « registres »

Limitations de ce type de circuits à horloge à niveau

Les montages suivants sont interdits :
• Création de registres à décalage par association synchrone en cascade. L’état à l’entrée de
la cascade se propage presque instantanément sur la sortie.
H
E1
E1 E2 E3 tP
D Q D Q
H H E2
E3 tP
H Réel !
Désiré
• Compteur 1 bit par rétroaction : 0 1 0 1 0 … Le montage oscille sans cesse très

rapidement, donc impossibilité de faire des compteurs !
H
D Q tP
Q désiré
H Q
H Q réel
Ces bistables à niveau sont encore utilisés, le mode transparent peut parfois etre
utile. Mais il est nécessaire de définir un nouveau circuit pour travailler
correctement en logique synchrone : la bascule à horloge à front.
1.2.4. Historiques bascules maître-esclave

On peut les citer pour l’histoire (elles datent presque du moyen age …). Elles permettaient
en associant deux bascules à niveau d’éviter les effets néfastes précédents.
Q
S S S Q
R R Maître R Esclave
Q
Q
H HM HE
Le niveau haut de H rend transparent le maître, le niveau bas l’esclave. Donc plus de mode
transparent. On peut cascader ces circuits et faire des rétroactions. Mais les entrées doivent
être stables durant tout le niveau haut pour éviter des aléas de prise en compte. Délicates à
exploiter. Abandonnées.

1.2.5. Bascules D à front

Ces bascules font l’acquisition de la donnée et réalisent la commande sur un front
d’horloge. Ce sont les bascules actuellement utilisées pour la conception en logique
séquentielle, et surtout en logique synchrone. Elles peuvent être actives sur le front
descendant ou sur le front montant.
D Q D Q
H Q H Q
Front montant Front descendant
D’un point de vue purement théorique (il ne s’agit pas du montage utilisé réellement),
on peut voir une bascule D commandée par un front montant de la manière suivante :
D s
H Q
H’
H Schéma
tPCk
De
principe
(Non réel)
H
Q
H
H’ r
tP Ck
En dosant de manière adéquate le temps de propagation tPCK de l’inverseur, on obtient en

H’ une impulsion juste assez large pour permettre le transfert de l’information D vers le latch
RS.
Set
Exemple : D
Circuit 74LS74 avec 4 bascules D, 4 entrées Q
Ck. Clr et Set t Clk commune. Ck
Q
D est une entrée a action synchrone de Ck. Clr
Clr et Set sont des entrées à action
asynchrone.
Equation : Avec Qn (ou Q) état avant le front

de Ck et Qn+1 ou Q+ l’état suivant :
Qn+1 = D ou Q+ = D
Table de vérité :
La combinaison Clr et Set à zéro est
évidemment à éviter.

Très important !
On s’aperçoit, et ce point est fondamental : dans une logique synchrone à front, on ne met
jamais l’horloge H dans les équations !
Applications simples, parfois utiles :

Exemple parmi d’autres :
Set
Mise à 1 sur front montant et à 0 sur niveau 1 D Q
haut : Ck
Mise à 1 Q
Clr Mise à 0
Mise à 1 sur niveau 0, mise à 0 sur front Mise à 1

Set
descendant
0 D Q
Mise à 0 Ck
Q
Clr
Ajout d’une entrée de MISE A ZERO SUYNCHRONE petit exercice !
Par un diagramme de Karnaugh compact : ClrSy

D’où Qn +1 = CLrSy.D directement (entrée D du montage) 0 D
Bascule : Qn +1 = d (d de la bascule utilisée).
1 0
On identifie : d = CLrSy. D
Par un simple raisonnement : pour mettre Q à zéro au Ck
suivant, il faut forcer D à 0, d’où l’usage d’une porte ET et d’un Tableau de Qn+1
(après l’événement Ck)
signal de mise à zéro actif à zéro CLrSy
ClrSy Set
ET d Montage ci-contre :
Q
D Avec signal de mise à
Ck zéro synchrone ajouté.
Ck Q
Clr
1.2.6. Bascules D à front et entrée de validation E

On veut ajouter une entrée de validation E, telle que :
E=0 Q conserve le même état quelque soit Ck et D, donc =Qn+1 = Qn
E=1 La bascule fonctionne normalement, donc recopie D au front de Ck : Qn+1 = D
Par un raisonnement simple : Il est aisé de comprendre qu’il suffit de prendre une bascule
avec d = ED + EQ
Par un diagramme de Karnaugh compact : E

D’où Qn +1 = E.D + E.Qn 0 Qn
Bascule : Qn +1 = d (d de la bascule utilisée).
1 D
On identifie : d = E.D + E.Qn
Tableau de Qn+1
(après l’événement Ck)

Equation précédente Schéma externe

Set Set
D
D d Q
Q E
E Ck
Q
Ck Ck Q Clr
Clr
N’existe pas en composant discret.
Existe en logique programmable.
1.2.7. Historiques et ‘Moyenâgeuses’ Bascules JK

Structure interne, obtenue à partir d’une Set
bascules D, avec un rebouclage et JK
avec quelques portes en plus. J JK Q
Schéma externe. Ck à front
K
Equation : Qn +1 = J .Qn + K .Qn Q
Clr
Table de vérité :
Cas important
Toujours active sur front évidemment, sinon le fonctionnement principal (qui le

différencie des bascules D, le « toggle » Q change d’état à chaque fois, serait instable et
idiot, on aurait au niveau 1 de Ck des basculements permanents très rapides !).
Intérêt principal : le cas « Toggle », la sortie change d’état à chaque coup d’horloge (si
J=K=1)
Application simple : une lampe que l’on allume et éteint en appuyant sur le même bouton.
Applications principale : compteur 1 bit 0,1,0,1,0,1 … et aussi le comptage binaire sous
ses différentes formes.
Mais n’existent pratiquement plus ni en composant discret ni pour logique programmable.
On peut en fait heureusement tout synthétiser à partir de bascules D à front.
1.2.8. Compteur 1 bit, bascule D montée en « Toggle »

H
D Q tP
Q
Ck Q

On note le petit retard entre les fronts montants de Ck et la sortie Q (Raison physique
évidente, ordre de grandeur quelques nanosecondes). On peut ne pas le représenter, mais le
faire apparaître évite souvent des erreurs de tracé de chronogrammes.
Applications bêtes :
Division par deux de fréquence ! Visible sur le dessin
Allumer et éteindre successivement par appui sur un bouton poussoir :
Vers diode électroluminescente ou
Bouton poussoir avec lampe (avec interface de puissance !)
anti-rebond à bascule RS D Q
Ck Q
Sinon, peu pratique, il manque une entrée de validation.
1.2.9. Compteur élémentaire 1 bits à validation

Il s’agira de l’élément de base des compteurs. Nous verrons cela un peu plus tard.
A chaque front actif de Ck, la sortie Q doit changer d’état ou rester inchangée.
Il faut donc un circuit à effet Toggle, munis d’une entrée de validation E (Enable)
Etude par un diagramme de karnaugh normal :

Deux entrées D et Q, donc 4 cases.
Etude par un diagramme de karnaugh Compact :

Une seule commande E donc 2 cases. C’est juste une simple E
table de vérité à une entrée. 0 Q
Si E = O Q reste inchangé au front de Ck
Si E = 1 Q change d’état au front de Ck, donc 1 Q
D’où Q + = E Q + E .Q = E ⊕Q Tableau de Q+
Bascule D : Q + = d
On identifié : d = E Q + E.Q = E ⊕ Q
D’où le câblage ci-dessous.
Set
On garde les entrées Clr et Set comme
entrées à action asynchrones.
E + d D Q
à front
Ck Q
Clr
Ce montage équivaut donc à celui qui Montage Obsolète :
était utilisé du temps des JK : Set
E
J JK Q
Ck à front
K Q
Clr

On peut facilement ajouter des portes pour obtenir une entrée de mise à zéro synchrone
ou (et) de chargement synchrone. On peut le faire en exercice avec une table de vérité ou
directement un diagramme de Karnaught compact à 2 entrées (E et Raz) ou 3 entrées (E,
Raz et Load)
- Pour seulement l’entrée supplémentaire de Raz synchrone, on obtiendrait :

On rappelle que dans une table de vérité compacte ou un diagramme de Karnaugh compact,
les entrées sont les vraies commandes, donc E et Raz, et on met à l’intérieur 0, 1, Q. On
choisit ici une remise à zéro active QUE si la bascule est validée.
Raz0 0 1 1
Raz Q 0
E 0 1 E 1 1 0
0 Q Q 0 0 1 1 0
1 Q 0 1 1 0 01 0 Et on sait que: Q+ = d
(Bascule D)
Q+ Q+
Karnaught Compact Karnaught complet
Avec l’un ou l’autre des diagrammes, on trouve d = Q E + Q.E.Raz (au lieu de
d = E Q + E.Q ). On voit bien l’intérêt du diagramme compact, plus simple à écrire !
- Remarque : l’entrée Raz synchrone peut aussi s’ajouter par le raisonnement « au

feeling » : une porte ET pour imposer 0.
On aurait alors : d = ( E Q + E .Q ).Raz = ( E ⊕ Q ).Raz
On n’a pas tout a fait la même équation car dans ce cas la remise à zéro se fait même si la
bascule n’est pas validée, donc le cahier des charges est un peu différent.
- Si on ajoute l’entrée Load synchrone:

Load 0
0 1 1 Si on simplifie en supposant un cas non utilisé
Raz (Chargement et Remise à zéro simultanée, et
E 0 1 1 0
0 Q Q Q Q Et: Q+ = d E actif)
1 Q 0 1- D (Bascule D) d = Q E + Q.E.Raz.Load + E.Load .D
On voit alors que Load est alors prioritaire sur
Raz.
Q+ Ce serait facile de faire l’inverse !, la fonction
Karnaught Compact serait à peine plus compliquée…
Un tableau de Karnaugh normal aurait eu 5 entrées (E, LOAD, Raz, D et Q) donc 25 =
32 cases !!!! D’où l’intérêt du diagramme « Compact ».
- Si on voulait une entrée load_asy Asynchrone, on aurait simplement :

D Load_asy Clr set Set = load _ asy. D
0 0 0 0 Clr = load _ asy.D
0 1 1 0
1 0 0 0
1 1 0 1
De nombreux circuits plus complexes (compteurs, registres à décalages, etc… sont

réalisés intérieurement à partir de ce circuit de base.

1.3. Registre à décalage Synchrone, bascules D à front en

cascade
Ce montage impossible à réaliser avec des bascules à niveau fonctionne heureusement avec
des bascules à front, on peut l’expliquer par les petits retards physiques entre Ck et Q.
H
ES d0 Q0 d1 Q2 d2 Q2 ES
tP
Ck Ck Ck
Q0
H Q1
Q2
Le 1 sur ES (entrée série) se décale régulièrement d’une bascule à chaque Ck.
Entrée Load de chargement parallèle synchrone (Montage tout simple et facile à

étudier, à placer sur chaque bascule, au niveau de chaque rond pointillé).
D0 D1 D2
Load
ES d0 Q0 d1 Q2 d2 Q2
Ck Ck Ck
H
Application : avec 8 bascules, chargement d’un octet en parallèle, décalage et sortie en série
sur un fil de chaque bit (principe de base des liaisons série entre ordinateur et imprimante
série).
Etude par un diagramme de Karnaugh Compact : Load Qi+
Une seule commande Load donc 2 cases. C’est donc juste une
simple table de vérité à une entrée. 0 Qi-1
Si Load = O Décalage ; Qi+ = Qi-1
Si Load= 1 Chargement de Di, donc Qi+ = Di 1 Di
di = Qi +1 = Load .Qi −1 + Load .Di
D’où le câblage évident non fourni ici.
Entrée de remise à zéro synchrone (agissant au niveau des entrées di). Simple porte ET
pour forcer à zéro les di.
Entrées à action asynchrone :
Soit de remise à zéro asynchrone (agissant au niveau des Clr des bascules), ainsi
qu’une mise à zéro automatique à la mise sous tension par réseau RC (voir la technique
plus loin paragraphe 3.4.1 et 3.4.1).
Soit de chargement asynchrone d’une valeur fixe ou non (agissant alors sur les
entrés asynchrones Clr et Set des bascules).
Autres possibilités : Entrée de validation du décalage E, une entrée M pour sélectionner
un décalage droite ou un décalage gauche, etc, etc…

2. COMPTEURS BINAIRES ASTYNCHRONES

La conception est presque évidente à partir de bascules D à front montées en ‘Toggle‘,
avec une simple mise en cascade.
Pour une horloge Ck de fréquence F :
Le petit poids Q0 change une fois sur deux (Fréquence F/2)
Q1 change une fois sur 4 (Fréquence F/4)
Les basculements doivent s’effectuer sur front descendant de la bascule précédente,
sinon décomptage ..)
Pr Pr Pr Pr
D Q D Q D Q D Q
Ck Ck Ck Ck
Cl Q Cl Q Cl Q Cl Q
Ck
E Q0 Q1 Q2 Q3
(validation éventuelle)
Montage HORRIBLE en logique
Synchrone ! ! !
Mais ici passable …
Q3 Q2 Q1 Q0 état On peut en réaliser, mais on en
0 0 0 0 0 trouve dans le commerce tout prêt, à
0 0 0 1 1 12, 14 bits et plus.
0 0 1 0 2
0 0 1 1 3
Ils sont pratiques pour faire juste
0 1 0 0 4 une division de fréquence, mais ils
0 1 0 1 5 ont les défauts de l’asynchrone. Eviter
0 1 1 0 6 donc le plus possible de les utiliser
0 1 1 1 7 autrement !
1 0 0 0 8
1 0 0 1 9
1 0 1 0 10
1 0 1 1 11
1 1 0 0 12
1 1 0 1 13
1 1 1 0 14
1 1 1 1 15
0 0 0 0 retour à Zéro etc ...
Avantage :
Simplicité !
On ajoute une entrée E de validation générale aisément :
- En utilisant une bascule Q0 avec entrée de validation
- Ou encore plus simple (Cf schéma) et pas trop affreux puisque l’on est en
asynchrone, en attaquant le montage par un ET entre E et Ck.
Inconvénient :
Les Temps de retard entre Ck et Q s'ajoutent, un dessin en HF montre alors des états
parasites de commutation, de durée très court en absolu, mais qui peuvent être parfois très
gênants :

Tp Ck toQ
Ck
Tp Ck toQ
Q0
Q1
Q2
1 2 3 2 0 4 5 6
N° 0 0
d'états
états parasites
transitoires
Si on monte en fréquence, les "états de commutation " peuvent prendre de plus en plus
de l'importance !
- Si on n'effectue qu'une division de fréquence, ils ne sont pas du tout gênants, et on
obtient la structure de diviseur de fréquence la plus rapide:
la Fmax de l'ensemble = Fmax de la bascule Q0, de poids faible.
- Si on veut exploiter les états (par une fonction logique décodant un état), les états de
commutation peuvent être néfastes !, même en basse fréquence, ils sont courts mais
existent, en HF ils peuvent même devenir prépondérant pour un compteur sur un plus grand
nombre de bits. Il faudra surtout utiliser ces états quand ils sont stabilisés. (on peut par
exemple compter sur un front et échantillonner en plus par une bascule D active sur l'autre
front, dans le cas ou la somme des ‘Temps ck à Q’ ne dépasse pas TCk/2).
Si on augmente encore la fréquence, et pour 4 bits on peut obtenir:
L'état normal 8 se retrouve de

CK durée très courte.
Pour des compteur sur plus de
bits, des états peuvent même
Q0
disparaître !
- Pas de problème pour une
Q1
simple division de fréquence.
-Mais impossible d'exploiter
les états !
Q2
Q3
7 6 4 0 8
ETATS VOULUS
états parasites

3. SYSTEMES SYNCHRONES : ETUDE GLOBALE

PAR LES MACHINES D’ETAT
3.1. Généralités : Les deux machines
Dans ce chapitre, nous allons examiner rapidement le type le plus important de circuit
séquentiel : la machine d’état. Une machine d’état est ainsi appelée car la logique séquentielle
qui l’implémente ne peut prendre qu’un nombre fini d’états possibles. Il existe deux familles
de machines d’état :
• la machine de Moore. Les sorties dépendent seulement de l’état présent n. Un circuit
combinatoire d’entrée détermine, à partir des entrées et de l’état présent n, les entrées des
bascules (JK ou D principalement) du registre d’état permettant de réaliser l’état futur n+1.
Les sorties sont une combinaison logique de la sortie du registre d’état et change de
manière synchrone avec le front actif de l’horloge.
Logique Logique
Entrées Registre Sorties
combinatoire combinatoire
Xi d’état Zk
déterminant de sortie
(bascules)
l’état suivant
(entrées des
bascules)
horloge
Contre-réaction d’états
• la machine de Mealy. Les sorties dépendent de l’état présent n mais aussi de la valeur des
entrées. La sortie peut donc changer de manière asynchrone en fonction de la valeur des
entrées. Il existe une variante synchrone de la machine de Mealy avec un registre placé sur
les sorties et activé par l’horloge. Toutefois, la machine de Moore est plus adaptée pour
réaliser une machine d’état totalement synchrone.
Entrées Sorties
Logique
Xi Zk
combinatoire
déterminant
l’état suivant
Registre
et les sorties
d’état
(bascules)
horloge
Contre-réaction d’états
3.2. Générateurs de petites séquences synchrones

quelconques
Les machines d’états servent à réaliser des automatismes complexes (contrôleur de feux
tricolores par exemple) et nous intéressent un peu moins, nous en verrons juste un exemple
par la suite.

Nous étudierons donc surtout un cas particulier de machine d’état : le générateur de

séquence synchrone. Il s’agit d’un cas simplifié de machine d’état de Moore dans laquelle :
• les sorties et les états internes sont identiques.
• la séquence est non-programmable,
• il n’y a pas d’entrées (il y a éventuellement des entrées de chargement, ou de remise à zéro,
mais elles n’interviennent pas dans le déroulement de la séquence de base.
Logique
combinatoire
Registre
déterminant Sorties
d’état
l’état suivant Qk
(bascules)
(entrées des
bascules)
horloge
Les générateurs de séquences synchrones sont composés de n bascules synchronisées par

une horloge qui est la seule commande extérieure du circuit.
Le cycle comporte ainsi au maximum 2n états qui se succèdent toujours dans le même
ordre.
On débute l’étude par le codage des états. Des séquences usuelles sont présentées dans le
tableau ci-dessous (sur 3 bits par exemple). Pour répondre à un besoin spécifique, tout autre
combinaison des sorties est possible et peut constituer un cycle de m états avec m ≤ 2n.
compteur cycle complet compteur cycle incomplet

(modulo 8)
binaire naturel binaire binaire naturel ou quelconque

quelconque
Compteur Décompteur gray Modulo 5 Johnson 1 parmi 3 pseudo-
aléatoire
incomplet
Q2 Q1 Q0 Q2 Q1 Q0 Q2 Q1 Q0 Q2 Q1 Q0 Q2 Q1 Q0 Q2 Q1 Q0 Q2 Q1 Q0
0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 1 0 0 1
0 0 1 1 1 0 0 0 1 0 0 1 0 0 1 0 1 0 1 0 0
0 1 0 1 0 1 0 1 1 0 1 0 0 1 1 1 0 0 1 1 0
0 1 1 1 0 0 0 1 0 0 1 1 1 1 1 1 1 1
1 0 0 0 1 1 1 1 0 1 0 0 1 1 0 0 1 1
1 0 1 0 1 0 1 1 1 1 0 0 1 0 1
1 1 0 0 0 1 1 0 1 0 1 0
1 1 1 0 0 0 1 0 0
Cette méthode des machines d’états ne sert en fait que pour des touts petits compteurs, ou
bien pour des séquences quelconques. Pour des compteurs en binaire naturel, complet ou
incomplet (tel que le compteur Décimal Codé Binaire), il sera bien plus judicieux de partir du
compteur élémentaire un bit et de généraliser.

3.3. Premier exemple: compteur par 3 : 1,2,3,1,2,3

On veut réaliser un compteur par 3, comptant ici 1,2,3, 1,2,3, 1,2,3 etc :
1) Table de vérité ( soit Q+ la valeur de Q désirée après le Ck)

N° état Q1 Q0 Q1+ ? Q0+ ? 1
0 0 0 - -
1 0 1 1 0 3
2 1 0 1 1 2
3 1 1 0 1 0
2) Diagramme de Karnaugh de Q0+ et de Q1+, et expressions simplifiées au maximum

(en tenant compte du cas inutilisé).
Q0 Q0
D1 = Q1+ = Q0 + Q1 = Q1.Q0 Q1 0 1 Q1 0 1
0 - 1 0 -
D0 = Q0+ = Q1
1 1 1 1
1
Q1+ Q0+
3) Démarrage et état 0 ?
Une simplification au maximum peut poser des problèmes de démarrage : en effet il faut
vérifier ce qui se passe si le circuit se trouvet par hasard (démarrage ou parasite) dans
l’état non utilisé ici Q1Q0 = 00.
Ici : on voit sur le diagramme que l’on a choisi pour simplifier Q1+Q0+ = 10. Donc
l’état 2. On ne reste donc pas bloqué dans l’état 0.
Le compteur est dit « self starting ».
Si besoin, on peut ajouter une initialisation à par exemple 01 (état 1) à la mise sous
tension (par petit réseau RC). Cette partie est vue autre part. Mais ce n’est pas forcément
utile dans ce cas.
4) Montage
1
3
2
4 10
1 ~1PR Q1 1 ~2PR Q0
2 5 12 9
1D 1Q 2D 2Q
CK
3 6 11 8
~1Q ~2Q
1 13
1 ~1CLR 1 ~2CLR
5) Autres exemples de séquences par 3

On pourrait tout aussi facilement faire les séquence 0,1,2,0,1,2…. Ou bien 3,2,1,3,2,1 ….
Ou encore 0,1,2 et autoblocage.

3.4. Deuxième exemple: Les registres à décalages bouclés

C’est une séquence particulière où seul le premier bit change selon le type de séquence, les
autres ne sont que des décalages du premier.
On code les états. Si la séquence peut se résumer en un simple décalage temporel et une
entrée série de 1 ou de 0, alors il y a une solution évidente à base de bascules D d’équation
Qn+1 = D.
Par exemple, parmi les séquences précédentes, les compteurs Johnson et 1 parmi 3 peuvent
être réalisés ainsi à partir de bascules D. On notera ici Qn+1 = Q+ pour faciliter les écritures.
3.4.1. Le compteur 1 parmi 3, ou « chenillard …. »

1) Montage simple « au feeling »
Pour un cas simple comme celui-ci, une étude au Feeling est tout à fait possible, sans parler
de machine d’état, en connaissant juste le principe des registres à décalage par mise en
cascade de bascules D.
On veut faire décaler un motif (ici 100) avec rotation de tout l’ensemble : suite
100 010 001 100 010 001 etc…
On sait qu’une bascule D recopie D vers Q au Ck, le montage est immédiat, sans nécessiter
en fait une étude plus approfondie !
s
D0 Q0 D1 Q1 D2 Q2
H H H Q2
r r
H
R initialisation C
Vcc
masse
Il faut évidemment charger à la mise sous tension le motif (ici 100). Ceci peut se faire
simplement par le réseau RC ci-dessus : la ligne Initialisation est active à 0 un certain temps
dès la mise sous tension, puis inactive à 1 ensuite. Il suffit pour cela que RC >> Temps de
montée de Vcc. Un petit dessin montrant les chronogrammes serait facile à faire (voir les
chronogrammes vers la fin de ce poly, chapitre : Initialisation d’un système à la mise sous
tension).
On peut faire tourner d’autres motifs : 110 011 101 110 011 101 il suffit de câbler
différemment la ligne Initialisation sur les bascules.
Rien ne se passe si les bascules sont à 0 (initialement ou accidentellement sur un parasite.

On a la suite : 000 000 000 000 ………
Avantage de ce montage et de l’initialisation par RC: système simple
Inconvénient : Un parasite modifiant un contenu peut alors modifier le

fonctionnement : changement de motif ou blocage apparent tout à zéro.
Pour le relancer sans refaire une mise sous tension, on pourrait ajouter une ligne
supplémentaire d’initialisation avec par exemple un bouton poussoir (Bon exercice à faire :
avec un interrupteur, une résistance et une porte ET pour faire une fonction OU en logique
négative).

2) Application simples : Q0
Horloges décalées à temps jointifs,
chenillards en animation de vitrines. Q1
Q2
3) Etude plus systématique par machines d’état. Systèmes « self starting »

Q0 Q1 Q2
1 0 0 Q2 0 0 1 1
0 1 0
0 0 1 Q0
Q1 0 1 1 0 Q0+
1 0 0 0 - 0 - 1 Karnaught
On étudie Q0, le reste suit par complet
décalage droite. D’où deux 0 et un 1
1 0 - -1 -
seulement dans le tableau.
Le reste indifférent (non utilisé).
D’où si on simplifie au maximum : Cycle principal (4,2,1)
Q0+ = Q2 4 2 1
Comme Q0+ = D donc D = Q2
On retrouve le montage précédent.
Si on étudie maintenant les cinq cas Cycle secondaire (6,3,5) Blocage 0 et 7
indéterminés du tableau (on a mis du fait 6 3 5 0 7
de la simplification deux 0 et trois 1), on
obtient le résultat ci-contre.
On retrouve les défauts précédents.
Realisation d’un ”self starting system”

On a vu que la simplification au maximum donnait le montage initial obtenu “au Feeling”
L’étude plus approfondie va nous permettre de faire ce que l’on veut des inutilisés afin de
forcer le démarrage et retourner automatiquement vers le bon cycle.
Il y a plusieurs solutions, on cherche toutefois un câblage relativement simple, et donc
toujours des regroupements par Karnaugh.
On évite déjà le blocage à 0 en Q2 0 0 1 1

mettant 1 en 000 (000 -> 100).
A partir de 111 un 0 fait passer à 001 Q0
Q1 0 1 1 0 Q0+
dans le cycle de base. 0 1 0 - 1 Karnaught
A partir de 110 un 0 fait passer à 011 complet
dans le cycle de base.
1 0 0 01 -
Cycle principal (4,2,1)

A priori l’équation la plus simple : 0
4 2 1
Q0+ = D0 = Q 2Q 0 + Q1.Q 0
Avec le cycle principal et tous les cas
de démarrage ci-contre. 7 3 5 6

On vous laisse le soin de dessiner ce nouveau montage avec quelques portes (montage
avec ET et OU, ou bien que des NAND), évidemment le RC ne sert plus à rien !
Avantage : en cas de parasite, on revient toujours vers le cycle normal.
3.4.2. Le compteur Johnson

Il s’agit d’un autre type de compteur qui permet d’obtenir plusieurs signaux décalés dans le
temps. La séquence des états à été vue précédemment.
Ayant observé le décalage (ici de la droite vers la gauche), il suffit d’étudier Q0+.
Q2 Q1 Q0 Q0+ = D0
0 0 0 1 Cycle principal
0 0 1 1 0 1 3 7 6 4
0 1 1 1
1 1 1 0 5 2 non utilisées
1 1 0 0
1 0 0 0
Deux combinaisons sont inutilisées donc le Q1 Q0

diagramme de Karnaugh permet de simplifier
Q2 00 01 11 10
très facilement :
On obtient : D 0 = Q 2 0 1 1 1 X
D0
1 0 X 0 0
D0 Q0 D1 Q1 D2 Q2
H H H Q2
H
H
Cycle principal
0 1 3 7 6 4
Q0
5 2 avec ce câblage simplifié

Q1
Cycle Secondaire
Q2
En examinant les deux états inutilisés, pour lesquels on a choisi finalement 0 pour l’état
5 et 1 pour l’état 2, on vérifie facilement l’existence d’un cycle secondaire parasite
(5,2,5,2,5,2 …). Si au démarrage ou bien accidentellement par un fort parasite le circuit se
trouve dans l’état 2 ou 5, il ne reviendra pas dans le cycle principal.

Remède N°1 : Initialisation à la mise sous tension

Pour démarrer tout de suite sûrement le bon cycle, il faut par exemple mettre à la mise
sous tension toutes les bascules à 0 (démarrage dans l’état 0), on pourrait aussi démarrer
dans l’état 1 ou 3 ou 7 …
On se sert alors des entrées asynchrone de mise à 1 ou à 0, et comme nous l’avons déjà
vu, d’un petit réseau RC (constante de temps ¼ à ½ seconde permet de maintenir un niveau
actif, ici zéro, le temps d’établissement des tensions et des horloges.
D0 Q0 D1 Q1 D2 Q2
H H H Q2
Clr Clr Clr
H
R C
Vcc
masse
Remède 2 : Self Starting Counter

On complique un peu le montage (plusieurs possibilités) pour qu’un départ sur 2 ou 5
fasse revenir toujours dans le cycle principal.
Il suffit de mettre 1 dans l’état 5 :
Alors 101 (5) donne 011 (3) donc cycle principal.
Et 010 (2) donne 101 (5 comme précédemment) puis 011 (donc 3 du cycle principal).
Nouveau D0: D 0 = Q 2 .Q1 + Q 2.Q0 d’ou montage avec que des NAND :
Q1
Q0 D0 Q0 D1 Q1 D2 Q2
Q2
H H H
H
Avantage : même si un très fort parasite le fait passer accidentellement à 2 ou 5, il
revient toujours en deux périodes maxi de Ck dans la boucle principale.
Cycle principal
0 1 3 7 6 4
2 5
Intérêt de ce compteur: On obtient des horloges de mêmes périodes, mais décalées en
phase. Et il ne peut pas y avoir d’impulsions parasites sur un signal qui serait formé
par une combinaison de ces sorties car il n’y en a qu’une qui change à chaque coup
d’horloge.

3.5. Diagrammes d’états

Lorsque le déroulement de la séquence dépend de variables extérieurs, on fait appel aux
diagrammes d’états. On est dans le domaine plutôt de l’Automatisme (ressemblance avec les
Grafcets), mais nous allons voir ici une application simple en électronique
Exemple : création d’un signal à 3 niveaux en transmission numérique.
Dans certaines transmissions numériques, les informations devant être transmises en série
(un bit à la fois) sont transformées en un code S à 3 niveau (afin de supprimer la composante
continue : valeur moyenne nulle).
Din est le bit à CK

transmettre à la cadence
de l’horloge Ck.
Din = 0 S = 0v Din
Din = 1 S = +5v ou -5v

en alternance.
S
Réalisation : le système doit se souvenir du signe de la dernière impulsion, il y a trois

niveaux différents donc le système à au moins 3 états.
Q1 Q2 S
On utilisera donc deux bascules D de sorties Q1 et Q2. 0 1 -5v
Quatre états. 1 0 +5v
0 0 0v
1 1 0v
La sortie S s’obtiendra tout simplement par un
soustracteur analogique (facile à faire avec un ampli
opérationnel et 4 résistances). Vs = G(v1-v2) avec G =
Q1
R2/R1 +
S
R2
Q2 -
R1
Q2 (v2)
R1
S
Q1 (v1)
R2
Etant donnée que la succession des états est fonction de variables externes (ici une seule :
Din), la méthode des diagrammes d’états (ressemblant un peu au Grafcet), est très pratique.

Diagramme d’états
La table de vérité de Q1+,
Q2+ en fonction de Din, Q1, Q2 Din 1 0 Din
aurait été bien moins commode S = +5v
à écrire, ici on voit bien mieux
toutes les transitions possibles et Din 0 0 Din 1 1 Din
l’évolution de cette machine S = 0v Din S = 0v
synchrone.
Les deux états (00 et 11)
donnant S = 0v permettent de 0 1
différencier un 0 après un S = -5v Din
niveau +5, d’un 0 après un Din
niveau -5 pour respecter
l’alternance.
Diagrammes de Karnaugh de Q1+ et Q2+ (Q1 et Q2 dans cet ordre dans les
« bulles du diagramme d’état).
Q2 0 1 1 0 Q2 0 1 1 0
Q1 0 0 1 1 Q1 0 0 1 1
Din Din
0 1 1 0 1 1
Q1+ Q2+
1 1 1 1 1 1
Equations : D1 = Q1+ = Q2 et D2 = Q2+ =

Q 2.Din + Q 2.Din = Q 2 ⊕ Din
Montage :
VCC 5V
U1A U1B
4 10
~1PR ~2PR
2 5 12 9
1D 1Q 2D 2Q Q2
3 6 11 8
Vers soustracteur
Q1 a ampli opérationnel
~1Q ~2Q
1 13
~1CLR ~2CLR
CK
74LS74D 74LS74D
U2A
Din
1
3
2
74LS86D

4. COMPTEURS BINAIRES SYNCHRONES

4.1. Méthode d’étude, par machines d’états (les Qi+) ?
Cette méthode n’est pas du tout indiquée ici, car on ne peut pas généraliser à N bits,
chaque cas étant un cas particulier !
Cette méthode par les Q+ (donc en machine d’état) est, rappelons le, réservée à de petits
compteurs à séquence quelconque (exemple 0,1,2 ou 1,2,3 ou autres).
4.2. Compteur 3 bits synchrone par mise en cascade de

compteurs élémentaires 1 bit
Set
Nous utiliserons ici ce que nous avons étudié
précédemment :
l’élément de base d’un compteur synchrone : D
E + d Q
(bascule D montée en « Toggle », et entrée de à front
validation E), ou nommé « compteur 1 bit » H Q
Le cas particulier de ces compteurs binaires s’y
prêtent en effet très bien.
Clr
Ei est la appelée aussi « fonction de basculement de Qi », en effet Ei à 1 signifie un
changement d’état de Qi au coup d’horloge suivant.
Q2 Q1 Q0 E2 E1 E0
0 0 0 0 0 1
0 0 1 0 1 1
0 1 0 0 0 1
0 1 1 1 1 1
1 0 0 0 0 1
1 0 1 0 1 1
1 1 0 0 0 1
1 1 1 1 1 1
Diagramme de Karnaugh inutile, on lit
E0 = 1
E1 = Q0 colonnes identiques !
E2 = Q 2.Q1.Q0 + Q 2.Q1.Q0 = Q1.Q0 facile à simplifier !
On voit aussi directement qu’une bascule change d’état au coup de Ck suivant lorsque
touts les bascules précédentes sont à 1, c’est en fait le principe même de tout comptage, et
d’une retenue vers le poids suivant !
Pour 4 bits, on aurait E3 = E2.E1.E0 Donc très facile à généraliser à n bits !

Pour 5 bits E4 = E3.E2.E1.E0
On voit que ici, le montage étant synchrone, on prépare un circuit pour le Ck suivant. Le
signal de retenue est donc à chaque fois le dernier état, correspondant à tous les bits de poids
inférieur à 1.

ATTENTION Compteurs 1 bit

Montage correct si ici toujours 1
Sinon, voir ci-dessous !
1 Q0 E1 Q1 E2 Q2
E0
H H H
Poids faible Q0 Q1 Q2
On peut ajouter une entrée E de validation générale de ce compteur 3 bits, entrée
nécessaire si on veut ensuite mettre en cascade de tels compteurs, et d’une manière générale
travailler en logique synchrone.
Attention E doit empêcher de compter tous les poids, sinon disfonctionnement facile à
comprendre : à chaque fois que l’on inhibe le compteur avec Q0 = 1 ou bien avec Q1Q0 = 1
la bascule suivante (Q1 dans le premier cas, Q2 dans le second) compte alors les unités !
Validation générale Q1 Q2
Q0 E1 E2
E E0
H H H
4.3. Compteurs Binaires Synchrones, N bits (modulo 2N)

Compteurs binaire naturel à cycle complet N bits : 2N états de 0 à 2N-1
On suit le code binaire naturel (0,1,2,3,4,5,6 …..). Le cycle et complet.
On dit aussi modulo 2N.
On va généraliser le compteur 3 bits synchrone précédent :
Ei = ∏k =0 Qk
i −1
Condition de basculement de Qi :
Exemple, Compteur 4 bits :
Q0
Q1
Q2
Validation Q3
générale Q0 E1 Q1 E2 Q2 Q3
E0 E3
E
H H H H
H
Retenue
état 15
Poids faible Q0 Q1 Q2 Q3
Grâce à la validation générale et la retenue en synchrone état 15 (et non 16, on anticipe
toujours en conception synchrone, on valide un circuit pour qu’il réagisse au coup d’horloge
suivant), on pourra mettre en cascade synchrone (même horloge) ces compteurs 4 bits pour
obtenir 8, 12, 16 bits…. Nous verrons ceci plus loin.

Avantages des compteurs synchrones:

Pas d'états parasites: Il y a juste un décalage constant entre Ck et les sorties (Tp Ck to
Q), les états ont la même durée.
Tp Ck to Q
Ck
Q0
Q1
Q2
1 2 3 4 5 6
N°
d'états
Inconvénients par rapport aux simples compteurs asynchrones :
- Plus de composants.
- Pour une simple division de fréquence par 2n, ils sont moins performant en fréquence
max de fonctionnement, et consomment plus. Ceci est un peu intuitif :
Dans un compteur asynchrone, il suffit seulement que la première bascule travaille à Fmax,
les autres fréquences étant F/2, F/4 ….
Toutes ces études Fmax, consommations …, seront vues dans une autre partie du cours.

5. COMPTEURS BINAIRE ET DECIMAL CODE

BINAIRE
5.1. Généralités
BINAIRE NATUREL
Compteurs binaire naturel à cycle complet N bits : 2N états de 0 à 2N-1
On suit le code binaire naturel Le cycle et complet.
On dit aussi modulo 2N.
Exemple pour 4 bits : 16 états de 0 à 15, donc modulo 16
Equation de la retenue : état15 . Validation
Exemple pour 8 bits : 256 états de 0 à 255, donc modulo 256
Equation de la retenue : état255 . Validation
DCB : Décimal Codé Binaire

Chaque chiffre décimal est codé en binaire.
4 bits par chiffre.
Pour 4 bits (1 chiffre) : 10 états de 0 à 9 (compteur cycle incomplet), donc modulo 10
Equation de la Retenue : état9 . Validation
Pour 8 bits (2 chiffres) : 100 états de 00 à 99, modulo 100
Equation de la Retenue : état99 . Validation
Pour 1 chiffre, ils existent tout fait (composants discrets ou programmables).
Intérêt : on voit tout de suite : Unités, dizaines, centaines. D’où câblage direct possible
d’afficheur 7 segments et lecture décimale.
Inconvénient : un peu moins rapide et plus complexe.
On verra plus loin comment les réaliser à partir de compteurs binaires (par rupture de
séquence normale et remise à zéro).
Brochage des compteurs 4 bits de base LS16(0 à 3) ou HC16(0 à 3).

Ces circuits existent encore un peu en tant que circuits physiques, mais ce sont surtout
actuellement des « composants logiciel de base » pour la logique programmable (à des
variantes près).
74LS160 DCB, Clear Asynchrone modulo 10, états de 0 à 9 (0000 à 1001)

74LS162 DCB, Clear Synchrone modulo 10, états de 0 à 9 (0000 à 1001)
74LS161 Binaire, Clear Asynchrone modulo 16, états de 0 à 15 (0000 à 1111)
74LS163 Binaire, Clear Synchrone modulo 16, états de 0 à 15 (0000 à 1111
QD, QC, QB, QA Sorties du compteurs

ENP et ENT Enable : Validations du compteur (les deux
doivent être à 1)
CLR Remise à zéro
LOAD Chargement parallèle
D, C, B, A Valeurs à charger en parallèle
RCO Ripple Carry Output : Retenue (dernier état)
Vcc +5v GND masse

Autres exemples de compteurs, nombre d’états :
1) 3 compteurs binaire 4 bits en cascade

12 bits, donc 212 = 4096 états de 0 à 4095 (000 à FFF en hexa). Modulo 4096.
2) 3 compteurs 4 bits DCB en cascade

12 Bits DCB = 3 chiffres décimaux. Donc 103 = 1000 états de 0 à 999
3) On veut compter de 0 à presque 106 (999999)
En binaire il faut 2n >=106. Donc n >=6log(10)/log(2) = 6/log(2) = 19,93. Il faut 20
bits.
En DCB, 9 chiffres décimaux, donc 6*4 = 24 bits.
4) Compteur 10 bits :
Compteur binaire : 1024 états de 0 à 1023.
Compteur DCB : -- ---- ---- donc deux chiffres complets pour les unités et
dizaines. Deux bits seulement pour les centaines. Donc 400 états de 0 à 399.
5.2. Chronogrammes de compteurs 4 bits
5.2.1. Compteur Binaire Naturel

QA
0 1 2 15
QB
QC
QD
RCO
Ck
Il y a donc 24 = 16 états, de 0 à 15. Compteur dit Modulo 16.

On obtient le modulo du compteur (le signal de fréquence F/16) évidemment sur le poids
fort : QD
Le signal de retenue correspond au dernier état.
On sait que RCO = Dernier_Etat ET Validation.
Donc ici : RCO = QD.QB.QC.QA.Ent.Ent
Si F est la fréquence de l’horloge, on a évidemment ici division par deux de la fréquence

à chaque bit : Les fréquences sur QA, QB, QC, QD sont donc F/2 , F/4, F/8, F/16
Ces signaux sont tous carrés (même durée au niveau haut et au niveau bas).
Attention, ceci n’est valable QUE POUR DES COMPTEURS BINAIRES A CYCLE
COMPLET (2n états).

5.2.2. Compteur 4 bits, DCB
QA
0 1 2 9
QB
QC
QD
RCO
Ck
C’est un compteur binaire nommé à CYCLE INCOMPLET.

Il possède seulement 10 états de 0 à 9. Le Compteur est dit Modulo 10.
On obtient le modulo du compteur (ici fréquence F/10) évidemment sur le poids fort :
QD, et ceci est une règle générale :
On obtient toujours le MODULO d’un compteur à cycle incomplet sur son POIDS
FORT ACTIF. (actif, car il pourrait y avoir dans le cas général des bits de poids forts restant
à zéro !).
Etude des fréquences des bits inférieurs :

ATTENTION : on n’a plus la succession F/2, F/4, … !!! Chaque cas est un cas particulier,
il faut regarder l’allure des signaux générés.
Pour obtenir une VRAIE FREQUENCE, il faut obligatoirement une alternance bien
régulière de fronts montants et descendants.
Ce n’est plus le cas ici pour tous les signaux :

Qd Qc Qb Qa états
Pour QA : alternance régulière 0 1 0 1 0 1 0 1 0 1 donc F/2 0 0 0 0 0
Pour QB : 0011001100 0011001100 il y a donc de temps 0 0 0 1 1
rupture du rythme (voir aussi les chronogrammes). Ce n’est 0 0 1 0 2
donc pas une vraie fréquence. Un fréquencemètre numérique 0 0 1 1 3
fournirait pourtant une sorte de F/5 car il compte le nombre de 0 1 0 0 4
fronts montant par seconde qui est fixe (ici 2 pour 10 Ck). 0 1 0 1 5
Pour QC : 0000111100 0000111100 0000111100 0 1 1 0 6
L’alternance des front montant est régulière : F/10. 0 1 1 1 7
Pour QD : sans hésitation F/10 (c’est poids fort actif). Ce 1 0 0 0 8
qui se voit aussi très bien sur le chrono et la suite des états : 1 0 0 1 9
00000000110000000011 Le suivant retour à 0

Le signal de retenue correspond toujours au dernier état (RCO = Dernier_Etat ET

Validation). Donc ici : RCO = QD.QC.QB.QA.Ent.Enp
Attention : on pourrait théoriquement obtenir le modulo du compteur sur ce signal de

retenue. Mais c’est TOTALEMENT DECONSEILLE et même INTERDIT DANS LE CAS
GENERAL: il existe en effet très fréquemment des impulsions parasites sur les sorties des
fonctions combinatoires (nommés aléas de commutation). Cette partie sera étudiée dans un
autre document).

6. TECHNIQUES DE MISE EN CASCADE DE

COMPTEURS
6.1. Mise en cascade série ou asynchrone

Le bit de poids fort sert d’horloge pour le compteur suivant (attention au front actif si on
veut se servir des états : il faut l’inverser pour un front montant actif, sinon peu importe en
simple division de fréquences !).
Surtout utilisé actuellement dans le cas de plusieurs diviseurs de fréquences successifs.
Exemple : création à partir d’une référence à Quartz de l’horloge de base de 1Hz pour un
chronomètre à la seconde près, ou de 100Hz pour un chronomètre au centième de secondes.
Si on part d’un quartz à 32768 Hz ou 3,2768 MHz (cas classiques des montres
numériques), une division par 32768 donne respectivement 1Hz ou 100Hz (compteur binaire
15 bits).
Sinon cette conception est vraiment obsolète de nos jours !
6.2. Mise en cascade, synchrone

6.2.1. Deux compteurs Binaires ou DCB de 4 bits
Méthode classique :
Horloges ensembles.
Retenue de chaque compteur validant le compteur de poids immédiatement
supérieur.
Evidemment les CLR (et LOAD) ensembles si même type d’action sur chaque
compteur : synchrone ou asynchrone !!!! On ne peut évidemment mélanger les deux.
Horloge Ck
Ck Ck
EP
EP
MSB RCO LSB validation générale
ET ET
Q7 Q0
Le compteur reste ici totalement synchrone. La sortie RCO (Ripple Carry Output) valide
(sur son dernier état) le compteur des poids forts pour le coup d'horloge suivant.
L’entrée ET_EP du compteur LSB peut servir de validation générale, en effet, comme
RCO contient l’une des validations (ET) le fonctionnement est correct et le compteur MSB se
bloquera même si le LSB est arrêté sur son dernier état.
Remarque : Il y a en réalité une petite distinction entre ET et EP, et un câblage judicieux
peut accroître la vitesse avec une propagation plus rapide des retenues. Non étudié ici.
Exemples :
Avec 2 compteurs 4 bits Binaire, on obtient un compteur de 0 à 255, modulo 256.
Avec 2 compteurs 4 bits DCB, on obtient directement un compteur de 0 à 99, modulo
100.

6.2.2. Ajouter un bit ou plus à un compteur quelconque

Il suffit d’ajouter un ou deux compteurs élémentaires 1 bit. Toujours la même méthode ;
retenue vers validation. Horloges ensembles.
Exemple : compteur 5 bits :
10 ENP
~1PR
1 ~LOAD
9 ENT
7 D
6 C
5 B
4 A
3
2 ~CLR
1 2
3 5
2 1D 1Q
CLK
3 6
~1Q
RCO
QB
QA
QC
QD
1
~1CLR
Ck
12
13
14
15
11
Q4 Q3 Q2 Q1 Q0
Le CLR de la bascule est évidemment asynchrone. On ne peut donc le relier directement
au CLR du compteur 4 bits que si celui-ci l’est aussi !
Pour le LOAD , c’est plus complexe. Non étudié ici.

7. COMPTEURS BINAIRE OU DCB A CYCLE

INCOMPLETS
7.1. Principe : compteur modulo M
Une étude directe en machine d’état n’est pratique que pour des touts petits compteurs ou
des suites quelconque.
Sinon :
On prend au départ un compteur Binaire ou DCB de modulo 2n ou 10n > M

On détecte l’état M-1
On commande alors une remise à zéro Synchrone au Ck suivant.
Il faut bien toujours détecter l’état M-1 pour préparer le circuit à repasser à zéro au coup
de Ck suivant. Bannir toute remise à zéro asynchrone qui pénalise en vitesse et est sujet à trop
d’aléas et de parasites.
Une détection incomplète de l’état M-1 est possible et même souhaitable (plus simple),
elle consiste à ne détecter que les bits à 1. En effet, comme on part de 0, la première fois ou
ces bits sont à 1 correspond aux aitres à zéro (facile à vérifier sur des exemples).
Le bit de poids le plus élevé variant fournit un signal de fréquence F/N .

Ne jamais utiliser le signal de détection de l’état M-1 directement pour autre chose, car
il présente le plus souvent des aléas de décodage, comme nous allons le verrons dans une
autre partie.
7.2. Quelques exemples

Compteur modulo 10 (1 chiffre DCB) :
On le trouve souvent tout fait (circuit physique ou composant logiciel).
Il faut parfois le réaliser. Pour cela, on utilise un compteur 4 bits Binaire, on détecte
l’état 9 (1 0 0 1 donc QD.QA en décodage incomplet) pour une remise à zéro. Nous verrons
cet exemple développé juste après.
Compteur modulo 60 Binaire :

On prend deux compteurs 4 bits binaires en cascade synchrone classique (donc
modulo 256 à la base), on détecte l’état 59 en binaire : etat59 = 111011 = Q 5Q 4Q 3Q 2Q1Q 0
en décodage complet ou plus simplement Q 5Q 4Q 3Q1Q 0 en décodage incomplet.
Il suffirait en fait d’un compteur 6 bits, modulo initial 64: de 0 (00 0000) à 63 (11
1111).
Compteur modulo 60 DCB :

On prend deux compteurs 4 bits DCB en cascade synchrone classique (donc modulo
100 à la base), on détecte l’état 59 en DCB : etat59 = 101 1001 = Q 6Q5Q 4Q 3Q 2Q1Q 0 en
décodage complet ou plus simplement Q 6Q 4Q 3Q 0 en décodage incomplet.
Il suffirait en fait d’un compteur 7 bits, modulo initial 80: de 0 (000 0000) à 79 (111
1001).

7.3. Compteur DCB 1 chiffre à partir d’un compteur

Binaire 4 bits
Si on ne dispose pas de compteur DCB, on peut en réaliser à partir d’un compteur binaire.
7.3.1. Compteur DCB élémentaire

CK
10 ENP
On détecte incomplètement l’état 9 (par
1 ~LOAD
9 ENT
7 D
6 C
5 B
4 A
3
2 ~CLR
seulement QD et QA). Au coup d'horloge
CLK
COMPTEUR
suivant, le compteur repasse à zéro. BINAIRE
RCO
QB
QA
4 BITS
QC
QD
Montage de principe seulement, car il
12
13
14
15
11
faut prévoir l’entrée générale de validation et
la retenue pour obtenir un compteur
2
1
U2A
élémentaire 1 chiffre DCB. 74LS00D
3
Circuit élémentaire pour une mise en cascade :
Montage complet 1 chiffre DCB
La retenue est évidemment le signal Etat9 E
Clr Synchrone
(pas le RCO qui ne sert plus à rien ici !). CK
Il faut aussi une entrée de validation 10 ENP

1 ~LOAD
9 ENT
7 D
6 C
5 B
4 A
3
2 ~CLR
générale mais qui bloque évidemment aussi

CLK
COMPTEUR
le compteur à l’état 9, et donc qui interdise BINAIRE
RCO
QB
QA 4 BITS
QC
l’action du Clear.
QD
Il se trouve que sur ces compteurs, E Retenue

12
13
14
15
11
valide seulement le comptage, la remise à

13
zéro pouvant tout de même s’effectuer !

2
2
1
U2A
D’où la nécessité de câbler aussi E sur la 74LS12D
porte NAND !!
1
Ceci n’est pas général, ça dépend des

12
compteurs utilisés.
Ici : Retenue = Etat9 = QD.QA.E
7.3.2. Mise en cascade de ces compteurs DCB

Elle devient évidente et classique : Les Ck ensemble et la retenue d’un chiffre quelconque
vers la validation du chiffre supérieur.
Remarque, si on avait omis E sur la porte NAND précédente, on aurait par exemple sur
deux chiffes compté : 87, 88, 89, 90, 01, 02 au lieu de 8, 88, 89, 90, 91, 92 …. ! De même
l’entrée de validation générale sur le chiffre de faible poids n’aurait pas agit quand celui-ci est
à 9, il se serait remis à zéro tout de même !

8. DECOMPTEURS SYNCHRONES
8.1. Binaire : principe de base à partir de compteurs 1 bit
à validation
Sur 3 bits, la suite serait 111 110 101 100 011 010 001 000 111 …
Il est facile de voir que cette fois ci :

Q0 change d’état à chaque fois (comme pour un compteur).
Q1 change d’état après que Q0 = 0
Q2 change d’état après que Q1Q0 = 00. Etc….
Validation générale Q1 Q2
Q0 E1 E2
E E0
Q0 H Q1 H
H
La retenue pour un bit supplémentaire ou un décompteur supplémentaire serait :
RCO = état0.Validation = Q 2.Q1Q 0. E
D’où mise en cascade synchrone identique aux compteurs !
8.2. DCB 4 bits à partir d’un décompteur binaire 4 bits

Il faut évidemment réaliser un cycle incomplet, mais cette fois-ci agir non pas au niveau de
la remise à zéro, mais de la remise à l’état maximum 9 après l’état 0.
1 0 0 1
La retenu (état 0) actionnera donc une entrée de
chargement parallèle synchrone pour charger 9 Load
(1001).
Ici dessin de principe rapide sans la validation. Décompteur Binaire 4 bits
QD QC QB QA
Pour une mise en cascade, il faudrait évidemment
l’entrée générale de validation (voir compteur DCB), et
un chargement inactif lorsque le compteur n’est pas
validé (à ajouter dans le câblage si nécessaire).
RCO

8.3. Décompteurs à partir de compteurs binaires

8.3.1. Décompteur binaire
Etats du Compteur Binaire Après inverseurs
10 ENP
1 ~LOAD
9 ENT
7 D
6 C
5 B
4 A
3
2 ~CLR
0000 0 1111 15
CLK
0001 1 1110 14 COMPTEUR
BINAIRE
0010 2 1101 13
RCO
QB
QA
4 BITS
QC
QD
0011 3 1100 12
12
13
14
15
11
. . Comptage
. .
1
3
5
9
1101 13 0010 2
1110 14 0001 1
2
4
6
8
1111 15 0000 0 Décomptage
8.3.2. Décompteur DCB

On réalise un compteur modulo 10 spécial démarrant à 6 : états 6,7,8, ….15. Une fois
inversé on obtient le décompteur DCB souhaité.
Etats du Compteur Après inverseurs 0 1 1 0

Binaire
10 ENP
1 ~LOAD
9 ENT
7 D
6 C
5 B
4 A
3
0110 6 1001 9 2 ~CLR
CLK
COMPTEUR
2
0111 7 1000 8 U3A

74LS04N BINAIRE
1000 8 0111 7 RCO
QB
QA
4 BITS
QC
QD
1
1001 9 0110 6
12
13
14
15
11 Comptage
1010 10 0101 5
1011 11 0100 4 Binaire
1
3
5
9
6 à 15
1100 12 0011 3
2
4
6
8
1101 13 0010 2 Décomptage DCB 9 à 0

1110 14 0001 1
1111 15 0000 0
Pour une mise en cascade synchrone, il faudrait comme d’habitude utiliser ou créer un
signal de retenue pour valider les poids fort : ici c’est RCO déjà fait !

9. REGLES D’ASSOCIATION EN LOGIQUE

SYNCHRONE
La famille des circuits synchrones est constituée de bascules synchronisées sur une seule
horloge, séparées par des couches de logiques combinatoires. Toutes les commandes sont
prises en compte sur le front actif de l’horloge et les « transitoires », sont forcément terminés
sur le front actif suivant de l’horloge (si bien entendu le montage respecte la fréquence
maximale de fonctionnement).
Il n’y a aucune rétroactions combinatoires directes (sur entrées asynchrones) mais
seulement sur des entrées synchrones des bascules. Le fonctionnement d’un circuit en logique
synchrone est donc extrêmement fiable et portable d’une famille technologique à l’autre. De
plus, sa vitesse augmente linéairement avec l’accroissement de la vitesse des éléments qui le
composent. L’amélioration de la densité d’intégration conduit en plus automatiquement à une
augmentation des performances (plus d’intégration, moins de capacités parasites…).
Règles à respecter le plus possible pour éviter tout problème et concevoir des circuits
proprement.
1. Il ne faut jamais attaquer une entrée d’horloge avec une combinaison de sorties de
bascules. Des temps de propagation différents entraînent toujours un régime transitoire et
des niveaux parasites peuvent exister. Nous verrons ce type d’aléas dits de
« commutation » un peu plus tard. Il faut toujours une horloge a front suffisamment
raide, unique et propre.
Impulsions parasites
Bascules « Toggle »
1 D0 Q0
Prohibé !
Ck
E E0 Q0 E1 Q1
Ck Ck
H Quelques cas seulement :

Raz Circuit quelconque Initialisation,mise sous tension
OUI Asynchrone Raz d’urgence, alarme …
Avec H propre,
distribuée sur chaque Raz Circuit quelconque
circuit Synchrone
Certains couples de bascules ne provoqueront pas de parasites, d’autres le feront. Si le

signal S est utilisé pour attaquer l’entrée d’horloge d’une bascule, le « glitch » comme on le
nomme parfois risque d’être vu comme un front supplémentaire et d’actionner la bascule !
2. Sauf cas très particuliers (arrêt d’urgence, démarrage asynchrone de quelque chose) il ne
faut pas utiliser les entrées asynchrones d’une bascule (entrée Clear et Preset par exemple).
3. Les entrées asynchrones ne sont utilisées que dans deux cas :

- cas d’urgence (dans le cas d’une panne de l’horloge, il faut bien agir sur le
système.
- les rares cas, ou l’on veut par exemple remettre à zéro une bascule à un moment
précis mais a priori indépendant de l’horloge.

10. DEUX APPLICATIONS SIMPLES DE COMPTEURS
On remarquera qu’il faut par moment une étude théorique pour des fonctions bien
précises, mais aussi du feeling et du sens physique pour appréhender tout l’ensemble d’un
montage ! Ceci est vrai de toute façon dans de nombreux domaines …
10.1. Principe d’une montre numérique

réglages manuels
Diviseurs = multiplexeur2 voies
/32768 /60 /60 /12 ou 24

vers diviseurs pour calendrier
F = 32768 Hz plus complexe
Quartz
décodeurs BCD 7 segments
Afficheur Afficheur Afficheur

Secondes Minutes Heures
Le diviseur par 32768 est le plus simple (car binaire, puissance de 2).
Pour une montre chronomètre (au 1/100 de secondes), on partirait par exemple plutôt d’un
quartz à 3,2768 MHz la première division par 32768 donne 100Hz, donc le centième de
seconde, un diviseur par 100 donne les secondes.
On voit ici l’usage de multiplexeurs pour la mise à l’heure (circuits d’aiguillages).
On ajouterait des compteurs et des comparateurs pour fabriquer l’alarme réveil ...
Si on veut l’altimètre, le baromètre, le podomètre, le rythme cardiaque .... on ajoute
divers capteurs et circuits et pratiquement un petit microprocesseur pour gérer les fonctions
(avec programme incorporé). Une logique à microprocesseur associé à un petit programme
remplace de nos jours toute une logique câblée complexe, et permet des modifications à
l’infini ou presque. Ces nouvelles techniques permettent aujourd’hui miniaturisation, faible
coût et souplesse d’emploi incomparable.
10.2. Principe d’une minuterie

Avec bouton poussoir de déclenchement, et arrêt au bout de N minutes.
Il faut tout d’abord une bascule D, ou une bascule de type RS, pour fournir la sortie
principale de la minuterie (fonction mémoire).
On peut utiliser ensuite un compteur ou un décompteur, un comparateur ou non .. Plusieurs
montages sont possibles avec un mélange de synchrone, d’asynchrone d’entrées à front et à
niveau.
A voir en exercice, en utilisant des circuits classiques : compteurs, comparateurs …

11. GENERATION D'IMPULSIONS

On désire très souvent générer une impulsion de durée constante à un instant bien précis
(comme au front montant ou descendant d'un signal ). Exemple d'application: on peut rendre
sensible sur front une entrée sensible sur niveau, en créant une impulsion fine (de 100ns à
quelques µs ) sur le front désiré du signal de commande. Un tel circuit se nomme en
analogique : "monostable".
Parfois on veut créer un signal périodique nommé "horloge", on utilise pour cela un
"astable".
11.1. Création d’une impulsion en Numérique

Exemple, on veut créer ici, au front montant d’un signal de commande
« Cadence_de_mesure », une impulsion de largeur calibrée ECH ici de T = 1/F = 1 ms.
Application : remise à zéro d’un compteur au début d’une mesure (cas d’un fréquencemètre
par exemple, ou l’on doit compter le nombre d’impulsions par seconde d’un signal).
Cadence de mesure
D Pr Q D Pr Q
1Hz
Ck Ck
Cl
Q Cl
Q
ECH
Référence
Horloge, :Signal carré
fréquence F = 1kHz
de période θ =1ms
(gamme 4 )
Il serait facile de dessiner les chronogrammes et de trouver :
Cadence
ECH
Remarque, variante : Si la porte NAND était câblée sur Q de la première bascule et Q de

la seconde, l’impulsion sur ECH serait déclenchée par le front descendant de
cadence_de_mesure.
11.2. Création d’une impulsion en Analogique

Un peu ringard, mais pratique parfois encore….
11.2.1. Détection des fronts d'un signal par simple RC

Dans de nombreux cas, une précision de quelques % sur la largeur de l'impulsion générée
est suffisante, et ces impulsions sont toujours de durée brève (de 100ns à 1µs par exemple) on
peut alors utiliser de simples circuits dérivateurs RC en remplacement des vrais
"monostables". Il y a plusieurs montages possibles, à base de circuit RC.
On prendra garde aux valeurs maximales autorisées pour les résistances de rappel à la
masse en technologie TTL (voir un autre cours).

11.2.1.1. Montage N°1
Circuit logique actionné

E
S
S 1
Seuil du circuit actionné
0 0
0
tension négative, inactive
Le front montant de E déclenche en S une impulsion en logique positive (active à 1) .

Cette impulsion n'est pas rectangulaire mais on peut souvent l'utiliser telle quelle sur une
entrée "à niveau" d'un circuit logique (ce dernier rabotera en plus l'impulsion existant sur le
front descendant de S, en pratique elle sera donc d'une amplitude inférieure, et de toute façon
inactive).
Rappel : pour comprendre les chronogrammes sans effectuer de calcul, se souvenir que la
tension aux bornes d'une capacité ne peut pas varier durant un temps très court (si la maille
présente une résistance non nulle), la capacité transmet donc la discontinuité du signal E,
ensuite le circuit du premier ordre tend vers sa valeur d'équilibre finale. S tend donc vers 0
volt pour un circuit CMOS ( courant d'entrée nul), ou vers une valeur de tension de niveau bas
ViL ~ R.IiL en TTL (nécessité de R < ViLmax/IiLmax)
L'impulsion générée a pour durée environ RC (ordre de grandeur).
11.2.1.2. Montage N° 2
On obtient en S une impulsion
active à zéro, détectant le front E Circuit logique actionné
montant de E. W S
W 1
Seuil du circuit actionné
0 0
0
S 1 tension négative, inactive
11.2.1.3. Montage N°3

Il fournit une impulsion active
à 1, sur le front descendant de Circuit logique actionné
E W S
E.
E
seuil du circuit actionné S

0 0 1 0
0
tension négative, inactive

11.2.1.4. Montage N°4

Il donne une impulsion
active à zéro sur le front E Circuit logique actionné
W W' S
descendant de E.
W'
seuil du circuit actionné
0 0 1 0
0 tension négative, inactive
S 1 1
0
11.2.1.5. Montage N°5
On obtient une impulsion
active à 0 sur le front
descendant de E (comme le E Circuit logique actionné
montage N°4, mais sans S
portes supplémentaires).
E
Seuil du circuit actionné S 1 1 1

tension > Vcc, niveau 1
Niveau 0
mais Attention au seuil !
ATTENTION en TTL : La discontinuité descendante de S est égale à la discontinuité
descendante de E; le seuil étant assez bas, si le niveau haut de E est un peu faible, l'impulsion
en S risque de ne pas franchir ce seuil d'une manière significative, l'impulsion sera de durée
faible ou inexistante. Donc utiliser ce montage plutôt pour actionner un circuit CMOS
(seuil = Vcc/2 et niveau haut plus élevé).
11.2.1.6. Montage 6
Il détecte les deux fronts
du signal E. Circuit logique actionné
E S
W
Seuil porte W

11.2.1.7. Remarque
Les montages N°2 et N°4 peuvent générer des impulsions de durée plus importantes ( >
1µs à plusieurs secondes), en remplaçant l'inverseur suivant le dérivateur par un inverseur
Trigger de Schmitt qui permet de remettre n forme le signal. Sans celui-ci, les temps de
transitions devenant trop importants provoquent des oscillations parasites sur la sortie S.
Le montage N°6 peut fournir aussi des impulsions de plus longue durée en plaçant un
trigger après le OU EXCUSIF.
11.2.2. Monostables réalisés à partir de portes.

Pour obtenir des impulsions de durée plus longue, et plus précise, ou réglables, ou de
durée supérieure à l'impulsion d'entrée, on doit utiliser des portes supplémentaires à défaut de
circuits plus performants. On choisit ici des portes NAND (des montages analogues à NOR
existent).
11.2.2.1. Montage générant des impulsions de durée inférieure à celle d'entrée:
E S
W W'
Seuil porte W
W'
S
Le front montant de E génère une impulsion en logique négative sur S. Si on utilise
comme inverseur après l'intégrateur RC un Trigger, on peut générer facilement des
impulsions de durée quelconque , mais obligatoirement < à la durée de l'impulsion E.
(Si E repasse à 0 avant, S est forcé à 1 et le circuit ne fonctionne plus en monostable !)
11.2.2.2. Montage pouvant générer des impulsions de durée supérieure à celle

d'entrée:
C E vers niveau bas

S
E W
W
R
VR VR
1
Seuil porte θ
0 θ Vers niveau bas
0
T
S

Les deux impulsions, en E et en S sont en logique négative (actives à 0) (un circuit

réalisé avec des NOR pourrait travailler en logique positive).
Selon la valeur du seuil, T va de 0,6RC à 1,4 RC (environ 1,2RC sur la figure, un calcul
exact est possible en prenant les équations des exponentielles, avec les valeurs exactes des
niveaux haut et bas et du seuil).
Le rebouclage de S vers l'entrée de la porte permet de générer des impulsions de sorties >>
que celle d'entrée. Le montage marche très bien pour des impulsions longues sans trigger du
fait de la réaction de la sortie sur l'entrée qui provoque justement un effet trigger !.
Si l'impulsion E à une durée > T, le signal S ne change pas, seule la seconde évolution
exponentielle de VR est retardée, W repassant à zéro seulement lors de la remontée de E.
11.2.2.3. Temps de "recouvrement"

Les circuits précédents ne peuvent être redéclenchés pour générer une impulsion nouvelle
que si ils sont revenus dans leur état de repos ( fin de la seconde exponentielle). On peut
accélérer ce temps de recouvrement (appelé aussi temps de récupération par une simple
diode placée dans le bon sens aux bornes de R, diminuant ainsi fortement la constante de
temps de la seconde exponentielle).
11.2.3. Monostables de précision en circuits intégrés.

Ces circuits sont un peu obsolètes, mais on peut trouver encore dans le commerce des
circuits intégrés contenant 1 ou 2 monostables (LS123 en TTL, et 4538 en HCMOS par
exemple, cf. annexes). Ils possèdent généralement des entrées sensibles sur front montant ou
descendant, un réseau RC extérieur assure la durée de l'impulsion (un générateur de courant
variable à la place de R permet de faire varier le durée de l'impulsion). On trouve R et C par
des abaques pour de faibles valeurs de la durée générée, puis sous forme d'une formule
approchée.
Certains circuits assurent les deux modes de fonctionnement :

Non redéclenchable : ils ne peuvent être redéclenchés tant que l'impulsion générée n'est
pas terminée, un temps minimum de récupération est même nécessaire. C'est le cas de tous les
monostables étudiés précédemment.
Redéclenchable: ils se redéclenchent même si l'impulsion générée n'est pas terminée,

pour une durée identique, le signal de sortie restant actif. Si la période des impulsions de
déclenchement est < à la durée générée, la sortie reste active en permanence. On peut ainsi
différencier deux fréquences différentes, détecter la présence d'impulsions sur une ligne ....

11.3. Initialisation d’un système à la mise sous tension
Ce montage est toujours utilisé de nos jours.

Dans les systèmes purement logique, il faut générer une impulsion au démarrage pour
initialiser les circuits séquentiels (action sur des mises à 1 ou 0 asynchrones ou synchrone,
commandes de chargement parallèle…).
Dans tous les systèmes informatiques et les appareils comportant un microcontrôleur,
cela permet en plus de lancer le processeur en début de programme de démarrage.
Selon les besoins des circuits, on peut créer un simple signal retardé V1 à front non remis
en forme, un signal retardé V2 remis en forme, ou une impulsion V3.
v2
Vcc
V1 et V2 pourraient
v1
actionner une entrée type
Initialisation (active à 0). seuil trigger
V3 activerait une entrée

type Initialisation (active à t
v3
1).
L'alimentation Vcc doit t

être suffisamment établie monostable
lorsque V1 passe le niveau Trigger éventuel éventuel
de seuil (le niveau ‘0’ doit Alimentation
être encore un peu actif Générale
lorsque Vcc est établie). Vcc v1 v2 v3
Si RC est trop petit, V1 va suivre Vcc sans être suffisamment retardé.

Par exemple si l’alimentation est bien établie après une durée θ, on pourra choisir RC
voisin de 3 ou 3θ.

11.4. Mini retard d'un signal logique

On peut évidement utiliser des registres à décalages. Mais parfois pour effectuer de tout
petits retards dont la durée exacte importe peu, on fait encore appel à l’analogique et aux
circuits RC.
W
Circuit logique actionné

W ou S
E
Seuil Trigger W
S
Ce montage ne génère pas en fait d'impulsion nouvelle, mais il permet de retarder un peu
les fronts avant et arrière du signal E.
Remarques:
W peut s'utiliser tel quel sur des entrées sensibles sur niveau.
Par contre même pour des retards faibles voisins de 100ns environ, la porte Trigger
(inverseuse) est nécessaire pour remettre le front en forme (le signal W risque sinon de ne pas
présenter des fronts suffisamment raides pour actionner une entrée sensible sur fronts).
11.5. Astables à portes logiques

11.5.1. A réseau RC
Lorsqu'une précision de quelques % est suffisante, (avec Vcc stable):
• Montage à trigger
RC
Validation= 1
Vc niveau haut
départ quelconque
S seuil 2
seuil 1
niveau bas
T
Vc S
T1 T2
La fréquence de récurrence peut se calculer exactement, sur la figure on devine son ordre
1 1
de grandeur : f = ≈ ( dépend des seuils et des niveaux haut et bas).
T1 + T2 1, 5RC

• Montage à portes
Validation= 1 v RC
S W
niveau haut
R
seuil
niveau bas
C
W
v et S
1
Pour le dessin de la figure, on voit que l'ordre de grandeur de f est de .
2RC
Pour ce circuit ainsi que le précédent on peut arrêter l'oscillation en mettant à zéro le signal
de validation, mais attention , au redémarrage, la première période de S sera plus longue, ce
qui n'est pas forcément un inconvénient.
11.5.2. A Quartz.
Les circuits précédents permettent une stabilité de la fréquence de quelques %. L'utilisation
d'un quartz permet des précisions de 10-6 et plus., dans une grande gamme de température.
• Astable à quartz réalisé avec un inverseur HCMOS (ou NAND).

La forte résistance Rf de quelques MΩ provoque une contre réaction et permet à la porte
HCMOS de travailler en permanence en amplificateur linéaire à fort gain, et l'ensemble forme
alors un oscillateur "Pierce" (ne pas remplacer la porte par un inverseur TTL !!; la CMOS
standard peut osciller vers 1MHz, la HCMOS est nécessaire pour des fréquences supérieures).
La résistance R1 limite le courant dans le quartz et assure une meilleure précision de celui-ci.
En modifiant C1 et C2 on peut "ajuster" la fréquence d'oscillation ( variation relative possible
< 10-6 ).
Le montage oscille sans problèmes avec les valeurs indiquées pour des Quartz de 1MHz à
4MHz. Les formules permettant de calculer les éléments de cet oscillateur figurent dans
l'annexe sur le circuit intégré HC4060, on pourra s'y reporter par curiosité...
HCMOS
validation
Quartz, fréquences S
classiques: Rf~10MΩ
1Mhz
ou 1,024Mhz
ou 2,048Mhz R1~1,2kΩ
ou 4Mhz
ou 4,096Mhz
C1=22pf C2=33pF

11.5.2.1. Astable et diviseur intégré: le HC4060.

Pour obtenir soit une fréquence basse soit toute une série de fréquence, on utilise souvent
des diviseurs, le plus classique est le diviseur binaire asynchrone 14 bits HC4060, qui possède
en effet en plus des portes logiques pour réaliser l'astable à réseau RC ou l'astable à quartz
précédent. Toutes les sorties ne sont pas accessibles (Q1, Q2, Q3, et Q11 ne sortent pas du
boîtier).
Par exemple à partir d'un quartz 4096kHz, la sortie Q12 fournit 1kHz. On peut ajouter des
diviseurs par 10 successifs pour fournir 100Hz, 10 Hz....
11.5.3. Autres astables

On peut en réaliser à partir d'ampli-opérationnels, ou de monostables rebouclés. Il existe
aussi des circuits intégrés pouvant travailler en astable ou en monostable suivant le câblage.
Etc....
Ces circuits sont très obsolètes …..
_______________________________

Base Sequentielle PDF

Hochgeladen von

Dokumentinformationen

Originaltitel

Copyright

Verfügbare Formate

Dieses Dokument teilen

Dokument teilen oder einbetten

Freigabeoptionen

Stufen Sie dieses Dokument als nützlich ein?

Sind diese Inhalte unangemessen?

Copyright:

Verfügbare Formate

Base Sequentielle PDF

Hochgeladen von

Copyright:

Verfügbare Formate

Base Sequentielle.

COURS DE CIRCUITS NUMERIQUES

Circuits séquentiels de bases

Compteurs, décompteurs, registres à décalage

Génération d’impulsion analogique et numérique

DUT GEII_ 1 CNAM ed 2010

2. COMPTEURS BINAIRES ASTYNCHRONES 17

3. SYSTEMES SYNCHRONES : ETUDE GLOBALE PAR LES MACHINES D’ETAT

4. COMPTEURS BINAIRES SYNCHRONES 28

5. COMPTEURS BINAIRE ET DECIMAL CODE BINAIRE 31

6. TECHNIQUES DE MISE EN CASCADE DE COMPTEURS 35

7. COMPTEURS BINAIRE OU DCB A CYCLE INCOMPLETS 37

DUT GEII_ 1 CNAM ed 2010

7.3. Compteur DCB 1 chiffre à partir d’un compteur Binaire 4 bits 38

9. REGLES D’ASSOCIATION EN LOGIQUE SYNCHRONE 41

10. DEUX APPLICATIONS SIMPLES DE COMPTEURS 42

11. GENERATION D'IMPULSIONS 43

DUT GEII_ 1 CNAM ed 2010

DUT GEII_ 1 CNAM ed 2010

1. INTRODUCTION A LA LOGIQUE SEQUENTIELLE

Etats d’un système

Certains états peuvent être physiquement exploités, et d’autres non :

DUT GEII_ 1 CNAM ed 2010

Horloge Variables internes

-Action sur niveau. Par exemple inactive à 0. Agit en permanence au niveau 1,

DUT GEII_ 1 CNAM ed 2010

Notations : Q et Q+ ou Qn et Qn+1 On utilisera l’une ou l’autre de ces notations

1.2. Circuits séquentiels élémentaires

Utilisation du diagramme de Kanaugh « Compact »

DUT GEII_ 1 CNAM ed 2010

Mise à un sur un signal ou interrupteur, Anti Rebond câblé

DUT GEII_ 1 CNAM ed 2010

1.2.2. Bascule RS synchronisée sur horloge à niveau : RSH

Quand H vaut 1, le bistable fonctionne normalement. Quand H vaut 0, il garde en

C’est une variante importante du circuit précédent :

Deux états selon H :

On n’exploite le plus souvent Q que pendant la phase verrou. 1 D

Existe en circuit intégré ou en composant pour logique programmable (4 ou 8 dans

On les nomme aussi « registres »

DUT GEII_ 1 CNAM ed 2010

Limitations de ce type de circuits à horloge à niveau

• Compteur 1 bit par rétroaction : 0 1 0 1 0 … Le montage oscille sans cesse très

1.2.4. Historiques bascules maître-esclave

DUT GEII_ 1 CNAM ed 2010

1.2.5. Bascules D à front

Front montant Front descendant

En dosant de manière adéquate le temps de propagation tPCK de l’inverseur, on obtient en

Equation : Avec Qn (ou Q) état avant le front

DUT GEII_ 1 CNAM ed 2010

Applications simples, parfois utiles :

Mise à 1 sur niveau 0, mise à 0 sur front Mise à 1

Ajout d’une entrée de MISE A ZERO SUYNCHRONE petit exercice !

Par un diagramme de Karnaugh compact : ClrSy

1.2.6. Bascules D à front et entrée de validation E

Par un diagramme de Karnaugh compact : E

DUT GEII_ 1 CNAM ed 2010

Equation précédente Schéma externe

1.2.7. Historiques et ‘Moyenâgeuses’ Bascules JK

Toujours active sur front évidemment, sinon le fonctionnement principal (qui le

1.2.8. Compteur 1 bit, bascule D montée en « Toggle »

DUT GEII_ 1 CNAM ed 2010

1.2.9. Compteur élémentaire 1 bits à validation

Etude par un diagramme de karnaugh normal :