David Bouchet – Architecture des ordinateurs – EPITA – S2 – 2017/2018
Chapitre 3
Les compteurs
Version du 27/12/2017
Table des matières
I. Définitions..................................................................................................................................................2
1. Compteur binaire...................................................................................................................................2
2. Décompteur binaire...............................................................................................................................3
3. Autres types de compteurs.....................................................................................................................4
II. Conception de compteurs asynchrones.....................................................................................................5
1. Principe..................................................................................................................................................5
2. Diviseurs de fréquence par deux ou bascule T......................................................................................5
3. Circuits de comptage à cycle complet...................................................................................................7
3.1. Compteurs......................................................................................................................................7
3.2. Décompteurs................................................................................................................................10
4. Circuits de comptage à cycle incomplet..............................................................................................12
4.1. Compteurs....................................................................................................................................12
4.2. Décompteur.................................................................................................................................14
5. Conclusion...........................................................................................................................................16
III. Conception de compteurs synchrones....................................................................................................17
1. Principe................................................................................................................................................17
2. Les tables de transitions......................................................................................................................17
2.1. La table de transitions d’une bascule JK.....................................................................................18
2.2. La table de transitions d’une bascule D.......................................................................................18
3. Compteurs synchrones à partir de bascules JK...................................................................................19
4. Compteurs synchrones à partir de bascules D.....................................................................................21
Chapitre 3 – Les compteurs 1/22
David Bouchet – Architecture des ordinateurs – EPITA – S2 – 2017/2018
I. Définitions
1. Compteur binaire
Un compteur binaire est un circuit séquentiel possédant une horloge et une sortie sur n bits. Cette sortie
représente un nombre binaire qui est incrémenté de 1 à chaque front d’horloge.
On dit qu’un compteur est modulo m lorsqu’il compte de 0 à m – 1. Par exemple :
• Un compteur modulo 8 compte de 0 à 7 ;
• Un compteur modulo 10 compte de 0 à 9 ;
• Un compteur modulo 16 compte de 0 à 15.
Exemple d’un compteur modulo 16 :
On peut remarquer qu’une sortie (Qn) bascule sur chaque front descendant de la sortie précédente (Qn–1) :
• Q1 bascule sur chaque front descendant de Q0 ;
• Q2 bascule sur chaque front descendant de Q1 ;
• Q3 bascule sur chaque front descendant de Q2.
Remarques :
• Un compteur modulo 10 peut également s’appeler un compteur BCD ;
n
• Un compteur modulo m avec m = 2 est un compteur à cycle complet ;
n
• Un compteur modulo m avec m ≠ 2 est un compteur à cycle incomplet.
Chapitre 3 – Les compteurs 2/22
David Bouchet – Architecture des ordinateurs – EPITA – S2 – 2017/2018
2. Décompteur binaire
Un décompteur binaire est un circuit séquentiel possédant une horloge et une sortie sur n bits. Cette sortie
représente un nombre binaire qui est décrémenté de 1 à chaque front d’horloge.
On dit qu’un décompteur est modulo m lorsqu’il décompte de m – 1 à 0. Par exemple :
• Un décompteur modulo 8 décompte de 7 à 0 ;
• Un décompteur modulo 10 décompte de 9 à 0 ;
• Un décompteur modulo 16 décompte de 15 à 0.
Exemple d’un décompteur modulo 16 :
On peut remarquer qu’une sortie (Qn) bascule sur chaque front montant de la sortie précédente (Qn–1) :
• Q1 bascule sur chaque front montant de Q0 ;
• Q2 bascule sur chaque front montant de Q1 ;
• Q3 bascule sur chaque front montant de Q2.
Remarques :
• Un décompteur modulo 10 peut également s’appeler un décompteur BCD ;
n
• Un décompteur modulo m avec m = 2 est un décompteur à cycle complet ;
n
• Un décompteur modulo m avec m ≠ 2 est un décompteur à cycle incomplet.
Chapitre 3 – Les compteurs 3/22
David Bouchet – Architecture des ordinateurs – EPITA – S2 – 2017/2018
3. Autres types de compteurs
En fait, on peut utiliser le terme compteur pour un circuit qui génère n’importe quel type de séquence.
Une séquence n’est pas nécessairement celle d’un nombre binaire naturel. Par exemple, il existe des
compteurs en code Gray. Une séquence peut également être conçue pour satisfaire les besoins divers et
variés de certains circuits.
Chapitre 3 – Les compteurs 4/22
David Bouchet – Architecture des ordinateurs – EPITA – S2 – 2017/2018
II. Conception de compteurs asynchrones
1. Principe
Dans un compteur ou un décompteur binaire, la fréquence d’une sortie (Qn) est deux fois plus petite que
celle de la sortie précédente (Qn–1) :
• La fréquence de Q1 est deux fois plus petite que celle de la sortie Q0 ;
• La fréquence de Q2 est deux fois plus petite que celle de la sortie Q1 ;
• Et ainsi de suite.
Les fréquences sont successivement divisées par deux (cf. chronogramme d’un compteur binaire – I.1).
Ce qui peut aussi se voir dans la séquence d’un nombre binaire que l’on incrémente :
Q2 Q1 Q0
0 0 0
0 0 1
0 1 0
0 1 1
1 0 0
1 0 1
1 1 0
1 1 1
Par conséquent, le principe de base d’un compteur est la division de fréquence par deux. Ceci peut être fa-
cilement obtenu en connectant plusieurs diviseurs de fréquence par deux en cascade (ou en série).
Nous devons maintenant comprendre ce qu’est un diviseur de fréquence par deux et comment il s’obtient.
2. Diviseurs de fréquence par deux ou bascule T
Un diviseur de fréquence par deux divise la fréquence de son entrée par deux. Il existe plusieurs façons
d’en obtenir. Les deux plus courantes utilisent une bascule D ou JK.
Figure 1 Figure 2
Chapitre 3 – Les compteurs 5/22
David Bouchet – Architecture des ordinateurs – EPITA – S2 – 2017/2018
Les chronogrammes de ces deux circuits sont identiques :
Un diviseur de fréquence par deux peut être associé au symbole suivant (bascule T) :
Cette bascule T est synchronisée sur front montant, mais l’on peut également la synchroniser sur front
descendant à l’aide de bascules D ou JK synchronisées sur front descendant. On obtient alors le symbole
suivant :
Les bascules D et JK disposent généralement d’entrées asynchrones actives à l’état bas. Ce sont des en -
trées de mise à 0 (clear ou reset) et de mise à 1 (preset ou set). En fonctionnement classique, ces deux en-
trées sont désactivées (mises à 1). Quand preset = 0, la sortie Q est forcée à 1 et quand clear = 0, la sor-
tie Q est forcé à 0. Ces entrées sont prioritaires sur toutes les autres entrées des bascules.
Chapitre 3 – Les compteurs 6/22
David Bouchet – Architecture des ordinateurs – EPITA – S2 – 2017/2018
Elles sont symbolisées de la façon suivante :
Ces entrées peuvent être ajoutées à nos bascules T.
Nous les représenterons uniquement lorsque nous en aurons besoin. Par conséquent, si elles n’appa-
raissent pas sur un symbole, nous supposerons qu’elles sont inactives (clear = preset = 1).
3. Circuits de comptage à cycle complet
3.1. Compteurs
Un compteur à cycle complet possède une sortie sur n bits et son modulo est 2n. Il compte en suivant la
séquence naturelle d’un nombre binaire de 0 à 2n – 1.
Pour concevoir un compteur sur n bits, n bascules sont nécessaires. Ces dernières sont alors connectées en
cascade (ou en série) de façon à ce qu’une sortie (Qn) bascule sur chaque front descendant de la sortie
précédente (Qn–1).
Par exemple, pour un compteur sur 4 bits, il faut connecter 4 bascules en série de façon à ce que :
• Q1 bascule sur chaque front descendant de Q0 ;
• Q2 bascule sur chaque front descendant de Q1 ;
• Q3 bascule sur chaque front descendant de Q2.
Chapitre 3 – Les compteurs 7/22
David Bouchet – Architecture des ordinateurs – EPITA – S2 – 2017/2018
Si l’on utilise des bascules synchronisées sur front descendant, on obtient le schéma et le chronogramme
suivants :
Par exemple, si la bascule T est constituée de bascules JK, on obtient le schéma suivant :
Chapitre 3 – Les compteurs 8/22
David Bouchet – Architecture des ordinateurs – EPITA – S2 – 2017/2018
Évidemment, nous pouvons tout aussi bien utiliser des bascules synchronisées sur front montant :
Ce circuit est toujours un compteur :
• Q1 bascule sur chaque front montant de Q0 (donc sur chaque front descendant de Q0) ;
• Q2 bascule sur chaque front montant de Q1 ( donc sur chaque front descendant de Q1) ;
• Q3 bascule sur chaque front montant de Q2 ( donc sur chaque front descendant de Q2).
Vous pouvez remarquer que sur un compteur, il y a toujours une seule bulle sur le fil qui relie une sortie
(Qn ou Qn) à l’entrée d’horloge de la bascule suivante.
Le chronogramme de ce circuit est le suivant :
Par exemple, si les bascules T sont constituées de bascule D, on obtient le schéma suivant :
Chapitre 3 – Les compteurs 9/22
David Bouchet – Architecture des ordinateurs – EPITA – S2 – 2017/2018
3.2. Décompteurs
Un décompteur à cycle complet possède une sortie sur n bits et son modulo est 2n. Il décompte en suivant
la séquence naturelle d’un nombre binaire de 2n – 1 à 0.
Pour concevoir un décompteur sur n bits, n bascules sont nécessaires. Ces dernières seront alors connec-
tées en cascade (ou en série) de façon à ce qu’une sortie (Qn) bascule sur chaque front montant de la sor-
tie précédente (Qn–1).
Par exemple, pour un décompteur sur 4 bits, il faut connecter 4 bascules en série de façon à ce que :
• Q1 bascule sur chaque front montant de Q0 ;
• Q2 bascule sur chaque front montant de Q1 ;
• Q3 bascule sur chaque front montant de Q2.
Si l’on utilise des bascules synchronisées sur front montant, on obtient le schéma et le chronogramme sui-
vants :
Chapitre 3 – Les compteurs 10/22
David Bouchet – Architecture des ordinateurs – EPITA – S2 – 2017/2018
Par exemple, si la bascule T est constituée de bascules D, on obtient le schéma suivant :
Évidemment, nous pouvons tout aussi bien utiliser des bascules synchronisées sur front descendant :
Ce circuit est toujours un décompteur :
• Q1 bascule sur chaque front descendant de Q0 (donc sur chaque front montant de Q0) ;
• Q2 bascule sur chaque front descendant de Q1 ( donc sur chaque front montant de Q1) ;
• Q3 bascule sur chaque front descendant de Q2 ( donc sur chaque front montant de Q2).
Vous pouvez remarquer que sur un décompteur, il y a soit zéro, soit deux bulles sur le fil qui relie une
sortie (Qn ou Qn) à l’entrée d’horloge de la bascule suivante.
Le chronogramme de ce circuit est le suivant :
Chapitre 3 – Les compteurs 11/22
David Bouchet – Architecture des ordinateurs – EPITA – S2 – 2017/2018
Par exemple, si les bascules T sont constituées de bascule JK, on obtient le schéma suivant :
4. Circuits de comptage à cycle incomplet
4.1. Compteurs
Un compteur à cycle incomplet possède une sortie sur n bits et son modulo est inférieur à 2n. Il compte en
suivant la séquence naturelle d’un nombre binaire de 0 à une valeur inférieure à 2n – 1.
La première étape pour concevoir un compteur à cycle incomplet est de concevoir un compteur à cycle
complet. Ensuite, la valeur du modulo doit être détectée et remplacée par la valeur 0.
Par exemple, un compteur modulo 11 est à cycle incomplet parce qu’il possède 4 sorties et que sur les
16 combinaisons disponibles, seulement 11 sont utilisées. Autrement dit, il compte de 0 à 10 alors qu’il a
la possibilité de compter de 0 à 15.
Nous devons donc concevoir un compteur modulo 16 et remplacer la valeur 11 par la valeur 0 :
Mod. 16 : 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
Mod. 11 : 0 1 2 3 4 5 6 7 8 9 10 0 1 2 3 4
↑
La valeur 11 doit être remplacée par la valeur 0.
Pour forcer la sortie du compteur à 0, on peut utiliser les entrées asynchrones de mise à 0 (clear).
La valeur 11 peut être détectée à l’aide d’une porte NON-ET à 4 entrées. Appelons M sa sortie.
M = 0 si et seulement si Q3:0 = 10112 = 1110.
Chapitre 3 – Les compteurs 12/22
David Bouchet – Architecture des ordinateurs – EPITA – S2 – 2017/2018
Si l’on utilise des bascules synchronisées sur front descendant, on obtient le schéma suivant :
Dès que la valeur 11 est atteinte, M passe à 0. Les entrées de mise à 0 deviennent actives et les sorties sont
forcées à 0. M repasse alors à 1, ce qui désactive les entrées de mise à 0 ; le compteur se remet à compter.
La valeur 11 apparaît très brièvement, ce qui est suffisant pour mettre à 0 les sorties. En pratique, l’impul-
sion de mise à 0 ne dure que quelques nanosecondes ; elle dépend de la performance des composants.
Il est possible d’optimiser légèrement la détection de la valeur 11. On peut remarquer que
Q3 = Q1 = Q0 = 1 quand la sortie vaut soit 11 (Q2 = 0) soit 15 (Q2 = 1). Étant donné que 15 n’apparaît
jamais dans notre séquence, nous pouvons conclure que quand Q3 = Q1 = Q0 = 1, la sortie du compteur
vaut 11. La valeur de Q2 n’est donc pas utile pour la détection de la valeur 11.
Chapitre 3 – Les compteurs 13/22
David Bouchet – Architecture des ordinateurs – EPITA – S2 – 2017/2018
Après optimisation, nous obtenons le schéma suivant :
4.2. Décompteur
Un décompteur à cycle incomplet possède une sortie sur n bits et son modulo est inférieur à 2 n. Il compte
en suivant la séquence naturelle d’un nombre binaire d’une valeur inférieure à 2n – 1 à 0.
La première étape pour concevoir un décompteur à cycle incomplet est de concevoir un décompteur à
cycle complet. Ensuite, la valeur maximale doit être détectée et remplacée par la valeur du modulo – 1.
Par exemple, un décompteur modulo 11 est à cycle incomplet parce qu’il possède 4 sorties et que sur les
16 combinaisons disponibles, seulement 11 sont utilisées. Autrement dit, il décompte de 10 à 0 alors qu’il
a la possibilité de décompter de 15 à 0.
Nous devons donc concevoir un décompteur modulo 16 et remplacer la valeur 15 par la valeur 10 :
Mod. 16 : 10 9 8 7 6 5 4 3 2 1 0 15 14 13 12 11
Mod. 11 : 10 9 8 7 6 5 4 3 2 1 0 10 9 8 7 6
↑
La valeur 15 doit être remplacée par la valeur 10.
Pour forcer la sortie du compteur à 10, on peut utiliser les entrées asynchrones preset et clear.
La valeur 15 peut être détectée à l’aide d’une porte NON-ET à 4 entrées. Appelons M sa sortie.
M = 0 si et seulement si Q3:0 = 11112 = 1510.
Chapitre 3 – Les compteurs 14/22
David Bouchet – Architecture des ordinateurs – EPITA – S2 – 2017/2018
Si l’on utilise des bascules synchronisées sur front montant, on obtient le schéma suivant :
Dès que la valeur 15 est atteinte, M passe à 0. Les sorties Q0 et Q2 sont mises à 0 et les sorties Q1 et Q3
sont mises à 1 ; la sortie décimale du compteur vaut 10 (1010 = 10102). M repasse alors à 1, ce qui désac-
tive les entrées preset et clear. Le décompteur se remet à décompter.
La valeur 15 apparaît très brièvement, ce qui est suffisant pour forcer à 10 la sortie. En pratique, l’impul-
sion de forçage ne dure que quelques nanosecondes ; elle dépend de la performance des composants.
Il est possible d’optimiser légèrement la détection de la valeur 15. On peut remarquer que Q3 = Q2 = 1
quand la sortie est supérieure ou égale à 12. Étant donné que 12, 13 et 14 n’apparaissent jamais dans notre
séquence, nous pouvons conclure que quand Q3 = Q2 = 1, la sortie du décompteur vaut 15. Les valeurs de
Q0 et de Q1 ne sont donc pas utiles pour la détection de la valeur 15.
Chapitre 3 – Les compteurs 15/22
David Bouchet – Architecture des ordinateurs – EPITA – S2 – 2017/2018
Après optimisation, nous obtenons le schéma suivant :
5. Conclusion
• Pour concevoir un compteur ou un décompteur asynchrone, il faut connecter des diviseurs de fré-
quence par deux en cascade (ou en série). La sortie de la première bascule fait commuter la sortie de la
deuxième, la sortie de la deuxième fait commuter la sortie de la troisième, et ainsi de suite.
• Dans un compteur, une sortie (Qn) bascule sur chaque front descendant de la sortie précédente (Qn–1).
Pour obtenir un tel résultat, il faut connecter Qn ou Qn à l’entrée d’horloge de la bascule suivante de fa-
çon à n’avoir qu’une seule bulle sur le fil.
• Dans un décompteur, une sortie (Qn) bascule sur chaque front montant de la sortie précédente (Qn–1).
Pour obtenir un tel résultat, il faut connecter Qn ou Qn à l’entrée d’horloge de la bascule suivante de fa-
çon à avoir soit zéro bulle, soit deux bulles sur le fil.
• Pour concevoir un compteur à cycle incomplet, la valeur du modulo doit être détectée et remplacée par
la valeur 0.
• Pour concevoir un décompteur à cycle incomplet, la valeur maximale sur n bits (2n – 1) doit être détec-
tée et remplacée par la valeur du modulo – 1.
Chapitre 3 – Les compteurs 16/22
David Bouchet – Architecture des ordinateurs – EPITA – S2 – 2017/2018
III. Conception de compteurs synchrones
1. Principe
Un compteur synchrone est constitué de bascules D ou JK connectées au même signal d’horloge. Les sor-
ties de ces bascules changent donc toutes au même moment.
Les entrées et les sorties des bascules sont connectées à un circuit combinatoire. Ce dernier a été conçu de
façon à générer une séquence particulière. Toute forme de séquence peut être générée.
Prenons un exemple constitué de trois bascules JK :
Les sorties des bascules sont les entrées du circuit combinatoire et les sorties du circuit combinatoire sont
les entrées des bascules.
Concevoir le circuit combinatoire revient à déterminer les expressions de ses sorties (K0, J0, K1, J1, etc.)
en fonction de ses entrées (Q0, Q1, etc.).
Pour cela, il est nécessaire d’utiliser des tables de transitions.
2. Les tables de transitions
Une table de transitions donne les différents états d’entrée qui permettent d’obtenir une transition donnée
sur une sortie.
Chapitre 3 – Les compteurs 17/22
David Bouchet – Architecture des ordinateurs – EPITA – S2 – 2017/2018
2.1. La table de transitions d’une bascule JK
La table de transitions d’une bascule JK se remplit à l’aide de sa table de vérité.
Table de transitions Table de vérité
Q(t) Q(t+1) J K C J K Q
0 0 0 Φ ↑ 0 0 q
0 1 1 Φ ↑ 0 1 0
1 0 Φ 1 ↑ 1 0 1
1 1 Φ 0 ↑ 1 1 q
Pour déterminer les états de J et de K, vous devez vous poser la question suivante pour chaque ligne :
quels sont les états possibles sur J et K qui permettent la transition de Q(t) à Q(t+1) ?
Ligne : Q passe de 0 à 0
• état mémoire (J = 0, K = 0)
• mise à 0 (J = 0, K = 1)
Ligne : Q passe de 0 à 1
• basculement (J = 1, K = 1)
• mise à 1 (J = 1, K = 0)
Ligne : Q passe de 1 à 0
• basculement (J = 1, K = 1)
• mise à 0 (J = 0, K = 1)
Ligne : Q passe de 1 à 1
• état mémoire (J = 0, K = 0)
• mise à 1 (J = 1, K = 0)
2.2. La table de transitions d’une bascule D
La table de transitions d’une bascule D est facile à obtenir parce qu’une bascule D copie directement son
entrée D sur sa sortie Q.
Q(t) Q(t+1) D
0 0 0
0 1 1
1 0 0
1 1 1
Pour déterminer les états de D, vous devez vous poser la question suivante pour chaque ligne : quel est
l’état sur D qui permet la transition de Q(t) à Q(t+1) ? La réponse est évidente : Q(t+1) = D.
Chapitre 3 – Les compteurs 18/22
David Bouchet – Architecture des ordinateurs – EPITA – S2 – 2017/2018
3. Compteurs synchrones à partir de bascules JK
Il est possible de définir tout type de séquence à condition que les combinaisons soient toutes différentes.
Prenons l’exemple ci-dessous :
Nous souhaitons concevoir un compteur synchrone qui réalise la séquence suivante :
Q2 Q1 Q0
1 0 0
1 0 1
1 1 1
1 1 0
0 1 0
0 1 1
À l’aide de la table de transitions, nous pouvons déterminer les entrées des bascules JK.
Q2 Q1 Q0 J2 K2 J1 K1 J0 K0
D’après la table de transitions d’une
1 0 0 Φ 0 0 Φ 1 Φ bascule JK, on a J0 = 1 et K0 = Φ lors
d'une transition de 0 à 1 sur Q0.
1 0 1 Φ 0 1 Φ Φ 0
1 1 1 Φ 0 Φ 0 Φ 1
1 1 0 Φ 1 Φ 0 0 Φ
0 1 0 0 Φ Φ 0 1 Φ
0 1 1 1 Φ Φ 1 Φ 1
À partir du tableau ci-dessus, nous pouvons déterminer les expressions simplifiées de J0, K0, J1, K1, J2
et K2 en fonction de Q0, Q1 et Q2.
• De façon évidente :
• K0 = Q1
• J1 = Q0
• J2 = Q0
Chapitre 3 – Les compteurs 19/22
David Bouchet – Architecture des ordinateurs – EPITA – S2 – 2017/2018
• À l’aide de tableaux de Karnaugh :
Q1 Q0 Q1 Q0
J0 00 01 11 10 K1 00 01 11 10
0 Φ Φ Φ 1 0 Φ Φ 1 0
Q2 Q2
1 1 Φ Φ 0 1 Φ Φ 0 0
J0 = Q1 + Q2 K1 = Q0.Q2
Q1 Q0
K2 00 01 11 10
0 Φ Φ Φ Φ
Q2
1 0 0 0 1
K2 = Q0.Q1
Nous obtenons le schéma de câblage suivant :
Il est possible d’utiliser des bascules synchronisées sur front montant ou descendant en fonction du front
sur lequel on souhaite synchroniser le compteur.
Chapitre 3 – Les compteurs 20/22
David Bouchet – Architecture des ordinateurs – EPITA – S2 – 2017/2018
4. Compteurs synchrones à partir de bascules D
La méthode de conception d’un compteur à partir de bascules D est semblable à celle utilisant des bas-
cules JK. Nous devons simplement remplacer les entrées J et K par des entrées D. Il est possible de défi-
nir tout type de séquence à condition que les combinaisons soient toutes différentes.
Prenons l’exemple ci-dessous :
Nous souhaitons concevoir un compteur synchrone qui réalise la séquence suivante :
Q2 Q1 Q0
0 0 0
0 0 1
0 1 0
0 1 1
1 0 0
1 0 1
1 1 0
1 1 1
À l’aide de la table de transitions, nous pouvons déterminer les entrées des bascules D.
Q2 Q1 Q0 D2 D1 D0
D’après la table de transitions d’une
0 0 0 0 0 1 bascule D, quand Q0 passe de 0 à 1,
D0 vaut 1.
0 0 1 0 1 0
0 1 0 0 1 1
0 1 1 1 0 0
1 0 0 1 0 1
1 0 1 1 1 0
1 1 0 1 1 1
1 1 1 0 0 0
À partir du tableau ci-dessus, nous pouvons déterminer les expressions simplifiées de D0, D1, et D2 en
fonction de Q0, Q1 et Q2.
• De façon évidente :
• D0 = Q0
Chapitre 3 – Les compteurs 21/22
David Bouchet – Architecture des ordinateurs – EPITA – S2 – 2017/2018
• À l’aide de tableaux de Karnaugh :
Q1 Q0 Q1 Q0
D1 00 01 11 10 D2 00 01 11 10
0 0 1 0 1 0 0 0 1 0
Q2 Q2
1 0 1 0 1 1 1 1 0 1
D1 = Q0.Q1 + Q0.Q1 D2 = Q2.Q1.Q0 + Q2.Q1 + Q2.Q0
Il est encore possible de simplifier ces expressions à l’aide d’un OU EXCLUSIF.
• D1 = Q0 ⊕ Q1
• D2 = Q2.Q1.Q0 + Q2.(Q1 + Q0)
D2 = Q2.Q1.Q0 + Q2.(Q1.Q0)
D2 = Q2 ⊕ (Q1.Q0)
Nous obtenons le schéma de câblage suivant :
Il est possible d’utiliser des bascules synchronisées sur front montant ou descendant en fonction du front
sur lequel on souhaite synchroniser le compteur.
Chapitre 3 – Les compteurs 22/22
