LES COMPTEURSUn compteur est un ensemble de n bascules interconnectées par des portes logiques. Ils peuvent donc mémoriser
des mots de n bits. Au rythme d'une horloge ils peuvent décrire une séquence déterminée c'est-à-dire occuper une
suite d'états binaires. Il ne peut y avoir au maximum que 2n combinaisons.
Ces états restent stables et accessibles entre les impulsions d'horloge. Le nombre total N des combinaisons
successives est appelé le modulo du compteur.
Le module N d’un compteur de n bascules est égale à 2n
L’état du compteur dans la plus part des cas fait 2n
Le début du compte est 0
La fin du compte est 2n-1
Le module d’un compteur constitué de 2 bascules T ou JK fait 22 soit 4, il peut faire 4 comptes allant de 00 à 11
en binaire ce qui équivaut à 0 à 3 en décimale.
Le module d’un compteur constitué de 4 bascules T ou JK fait 24 soit 16, il peut faire 16 comptes allant de 0000 à
1111 en binaire ce qui équivaut à 0 à 15 en décimale.
Les compteurs binaires peuvent être classés en deux catégories :
- les compteurs asynchrones ;
- les compteurs synchrones.
De plus on distingue les compteurs réversibles ou compteurs-décompteurs.
Les compteurs asynchrones ou Ripple
Un compteur asynchrone est constitué de n bascules J-K fonctionnant en mode T. Le signal
d'horloge n'est reçu que par le premier étage (bascule LSB : Least Significant Bit). Pour chacune
des autres bascules le signal d'horloge est fourni par une sortie de la bascule de rang
immédiatement inférieur.
A A
B B
C C
D D
A B C D
A A
B B
C C
D D
A B C D
compteur asynchrone de 4 bits utilisant des bascule T
n=4 bascules T, 2n=16 états, Modulo 2n=16, Début du compte 0000 2 = 010, Fin de compte 11112=1510
Chronogramme d’un compteur asynchrone de 4 bits T
n=4 bascules T, 2n=16 états, Modulo 2n=16, Début du compte 0000 2 = 010, Fin de compte 11112=1510
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18
1 1 1 1 1 1 1 1 1
0 0 0 0 0 0 0 0 0 0
1 1 1 1 1 1 1 1 1
0 0 0 0 0 0 0 0 0 0
1 1 1 1 1 1 1 1
0 0 0 0 0 0 0 0 0 0 0
1 1 1 1 1 1 1 1
0 0 0 0 0 0 0 0 0 0 0
0010
2
10110000 0001 0010 0011 0100 0101 0110 0111 1111 0000 00011100 1101
111 12 13 14 15 05 6 7 8 9 10
1110
0 1 2 3 4
1000 1001 1010
compteur asynchrone de 4 bits utilisant des bascule T
n=4 bascules T, 2n=16 états, Modulo 2n=16, Début du compte 0000 2 = 010, Fin de compte 11112=1510
15
0
10
11
12
13
14
5
6
7
8
9
0
1
2
3
4
16 0 0 0 0
15 1 1 1 1
14 1 1 1 0
13 1 1 0 1
12 1 1 0 0
11 1 0 1 1
10 1 0 1 0
9 1 0 0 1
8 1 0 0 0
7 0 1 1 1
6 0 1 1 0
5 0 1 0 1
4 0 1 0 0
3 0 0 1 1
2 0 0 1 0
1 0 0 0 1
Init 0 0 0 0
Clk QD QC QB QA Dec
0011
0100
0101
0110
0111
00000001
0010
10001001
1010
1011
1100
1101
1110
1111
compteur asynchrone de 4 bits utilisant des bascule JK
n=4 bascules JK, 2n=16 états, Modulo 2n=16, Début du compte 0000 2 = 010, Fin de compte 11112=1510
A A
B B
C C
D D
A B C D
A B C D
décompteurs asynchrone de 4 bits utilisant des bascule T
n=4 bascules T, 2n=16 états, Modulo 2n=16, Début du compte 1111 2 = 1510, Fin de compte 00002=010
A A
B B
C C
D D
A B C D
décompteur asynchrone de 4 bits utilisant des bascule T0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18
1 1 1 1 1 1 1 1 1
0 0 0 0 0 0 0 0 0 0
1 1 1 1 1 1 1 1 1 1
0 0 0 0 0 0 0 0 0
1 1 1 1 1 1 1 1 1 1
0 0 0 0 0 0 0 0 0
1 1 1 1 1 1 1 1 1 1MSB
0 0 0 0 0 0 0 0 0
1515 14 13 12 145 4 3 2 1 011 10 9 8 7 60
1000 0111 0110 01010000 1111 1110 1101 1100 1011 1010 1001 0010 0001 0000 1111 11100100 0011
n=4 bascules T, 2n=16 états, Modulo 2n=16, Début du compte 1111 2 = 1510, Fin de compte 00002=010
décompteur asynchrone de 4 bits utilisant des bascule T
n=4 bascules T, 2n=16 états, Modulo 2n=16, Début du compte 0000 2 = 010, Fin de compte 11112=1510
16 0 0 0 0 0
15 0 0 0 1 1
14 0 0 1 0 2
13 0 0 1 1 3
12 0 1 0 0 4
11 0 1 0 1 5
10 0 1 1 0 6
9 0 1 1 1 7
8 1 0 0 0 8
7 1 0 0 1 9
6 1 0 1 0 10
5 1 0 1 1 11
4 1 1 0 0 12
3 1 1 0 1 13
2 1 1 1 0 14
1 1 1 1 1 15
Init 0 0 0 0 0
Clk QD QC QB QA Dec
01111001
1000
01101010
01011011
0100
1100
1101 0011
1110 0010
00001111 0001
décompteur asynchrone de 4 bits utilisant des bascule T
A A
B B
C C
D D
n=4 bascules T, 2n=16 états, Modulo 2n=16, Début du compte 1111 2 = 1510, Fin de compte 00002=010
décompteur asynchrone de 4 bits utilisant des bascule T0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18
1 1 1 1 1 1 0 0 1 1
0
0 0 0 0 0 0 0 0
1 1 1 1 1 1 1 1 1 1
0 0 0 0 0 0 0 0 0
1 1 1 1 1 1 1 1 1 1 1
0 0 0 0 0 0 0 0
1 1 1 1 1 1 1 1 1 1 10 0 0 0 0 0 0 0
1101
155 4 311 10 9 8
1001 0010 00010011
142 1 0
0000 1111 1110
7 612
1000 0111 0110 0101 0100
1315 14 13
1111 1110 1101 1100 1011 1010
C
n=4 bascules T, 2n=16 états, Modulo 2n=16, Début du compte 1111 2 = 1510, Fin de compte 00002=010
décompteurs asynchrone de 4 bits utilisant des bascule JK
A A
B B
C C
D D
A B C D
A B C D
n=4 bascules T, 2n=16 états, Modulo 2n=16, Début du compte 1111 2 = 1510, Fin de compte 00002=010
décompteurs asynchrone de 4 bits utilisant des bascule JK
n=4 bascules JK, 2n=16 états, Modulo 2n=16, Début du compte 1111 2 = 1510, Fin de compte 00002=010
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18
J
K
1 1 1 1 1 1 1 1 1
0 0 0 0 0 0 0 0 0 0
1 1 1 1 1 1 1 1 1 1
0 0 0 0 0 0 0 0 0
1 1 1 1 1 1 1 1 1 1
0 0 0 0 0 0 0 0 0
1 1 1 1 1 1 1 1 1 1MSB
0 0 0 0 0 0 0 0 0
0001 0000 1111 1110
0 15 14 13 12
1000 0111 0110 0101 0100 00110000 1111 1110 1101 1100 1011 1010 1001 0010
15 145 4 3 2 1 011 10 9 8 7 6
décompteurs asynchrone de 4 bits utilisant des bascule JK
n=4 bascules JK, 2n=16 états, Modulo 2n=16, Début du compte 1111 2 = 1510, Fin de compte 00002=010
A A
B B
C C
D D
A B C D
Compteur/décompteur asynchrone
Nous obtenons un compteur en déclenchant chaque bascule lorsque celle de rang
immédiatement inférieur passe de l'état 1 à 0. Pour réaliser un décompteur il faut que le
changement d'état d'une bascule intervienne lorsque la bascule de rang immédiatement
inférieur passe de l'état 0 à 1. Pour cela il suffit d'utiliser la sortie Q de chaque bascule pour
déclencher la suivante.
On réalise un compteur-décompteur en utilisant un multiplexeur 2 entrées - 1 sortie entre
chaque étage pour sélectionner la sortie à utiliser.
Selon l'état de la ligne de commande M nous pouvons sélectionner le mode de comptage :
M = 0 ⇒ compteur ;
M = 1 ⇒ décompteur.
Compteur/décompteur asynchrone (Ripple) de 4 bits JK
Pour concevoir un compteur/décompteur asynchrone, il faut chercher entre les flip-flop JK ou T un circuit combinatoire qui permet de sélectionner le mode de comptage.Ce circuit permet d'attaquer les entrées des horloges des bascules soit avec la sortie Q ou avec la sortie Q'.Dans le cas de Q, nous aurons un compteur et si c'est Q' qui attaque l'horloge nous avons un décompteur. Dans tous les cas les sorties sont QA (LSB), QB, QC, QD(MSB) Ce circuit aura comme entrée M, Q, Q'. Si M=0 donne un compteur et M=1 donne un décompteurNous allons prendre comme sortie de ce circuit combinatoire Y qui se chargera d'attaquer l'horloge. Dans le cas d'un compteur Y=Q et pour un décompteur Y=Q'
Table de vérité du circuit combinatoire
Nous allons chercher par Karnaugh Y en fonction des entrées M, Q et Q' Circuit combinatoire
Attention ne pas convertir en XOR car Q désigne l'une des sorties de la bascule.
1
0 0 1
M Q Q'
0 0 0
Y
0Y
0
0 1 1
1 1 0
0 1 0
0
1 1 1
1 0 0
1 0 1
Q Q'
1 1
1 1
1
Q Q'
M'
M
Q Q' Q Q'M/QQ'
Y=M Q + M Q
1
0
1
A
n=4 bascules JK, 2n=16 états, Modulo 2n=16
A A
B B
C C
D D
A B C
D
A B C D
Compteur/décompteur asynchrone (Ripple) de 4 bits JK
compteur/décompteur asynchrone de 4 bits JK
n=4 bascules T, 2n=16 états, Modulo 2n=16
1511111
1401112
4001012
3110013
1111 0001
Init 0 0 0 0 0
Clk QD QC QB QA Dec 0000
Init 0 0 0 0 0
Clk QD
1110 0010
11
1101 0011
4 1 1 0 0 12
3 1 1 0 1 13
11015
8
0100
7 1 0 0 1 9 1100
6 1 0 1 0 10
00018
5
0101
10 0 1 1 0 61011
9 0 1 1 1 7
101011
01101010
0
01111001
15 0 0 0 1 1 1000
14 0 0 1 0 2
000016
QC QB QA Dec
2 0 0 1 0 2
1 0 0 0 1 1
4 0 1 0 0 4
3 0 0 1 1 3
6 0 1 1 0 6
5 0 1 0 1 5
8 1 0 0 0 8
7 0 1 1 1 7
10 1 0 1 0 10
9 1 0 0 1 9
12 1 1 0 0 12
11 1 0 1 1 11
14 1 1 1 0 14
13 1 1 0 1 13
16 0 0 0 0 0
15 1 1 1 1 15
Parfois, nous avons parfois besoin de remettre à zéro un compteur et recommencer le
compte ou de le charger avec une valeur déterminée.
Pour cela nous allons faire appel aux entrées asynchrones Preset (Pr) et Clear (Cr).
Ces entrées asynchrones prennent le dessus sur les entrées synchrones (J, K) et l'horloge
(Clk). Ces entrées asynchrones étant activées au niveau bas (active low), nous avons :
Si (Pr=1 et Cr=1) la bascule fonctionne normalement.
Si (Pr=0 et Cr=1) la bascule est presetée et Q donne 1
Si (Pr=1 et Cr=0) la bascule est resetée et Q donne 0
Si (Pr=0 et Cr=0) à proscrire
Remise à Zéro et chargement d'un compteur
1. Fonctionnement normal (DS=R=1)
Si DS=R=1, nous avons J=K=Pr=Cr=1 sur chaque bascule, ce qui donne un fonctionnement normal
2. Remise à zéro (R=0)
Pour la remise à zéro, nous allons chercher Pr=1 et Cr= 0. Pour cela il nous faut avoir R=0
J=K=0, mémorisation, pas de basculement sur une impulsion du signal d'horloge
3. Chargement avec une valeur déterminée D (DS=0 et R=1)
Si DS=0, J=K=0, mémorisation, pas de basculement sur une impulsion du signal d'horloge
Si D=0, (Pr=1 et Cr=0) donne Q=0
Si D=1, (Pr=0 et Cr=1) donne Q=1
Ces deux cas nous donne Q=D. Nous avons donc la possibilité de charger chaque bascule du compteur
avec une valeur donnée à présenter sur l'entrée D, donc d'initialiser le compteur.
Remise à Zéro et chargement d'un compteur
Remise à Zéro et chargement d'un compteur
A A
A
C
La figure suivante présente un exemple de montage permettant
de remettre à zéro un compteur ou de le charger avec une
valeur déterminée. Pour cela on utilise les entrées asynchrones
des bascules. En fonctionnement normal du compteur nous
devons avoir :
DS = R = 1. Nous avons alors : J = K = Pr = Cr = 1 sur chaque
bascule du compteur.
Pour RAZ : R = 0
⇒ J = K = 0 Interdit tout basculement sur une impulsion du
signal Clk;
⇒ (Pr = 1, Cr = 0) ⇒ Q = 0.
Chargement : (DS = 0, R = 1) ⇒ J = K = 0 Interdit tout
basculement sur une impulsion du signal Clk;
D = 0 ⇒ (Pr = 1, Cr = 0) ⇒ Q = 0
D = 1 ⇒ (Pr = 0, Cr = 1) ⇒ Q = 1
Dans ces deux cas nous obtenons Q = D. Nous sommes donc
capable de charger chaque bit du compteur avec une valeur
donnée à présenter sur l'entrée D, donc d'initialiser le compteur.
Compteur asynchrone incomplet Compter jusqu'à une certaine valeur
Le module d'un compteur est égale à 2 à la puissance du nombre de flip-flop (bits) utilisésUn compteur de 2 bits est un compteur modulo 4 = 22
Ce compteur peut compter jusqu'au (module -1), soit 4 -1 = 3Un compteur de 3 bits est un compteur modulo 8 = 23
Ce compteur peut compter jusqu'au (module -1), soit 8 - 1 = 7Un compteur de 4 bits est un compteur modulo 16 = 24
Ce compteur peut compter jusqu'au (module -1), soit 16 -1 = 15
Dès fois, il nous arrive de vouloir compter jusqu'à p , p étant un nombre compris entre 0 ( le compte le plus petit) et 2n-1 ( compte le plus élevé)
Dans ce cas, nous allons utiliser un compteur d'un module supérieur et une fois le compte voulu atteint le remet à zéro (Clear) pour recommencer
Nous allons utiliser les entrées asynchrones (Preset et Clear) pour faire un forçage sur le compteur indépendamment des entrées synchrones et de l'horloge
Si nous voulons concevoir un compteur modulo 6, qui donc peut compter de 0 à (6-1) = 5, nous allons utiliser un compteur modulo 8
Compteur asynchrone modulo 6
A A
B B
C C
A B C
A B C
1 1
0 0
0 1
1 0
QB QA
0 0
1
1
Dec
0
1
2
3
4
5
6
QC
0
0
0
0
1
1
1 1 7
0 1
1 0
0 1 0 2
0 1 1 3
QC Dec
0 0
0 0 1 1
0 0
QB QA
3
4
5
1 0 0
1 0 1
0 1 1
5101
4001
20 1 0
0 0 0 0
0 0 1 1
Pour avoir Clr (Clear) = 0 à la sortie de la porte NAND, il nous faut injecter 6 (110) (QC=1, QB=1 et QA=0)
Compteur asynchrone modulo 6
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18
1 1 1 1 1 1 1 1 1
0 0 0 0 0 0 0 0 0 0
1 1 1 1 1 1
0 0 0 0 0 0 0 0 0 0 0 0 0
1 1 1 1 1 1
0 0 0 0 0 0 0 0 0 0 0 0 0
000 001 010 011 100 101 000
3 40 1 2 3 4
001 010 011 100
5 05 0 1 2 3 45 0 1 2
001 010 011 100 101101 000
Compteur asynchrone modulo 6
Init 0 0 0 0
Clk QC QB QA Dec
000
100
010
2 0 1 0 2
1 0 0 1 1
011
4 1 0 0 4
3 0 1 1 3
6 0 0 0 0
5 1 0 1 5
8 0 1 0 2
7 0 0 1 1
10 1 0 0 4
9 0 1 1 3
12 0 0 0 0
11 1 0 1 5
14 0 1 0 2
13 0 0 1 1
16 1 0 0 4
15 0 1 1 3
101
001
Compteur décimal asynchrone
Si nous voulons concevoir un compteur décimal qui peut compter de 0 à 9 (0000, 0001, …..1000, 1001), nous allons utiliser une compteur modulo 10
Étant donné que 10 n'est pas une puissance de 2, nous allons utiliser un compteur d'un modulo puissance de 2 supérieur à 10, soit 24 qui donne 16On ajoute à ce compteur un asservissement de l'entrée clear pour remettre le compteur à zéro à chaque fois qu'on atteint 1001 (9).Nous allons prendre le nombre qui vient immédiatement après 9 qui est en fait le module de notre compteur, (1010) 10.Nous écrivons l'expression logique suivante : Cr’ = Q3 Q2’ Q1 Q0’
0 0 1 1 2 2
0 1 2
3 3
3
0 1 2 3
Compteur décimal asynchrone
0 0 0 0 0
1 0 0 0 8
1 0 0 1 9
0 1 1 0 6
0 1 1 1 7
0 1 0 0 4
0 1 0 1 5
0 0 1 1 3
0
0
0
1
1
0
0
0
7
0 0 0 8
51 0 1
1 1
0 0 1 1 3
0
1 0 0 40
0 1 0 2
0 0 0 1 1
0
5
6
9
10
Q3 Dec
1
1
1
0
0
7
8
1
1
0 0 0
1 1
0 0
Q2 Q1 Q0
0 1
0 1 0
0
0
Q3
0
0
0
0
0
0 1
1 1 0
0
0
Q1 Q0
1 0 0
6
0 0 1 1
0 1 0 2
0 0 0 0
0 0 1 9
1 1 1
0
Dec
0 0 0 0
Q2
0
1 1 3
4
0 1 1
0 1 0 2
0
0 0 1 1 2 2
0 1 2
3 3
3
0 1 2 3
Compteur décimal asynchrone
Pour avoir 1 à la sortie de la porte NAND nous pouvons aussi nous passer de Q2 et de Q0et écrire Cr’=Q3 Q1, cela nous donnera le schéma suivant :
Compteur synchrone 2 bits JK
A la différence d'un compteur asynchrone, l'horloge du compteur synchrone attaque en même temps les entrées d'horloge de tous les flip flop
Il y a 5 étapes à suivre pour concevoir un tel compteur
1. Décider du nombre et du type de flip-flop à utiliser2. Dresser la table d'excitation des flip flop3. Faire le diagramme d'état et la table d'excitation du circuit4. Faire la simplification par Karnaugh des entrées5. Dessiner le circuit
Nous allons concevoir un compteur synchrone de 2 bits avec des bascule JK
Compteur synchrone 2 bits JK
Table d'excitation de la JK Table d'excitation du circuit
Qn Qn+1 J K Q1 Q2 Q1+ Q2+ J1 K1 J2 K2
0 0 0 x 0 0 0 1 0 x 1 x
0 1 1 x 0 1 1 0 1 x x 1
1 0 x 1 1 0 1 1 x 1 1 x
1 1 x 0 1 1 0 0 x 0 x 1
J1 Q1 Q1 K1 Q1 Q1 J2 Q1 Q1 K2 Q1 Q1
Q2 X Q2 X 1 Q2 X 1 Q2 X 1
Q2 1 X Q2 X Q2 1 X Q2 1 X
J1=Q2 K1=Q2 J2=1 K2=1
Diagramme d'état du circuit
S3=11
S0=00
S1=01
S2=10
Compteur synchrone 2 bits JK
Compteur synchrone 3 bits JK
Qn Qn+1 J K Q3 Q2 Q1 Q3+ Q2+ Q1+ J3 K3 J2 K2 J1 K1
0 0 0 x 0 0 0 0 0 1 0 X 0 X 1 X0 1 1 x 0 0 1 0 1 0 0 X 1 X X 11 0 x 1 0 1 0 0 1 1 0 X X 0 1 X1 1 x 0 0 1 1 1 0 0 1 X X 1 X 1
1 0 0 1 0 1 X 0 0 X 1 X1 0 1 1 1 0 X 0 1 X X 11 1 0 1 1 1 X 0 X 0 1 X1 1 1 0 0 0 X 1 X 1 X 1
J3 J2 J3
Q1 Q1 Q1
Q1 Q1 Q1
J3=K3=Q1 Q2 J2=K2=Q1 J1=K1=1
1
X
1 1 1
1 X X X1 X X X X 1
X X
Q3Q2Q3Q2 Q3Q2 Q3Q2 Q3Q2
X X
Q3Q2 Q3Q2 Q3Q2 Q3Q2 Q3Q2Q3Q2 Q3Q2
110
000
001
010
011
100
101
110
111
Compteur synchrone 3 bits JK
2
3
2
CLK
Compteur synchrone 3 bits T Attention :Ne jamais oublier que la sortie de la dernière bascule QC est le MSB et que QA est le LSB quand vous faites les tables d'excitation
Nous allons concevoir un compteur synchrone de 3 bits avec des bascule T S0=000
Table d'excitation de la T Table d'excitation du circuit S0=111
S0=001
Qn Qn+1 T QC QB QA QC+QB+ QA+ TC TB TA
0 0 0 0 0 0 0 0 1 0 0 1 S0=110
0 1 1 0 0 1 0 1 0 0 1 1
1 0 1 0 1 0 0 1 1 0 0 1 S0=010
1 1 0 0 1 1 1 0 0 1 1 1 S0=101
1 0 0 1 0 1 0 0 1 TC 1 0 1 1 1 0 0 1 1 S0=100 S0=011
QA 1 1 0 1 1 1 0 0 1QA 1 1 1 0 0 0 1 1 1
TBQA
QA
TA
QA
QA
1QC QB
TC = QAQB
TB = QA
1
1 1 1 1TA = 1
QC QB QC QB
1 1
QC QB QC QB QC QB
1 1
1QC QB
1
1 1
QC QB QC QB QC QB QC QB
QC QB
T
Compteur/décompteur synchrone 3 bits JKTable d'excitation de la JK
Qn Qn+1 J K Table d'excitation du circuit
0 0 0 X
0 1 1 X Top M Q2 Q1 Q0 Q2+ Q1+ Q0+ J2=K2J1=K1 J0=K0
1 0 X 1 0 0 0 0 0 0 0 1 0 0 1
1 1 X 0 Compteur 1 0 0 0 1 0 1 0 0 1 1 Décompteur
2 0 0 1 0 0 1 1 0 0 1
3 0 0 1 1 1 0 0 1 1 1
4 0 1 0 0 1 0 1 0 0 1
5 0 1 0 1 1 1 0 0 1 1J2=K2 = Q0 Q1 6 0 1 1 0 1 1 1 0 0 1 J2=K2 = Q0 Q1
7 0 1 1 1 0 0 0 1 1 1
0 1 1 1 1 1 1 0 0 0 1
1 1 1 1 0 1 0 1 0 1 1J1=K1 = Q1 2 1 1 0 1 1 0 0 0 0 1 J1=K1 = Q0
3 1 1 0 0 0 1 1 1 1 1
4 1 0 1 1 0 1 0 0 0 1
5 1 0 1 0 0 0 1 0 1 1
6 1 0 0 1 0 0 0 0 0 1J0=K0 = 1 7 1 0 0 0 1 1 1 1 1 1 J0=K0 = 1
J0=K1=1 J0=K1=1
J1=K1=Q0 J1=K1=Q0
J2=K2=Q0 Q1 J2=K2=Q0 Q1
J0=K0=1 ou J0=K0=1 J0=K0=1 ou J0=K0=1
Ji=Ki=Q0.Q1…Qi-1 Ji=Ki=Ji-1.Qi-1 Ji=Ki=Q0.Q1…Qi-1 Ji=Ki=Ji-1.Qi-1
J2=K2 Q0 Q1 Q0 Q1 Q0 Q1 Q0 Q1 Q0 Q1 Q0 Q1 Q0 Q1 Q0 Q1J2=K2
1 0
1 0
Q2 0 0 1 0
Q2 0 0 1 0
Q2 0
Q0 Q1 Q0 Q1
Q2 1 1 1 1
1
J0=K0 Q0 Q1 Q0 Q1
Q2 0 1
J1=K1 Q0 Q1 Q0 Q1 Q0 Q1 Q0 Q1
Q2 1 1 1 1
1 0 0 0
Q2 1 0 0 0
Q2
Q0 Q1 Q0 Q1 Q0 Q1 Q0 Q1
Q2 1 1
J1=K1
1 1
J0=K0 Q0 Q1 Q0 Q1 Q0 Q1 Q0 Q1
Q2
1 1 1 1
Q2 1 1 1 1
Q2
000
001
010
011
100
101
110
111
Compteur / décompteur synchrone 3 bits JK
0
0 0
1
1 1
2
2 2
n
n n
0
0 0
1
1 1
n
n n
2
2 2
Compteur / décompteur synchrone 3 bits JK
Compteur / décompteur synchrone 3 bits JKTable d'excitation de la T
Qn Qn+1 T Table d'excitation du circuit
0 0 0
0 1 1 M QC QB QA QC+ QB+ QA+ TC TB TA
1 0 1 0 0 0 0 0 0 1 0 0 1
1 1 0 0 0 0 1 0 1 0 0 1 1
0 0 1 0 0 1 1 0 0 1
0 0 1 1 1 0 0 1 1 1
0 1 0 0 1 0 1 0 0 1
0 1 0 1 1 1 0 0 1 1
0 1 1 0 1 1 1 0 0 1
0 1 1 1 0 0 0 1 1 1
1 0 0 0 1 1 1 1 1 1
1 0 0 1 0 0 0 0 0 1
1 0 1 0 0 0 1 0 1 1
1 0 1 1 0 1 0 0 0 1
1 1 0 0 0 1 1 1 1 1
1 1 0 1 1 0 0 0 0 1
1 1 1 0 1 0 1 0 1 1
1 1 1 1 1 1 0 0 0 11
TB= QB M + QB M
TA=1
M QC
M QC
M QC 1 0 0
0 0 1
QA QB
M QC
M QC
TC= QA QB M + QA QB M
TB
TC
M QC
M QC
QA QBQA QB QA QB
0
0
0
1
1
M QC
0 1 1 0
0
0
0
0
0
0 01
1
QA QB QA QB QA QB QA QB
0 1 1 0
0
01
000
001
010
011
100
101
110
111
Compteur / décompteur synchrone 3 bits JK
A A
B B
C C
Compteur / décompteur synchrone 3 bits JK
A A
B B
C C
A B C
Compteur en anneau de 4 bits utilisant des bascules D "Ring counter"Un ring counter est un compteur synchrone différente des compteurs classiques
Ce compteur utilise les flip flop D comme les registre à la place des JK et des T généralement utilisés pour les compteur
Le nombre d'état du compteur est égale au nombre de flip flop utilisés et non de 2 levé à leur puissance
Vous remarquerez que les entrées synchrones Clear et Preset sont utilisées.
Preset pour le premier flip flop et clear pour les flip flop suivants.
Avec Pr activé nous avons Preseté la bascule FF-0 ce qui donne Q0=1
Avec Clr activé nous avons Reseté les bascule FF-1, FF-2, FF-3 ce qui donne Q1=Q2=Q3=0
La sortie de la bascule FF-3 est l'entrée de la bascule FF-1
Quatrième Top Q3=1 donne D0=1 donne Q0=1 Q0=0 donne D1=0 et Q1=0 Q1=0 donne D2=0 et Q2=0 Q2=0 donne D3=0 et Q3=0
Troisième Top Q3=0 donne D0=0 donne Q0=0 Q0=0 donne D1=0 et Q1=0 Q1=0 donne D2=0 et Q2=0 Q2=1 donne D3=1 et Q3=1
Deuxième Top Q3=0 donne D0=0 donne Q0=0 Q0=0 donne D1=0 et Q1=0 Q1=1 donne D2=1 et Q2=1 Q2=0 donne D3=0 et Q3=0
Premier Top Q3=0 donne D0=0 donne Q0=0 Q0=1 donne D1=1 et Q1=1 Q1=0 donne D2=0 et Q2=0 Q2=0 donne D3=0 et Q3=0
Etat initial PR active Q0=1 CLR active Q1=0 CLR active Q2=0 CLR active Q3=0
0 0
1 1
2 2
3 3
R-PR
R
R R R R
Compteur en anneau de 4 bits utilisant des bascules D "Ring counter"
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
1 1 1 1 1
0 0 0 0 0 0 0 0 0 0 0 0
1 1 1 1
0 0 0 0 0 0 0 0 0 0 0 0 0
1 1 1 1
0 0 0 0 0 0 0 0 0 0 0 0 0
1 1 1 1
0 0 0 0 0 0 0 0 0 0 0 0 0
Compteur en anneau de 4 bits utilisant des bascules D "Ring counter"
1
1
1
ORD
1
1
1
1
10000100
7 1 0 0 0 8
6 0 1 0 0 4
5 0 0 1 0 2
4 0 0 0 1 1
3 1 0 0 0 8
00102 0 1 0 0 4
1 0 0 1 0 2
0001
1
Clk Q3 Q2 Q1 Q0 Dec
x 0 0 0 1
Le compteur en anneau de 4 bits utilisant des bascules D "Johnson Ring Counter"
Le compteur Johnson est une variante du ring counter.
Ce compteur utilsie les flip flop D comme les régistre à la place des JK et des T généralement utilisés pour les compteur
Le nombre d'état du compteur est égale 2 fois le nombre de flip flop utilisés
Vous remarquerez que l'entrée synchones Clear est utilisée dans touts les flip flop
Avec Clr activé nous avons reseté toutes les bascule ce qui donne Q0=Q1=Q2=Q3=0, donc Q3barre=1
La sortie Q3barre de la bascule FF-3 est l'entrée D0 de la bascule FF-1
Le compteur en anneau de 4 bits utilisant des bascules D "Johnson Ring Counter"
D Q D Q D Q D Q0 0 0 00 0 0 10 0 1 10 1 1 11 1 1 11 1 1 01 1 1 01 0 0 0
Init 0 0 0 0
0 0
1 1
2 2
3 3
R
R R R R
0 1
1 2 0 0 1 1
Q0
x 0 0 0 0
ORD Clk Q3 Q2 Q1
1 1 0 0
1 4 1 1 1 1
1 3 0 1 1 1
1 6 1 1 0 0
1 5 1 1 1 0
1 8 0 0 0 0
1 7 1 0 0 0
Compteur en anneau de 4 bits utilisant des bascules D "Ring counter"