Disposition du titre - Université du Sahel

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


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


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


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


décompteur asynchrone de 4 bits utilisant des bascule T


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


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


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




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



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.



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)


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


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


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


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


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


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


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 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


A A

B B

C C


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


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

Disposition du titre - Université du Sahel

Documents

Transcript of Disposition du titre - Université du Sahel