Cours strm mme_touil_all

Ministère de l’Enseignement Supérieur et de la Recherche Scientifique Université Alger 1

Faculté des sciences

Département Mathématiques Informatique

Rédigée par Mme TOUIL Page 1

Chapitre 1 : Les Circuits Combinatoires

Introduction

Les circuits logiques sont à la base de tout matériel électronique, en particulier les ordinateurs. Nous

ne pouvons pas comprendre la structure ni le fonctionnement d’une machine électronique sans comprendre

le fonctionnement de ses circuits logiques de base.

Il existe deux types de circuits logiques :

- Circuits logiques combinatoires

- Circuits logiques séquentiels

1.1 Définition d’un circuit logique combinatoire

Un circuit combinatoire est un circuit numérique dont les sorties dépendent uniquement des entrées.

Il est constitué de portes logiques, elles reçoivent des signaux appliqués en entrée et produisent des

signaux en sortie.

Ainsi, une information binaire transmise en entrée est transformée en une autre information demandée en

sortie. Cela permet de schématiser un circuit combinatoire comme suit :

C’est possible d’utiliser des circuits combinatoires pour réaliser d’autres circuits plus complexes.

1.2 Exemple de Circuits Combinatoire

- Demi-Additionneur

- Additionneur complet

- Comparateur

- Multiplexeur

- Démultiplexeur

- Encodeur

- Décodeur

Variables

d’entrée Circuit

Combinatoire

Variables

de sortie





1.3 Additionneur et Demi-Additionneur

Un Additionneur est un circuit combinatoire qui est un élément fondamental de toute unité de

traitement, son rôle est d’additionner des bits.

L’addition de deux nombres binaires s’accomplit en additionnant les bits de même rang en

commençant par les bits les moins forts en allant vers ceux des rangs les plus forts.

a- Demi-Additionneur

Un tel circuit doit présenter :

Des entrées (les nombres à additionner en binaire).

Une sortie (résultat).

Une retenue.

L’addition de deux nombres d’un bit nous donne le circuit appelé demi-additionneur :

Sa table de vérité est :

A B S R

0 0 0 0

0 1 1 0

1 0 1 0

1 1 0 1

Où S est la somme et R est la retenue

Avec et

Logigramme :

b- Additionneur Complet

En binaire lorsque on fait une addition, il faut tenir en compte de la retenue entrante

- L’additionneur complet un bit possède 3 entrées :

: le premier nombre sur un bit.

: le deuxième nombre sur un bit.

: la retenue entrante sur un bit.

- Il possède deux sorties :

: la somme.





: la retenue sortante

Sa table de vérité :

0 0 0 0 0

0 0 1 1 0

0 1 0 1 0

0 1 1 0 1

1 0 0 1 0

1 0 1 0 1

1 1 0 0 1

1 1 1 1 1

Logigramme :

ai bi

Ri-1

Si

Ri





1.4 Comparateur

Un comparateur est un circuit combinatoire qui permet de comparer entre deux nombres binaires A et B.

a- Comparateur sur 1 bit

- Il possède 2 entrées :

A : sur 1 bit.

B : sur 1 bit.

- Il possède 3 sorties :

Fe : égalité (A=B).

Fi : inférieur (A<B)

Fs : supérieur (A>B).


A B Fi Fe Fs

0 0 0 1 0

0 1 1 0 0

1 0 0 0 1

1 1 0 1 0

Logigramme :





b- Comparateur sur 2 bits

Il permet de faire la comparaison entre deux nombres A(A1A0) et B(B1B0) chacun sur deux bits.


A1 A0 B1 B0 Fi Fe Fs

0 0 0 0 0 1 0

0 0 0 1 1 0 0

0 0 1 0 1 0 0

0 0 1 1 1 0 0

0 1 0 0 0 0 1

0 1 0 1 0 1 0

0 1 1 0 1 0 0

0 1 1 1 1 0 0

1 0 0 0 0 0 1

1 0 0 1 0 0 1

1 0 1 0 0 1 0

1 0 1 1 1 0 0

1 1 0 0 0 0 1

1 1 0 1 0 0 1

1 1 1 0 0 0 1

1 1 1 1 0 1 0

Sachant que les sorties d’un comparateur 1 bit sont les suivantes :

Donc les sorties d’un comparateur 2 bits sont comme suit :





c- Comparateur 2 bits avec des entrées de mise en cascade

On remarque que :

- Si A2 > B2 alors A > B

- Si A2 < B2 alors A < B

- Par contre si A2=B2 alors il faut tenir compte du résultat de la comparaison des bits du rang

faible.

- Pour cela, on rajoute au comparateur des entrées qui nous indiquent le résultat de la

comparaison précédente.

- Ces entrées sont appelées des entrées de mise en cascade.

- Il va avoir une entrée de supérieur, une entrée d’inférieur et une entrée d’égalité

Le schéma général d’un tel comparateur est :

A B

Ecs Ece Eci

Fs Fe Fi

Comparateur





Si on veut réaliser un comparateur 2bits avec 2 comparateur 1 bit avec des entrées mises en cascade :

La table de vérité correspondante est :

Fs=1 si (A1>B1)ou (A1=B1 et A0>B0) or la fonction de sortie de A0>B0 est Ecs=1

Fi=1 si (A1<B1)ou(A1=B1 et A0<B0) or la fonction de sortie de A0<B0 est Eci=1

Fe=1 si (A1=B1 et A0=B0) or la fonction de sortie de A0=B0 est Ece=1

Les entrées en cascade Ecs, Ece et Eci sont des sorties d’un comparateur 1 bit des bits du rang faible.

A1 A0 B1 B0 Ecs Ece Eci Fs Fe Fi

0 0 0 0 0 1 0 0 1 0 A1=B1 et A0=B0 A1=B1 et A0<B0 0 0 0 1 0 0 1 0 0 1

0 0 1 0 X X X 0 0 1 A1<B1 → A<B

0 0 1 1 X X X 0 0 1

0 1 0 0 1 0 0 1 0 0 A1=B1 et A0>B0 A1=B1 et A0=B0 0 1 0 1 0 1 0 0 1 0

0 1 1 0 X X X 0 0 1 A1<B1 → A<B

0 1 1 1 X X X 0 0 1

1 0 0 0 X X X 1 0 0 A1>B1 →A>B

1 0 0 1 X X X 1 0 0

1 0 1 0 0 1 0 0 1 0 A1=B1 et A0=B0 A1=B1 et A0<B0 1 0 1 1 0 0 1 0 0 1

1 1 0 0 X X X 1 0 0 A1>B1 →A>B

1 1 0 1 X X X 1 0 0

1 1 1 0 1 0 0 1 0 0 A1=B1 et A0>B0

1 1 1 1 0 1 0 0 1 0 A1=B1 et A0=B0

A0 B0 A1 B1

Fs0 Fe0 Fi0

Fs1 Fe1 Fi1

Comparateur Comparateur





1.5 Multiplexeur

Définition : le multiplexage consiste à envoyer sur une même ligne de transmission des informations

provenant de sources différentes. Exemple : ligne téléphonique

Principe : Un multiplexeur (MUX) est généralement un circuit constitué d’un ou plusieurs qui reçoit N

entrées et transmet par sa sortie une de ses entrées au choix. Pour sélectionner cette entrée le

multiplexeur reçoit une adresse codée. On pourra de plus trouver une entrée de validation.

Un multiplexeur dispose de :

2n entrés.

1 sortie.

N lignes de sélections (d’adresse)

1 validation.

a- Multiplexeur 2x1

Ce multiplexeur dispose de :

21 entrées E1 et E0

1 sortie S

1 ligne de commande ou de sélection C

1 validation V


V C S

1 0 E0

1 1 E1

0 X 0 MUX non validé

Sa fonction de sortie est :

E1 E0

V C

S

MUX 2x1





Logigramme :

b- Multiplexeur 4x1

Ce multiplexeur à 4 entrées, appelé aussi MUX 4x1


4 entrées de données E0, E1, E2 et E3

2 entrées d’adresses A0 et A1

1 sortie S

1 entrée de validation V.

Le multiplexeur consiste à envoyer sur une même ligne de transmission des informations provenant des

sources differentes.

S=E0 si A0=0 et A1=0 et V=1








Sa table de fonctionnement est la suivante :

V A1 A0 S

1 0 0 E0

1 0 1 E1

1 1 0 E2

1 1 1 E3

0 X X 0 MUX non validé

Equation de S :

Les lignes d’adresse (de séléction ou de commande ) determinent quelle entrée se retrouve en sortie ; de ce

faite, on dira qu’un multiplexeur est un sélécteur de données .

Exercice : verifier que le Multiplexeur 4x1 peut etre obtenu par 3 Multiplexeur 2x1.

Solution :

Prenons l’equation de sortie du MUX 4x1 en le supposant valide :

Or : est un MUX 2x1 avec E0 et E1 comme etant les entrées, A0 la ligne de

commande.

De même pour : est un MUX 2x1 avec E2 et E3 comme etant les entrées, A0 la ligne

de commande.

Circuit :

E3 E2 E1 E0

A0

A1

S

MUX 2X1 MUX 2X1

MUX 2X1





c- Multiplexeur 8X1 (MUX 8x1)


23 = 8 entrées de données E0, E1, E2,E3,E4,E5,E6 et E7

3 entrées d’adresses A0 , A1 et A2

1 sortie S

1 entrée de validation V.

Sa table de fonctionnement est :

V A2 A1 A0 S

1 0 0 0 E0

1 0 0 1 E1

1 0 1 0 E2

1 0 1 1 E3

1 1 0 0 E4

1 1 0 1 E5

1 1 1 0 E6

1 1 1 1 E7

0 X X X 0 MUX non validé

Execice 1 : verifier qu’on peut obtenir un MUX 8x1 en utilisant 2 MUX 4x1 et 1 MUX 2x1

Solution : prenons l’expression algébrique S d’un MUX 8x1





Exercice 2:

Réaliser un additionneur complet 1 bit avec des multiplexeur 8x1.

d- Mulriplexeur 16x1


24=16 entrées de données E0, E1,…, E14, E15.

4 entrées d’adresses A0, A1, A2, A3

1 sortie S.

1 entrées de validation

1.6 Démultiplexeur

Il joue le rôle inverse d’un multiplexeur , il permet de faire passer une information dans l’une dessortes

selon les valeurs des entrées de commandes.

Il possède :

Une seule entrée

2n sorties.

n entrées de selections ( commandes)

a- Démultiplexeur 1x2

Appelé aussi DMUX 1x2.

Ce DMUX possede :

1 entrée E

2 sorties S0 et S1

1 ligne de commande C

1 entrée de validation

E7 E6 E5 E4 E3 E2 E1 E0

A0

A1 MUX 4x1 MUX 4x1

MUX 2x1 A2

S






V C S0 S1

1 0 E 0

1 1 0 E

0 X 0 0 DMUX non validé

Sa fonction de sortie est :

b- Démultiplexeur 4x1

Un Démultiplexeur à 4 sorties, appelé aussi DMUX 4x1

Ce démultiplexeur possède :

1 seule entrée.

1 entrée de validation.

4 sorties

2 entrées de commandes.

Le démultiplexage consiste à répartir sur plusieurs lignes des informations qui arrivent en série sur une même ligne. S0=E si A0=0 et A1=0 et V=1 S1=E si A0=1 et A1=0 et V=1 S2=E si A0=0 et A1=1 et V=1 S3=E si A0=1 et A1=1 et V=1

E

V C

S1 S0

DMUX 2x1





Sa table de fonctionnement est :

V A1 A0 S0 S1 S2 S3

1 0 0 E 0 0 0

1 0 1 0 E 0 0

1 1 0 0 0 E 0

1 1 1 0 0 0 E

0 X X 0 0 0 0 DMUX non validé

Les équations de sorties :

c- Demultiplexeur 1x8

Est un demultiplexeur à 8 sorties

Ce multiplexeur possede :

1 entrée de données E,

3 lignes d’adresse (de séléction ou de commande) A0, A1 et A2,

1 ligne de validation V et

8 sorties S0, S1, S2, S3, S4, S5, S6 et S7

S0 S1 S2 S3 S4 S5 S6 S7

V

E

A0 A1 A2

DMUX 1x8





1.7 Décodeur

Définition 1 : C’est un circuit logique comportant n entrées et 2n sorties. Lorsque le signal de validation est actif,

seule la sortie dont le numéro correspond à la valeur binaire affichée sur l’entrée est active. Toutes les autres sont

inactives.

Définition 2 : Un décodeur est circuit combinatoire qui traduit l’information binaire presente sur n lignes

d’entrées et l’utilise pour mettre à l’etat 1 l’une et seulement de ses 2n lignes de sortie. Un décodeur est

dit de type n vers 2n.

Définition 2 : C’est un circuit logique comportant n entrées et 2n sorties. Lorsque le signal de validation

est actif, seule la sortie dont le numéro correspond à la valeur binaire affichée sur l’entrée est active.

Toutes les autres sont inactives.

Exemple :

Nous pouvons citer le clavier d’une porte automatique

Le décodeur BCD/Afficheur 7 segments.

Le décodeur est un circuit très employé dans les microprocesseurs. Son rôle est de sélectionner entre

autres, une adresse précise de mémoire parmi un lot important d’adresses différentes.

Supposez qu’il faille aller chercher dans une mémoire d’une capacité de 1024 mots, un mot donné situé

à une adresse bien précise. Il n’est pas question d’adresser les 1024 mots différents contenus dans la

mémoire. Cela nécessiterait 1024 fils. Pour résoudre ce problème il ne faut relier le microprocesseur que

par 10 fils, car c’est un mot de 10 bit qui permet d’adresser 1024 places (210 = 1024). Il nous faudra alors

un décodeurs 10 entrées et 1024 sorties

a- Décodeur 2 vers 4 ou 1 parmi 4

Ce décodeur possède :

2 entrées A et B

4 sorties D0, D1, D2, D3

V

A

B

D0 D1 D2 D4

Décodeur






V A B D0 D1 D2 D3

0 x x 0 0 0 0

1 0 0 1 0 0 0

1 0 1 0 1 0 0

1 1 0 0 0 1 0

1 1 1 0 0 0 1

Les équations de sortie :

Logigramme

b- Décodeur 3 vers 8 ou 1 parmi 8

Ce décodeur possède :

3 entrées A, B et C

8 sorties D0, D1, D2, D3, D4, D5, D6, D7

V

A

B

C

D0 D1 D7

Décodeur





Table de vérité :

V A B C D0 D1 D2 D3 D4 D5 D6 D7

0 X X X 0 0 0 0 0 0 0 0

1 0 0 0 1 0 0 0 0 0 0 0

1 0 0 1 0 1 0 0 0 0 0 0

1 0 1 0 0 0 1 0 0 0 0 0

1 0 1 1 0 0 0 1 0 0 0 0

1 1 0 0 0 0 0 0 1 0 0 0

1 1 0 1 0 0 0 0 0 1 0 0

1 1 1 0 0 0 0 0 0 0 1 0

1 1 1 1 0 0 0 0 0 0 0 1

Ses equations de sortie :

1-8 Codeur (ou l’encodeur)

Le codeur réalise la fonction inverse du décodeur, c'est-à-dire à une entrée active (etat 1), parmi les

2n entrées, il fait correspondre en sortie un code sur n lignes (bits).

Un encodeur est système qui comporte N lignes d’entré et n lignes de sorties. Lorsqu’une des lignes d’entré est

activité l’encodeur fournit en sortie un mot de n bit correspondant au codage de l’information identifié par la ligne

activée.

a- Codeur élémentaire à 2bits : 4 vers 2 ou bien 4→2

Il possede :

4 entrées

1 ligne de validation

2 sorties

V

D0 D1 D2 D4

Codeur

A B





Table de vérité

V D0 D1 D2 D3 A B

0 0 0 0 0 X X

1 1 0 0 0 0 0

1 0 1 0 0 0 1

1 0 0 1 0 1 0

1 0 0 0 1 1 1


A=D2+D3 ; B=D1+D3

Logigramme :

les lignes d’entrées (D0 à D3) sont toujours à l’état 0 sauf une d’entre elles (etat 1), les sorties (A,B) dont

sont toujours à l’état 0 sauf si une entrée (autre que D0) est activée.

b- Codeur à 3 bits : 8 vers 3 ou bien 8→3

D0 D1 D7

Codeur

A

B

C





Table de vérité :

V D0 D1 D2 D3 D4 D5 D6 D7 A B C

0 0 0 0 0 0 0 0 0 X X X

1 1 0 0 0 0 0 0 0 0 0 0

1 0 1 0 0 0 0 0 0 0 0 1

1 0 0 1 0 0 0 0 0 0 1 0

1 0 0 0 1 0 0 0 0 0 1 1

1 0 0 0 0 1 0 0 0 1 0 0

1 0 0 0 0 0 1 0 0 1 0 1

1 0 0 0 0 0 0 1 0 1 1 0

1 0 0 0 0 0 0 0 1 1 1 1


A= D4+D5+D6+D7

B=D2+D3+D6+D7

C=D1+D3+D5+D7

c- Transcodeur

Definition : Un transcodeur est un circuit combinatoire qui permet de faire passer une information

écrite dans le code C1 sur n lignes à un autre code C2 sur n lignes.

les deux plus importantes applications des transactions sont : le conversion de code et l’affiichage par

segment.

Exemple : conversion de code : transcodeur Gray- Binaire

Pour passer d’un code à un autre, on utilisera un convertisseur de code.

Cherchons le circuit d’un transcodeur qui permet de convertir le code Gray à 3 bits en code binaire.

La table de conversion Gray-Binaire est donnée par le tableau suivant :

Gray Binaire

G2 G1 G0 B2 B1 B0

0 0 0 0 0 0

0 0 1 0 0 1

0 1 0 0 1 1

0 1 1 0 1 0

1 0 0 1 1 1

1 0 1 1 1 0

1 1 0 1 0 0

1 1 1 1 0 1





On utilisera le tableau de Karnaugh pour obtenir l’expression logique simplifiée de Bi

Expression de B2

G1G0 G2

00 01 11 10

0 0 0 0 0

1 1 1 1 1

Expression de B1

G1G0 G2

00 01 11 10

0 0 0 1 1

1 1 1 0 0

Expression de B0

G1G0 G2

00 01 11 10

0 0 1 0 1

1 1 0 1 0

Logigramme



Département Mathématiques Informatique Module : Structure Machine / S2

Chargée de cours/TD : Mme TOUIL Page : 1 Année universitaire : 2015/2016

Chapitre 2 : Introduction à l’Architecture des ordinateurs

2.1 Introduction

Le mot «ordinateur» a été créé en 1955 pour designer une machine capable, dans la limite de

ses capacités en espace mémoire (nécessairement finies) et en vitesse de calcul, d'exécuter n'importe

quel algorithme qu'on lui fournit sous forme de programme, sur n'importe quelle donnée discrète,

qu'on lui fournit également.

Il se distingue ainsi fondamentalement d'une simple machine à calculer par sa capacité

à enchaîner plusieurs opérations en suivant des instructions paramétrables. Toute la difficulté de

conception d'un ordinateur vient donc de cette nécessité de lui faire exécuter des suites d'opérations,

en synchronisant l'action de ses différents composants.

C’est une machine qui traite l’information fournie par un composant d’entrée suivant un

programme et délivre une information sur un composant de sortie

2.2 Les composants d’un ordinateur

Le cœur d'un ordinateur est constitué :

D’une Unité Centrale (UC), ou «microprocesseur» ;

Des mémoires, parmi lesquelles on distingue plusieurs types :

o La mémoire ROM (Read Only Memory : mémoire à accès en lecture seule) : ensemble de bits

dont l'état est fixé une fois pour toute, lors de la construction de l'ordinateur. Elle sert à stocker

des informations permanentes (procédures de démarrage...) ;

o La mémoire RAM ou «mémoire vive» (Random Access Memory : mémoire à accès aléatoire) :

ensemble de bits modifiables à volonté, où se trouvent stockées les données sur lesquelles

travaille l'ordinateur. Cette mémoire est volatile, c'est-à-dire qu'elle ne conserve les données

que tant que la machine est sous tension. La mémoire vive des meilleurs ordinateurs actuels

atteint 1Giga-octet.

o les mémoires secondaires ou auxiliaires : ce sont des dispositifs permettant de stocker des bits

de façon stable (qui reste fixée même si on éteint la machine) tout en étant généralement

modifiable. On peut inclure parmi elles les disques durs, les disquettes, les bandes

magnétiques, les clés USB... La capacité des disques durs actuels se compte en Giga-octets.





Les autres composants sont donc :

soit des périphériques d'entrée, c'est-à-dire permettant à un utilisateur extérieur de fournir des

informations (données/programmes) à la machine sous forme numérique : souris, clavier,

scanner, joystick, appareil photo numérique, caméscope numérique... Ces dispositifs peuvent

tous être conçus comme des numériseurs puisqu'ils transforment un comportement (l'appui sur

la touche d'un clavier, le mouvement de la souris) ou un objet (une photo analogique pour le

scanner, un paysage pour les appareils de prise de vue numérique !) en une suite de bits.

soit des périphériques de sortie, c'est-à-dire permettant de visualiser ou de transmettre des

données internes à l'extérieur : écran, imprimante, IPod, vidéo-projecteur... A l'inverse des

numériseurs, ces dispositifs traduisent des suites de bits en information interprétable par les

humains.

La logique de cette organisation est donc celle de la figure suivante :

Figure 1 : Organisation générale d'un ordinateur

2.3 L'architecture de Von Neumann

Entrons maintenant dans l'organisation interne du cœur de notre ordinateur.

Si Turing peut être considéré comme le père de l'informatique théorique, l'homme à l'origine de la

conception des ordinateurs actuels est John Von Neumann. Von Neumann, né en Hongrie, était un très

grand mathématicien, ayant laissé sa trace dans de nombreux domaines, y compris en physique

(quantique) et en économie (théorie des jeux). D'origine juive, il a émigré aux Etats Unis dans les

années 1930. En 1935, il a accueilli dans son Université de Princeton, pour un stage universitaire, un

certain Alan Turing. Les deux hommes se connaissaient donc mais n'ont jamais pour autant travaillé

ensemble à la réalisation d'un ordinateur. Pendant la guerre, Von Neumann, a participé au projet

«Manhattan», qui a donné lieu à la bombe atomique américaine, en se consacrant particulièrement

aux calculs balistiques. Sensibilisé par cette expérience à l'intérêt des calculateurs automatiques, il a

ensuite travaillé avec des ingénieurs à la conception d'un tel calculateur. En 1945, il a écrit à leur

intention un rapport où il détaillait les principes qui devaient selon lui présider à la réalisation d'une





machine universelle (un ordinateur, donc). Ces principes sont depuis connus sous le nom

«d'architecture de Von Neumann», et sont ceux encore utilisés de nos jours pour la conception des

ordinateurs actuels.

Le schéma général (très simplifié) de l'architecture de Von Neumann est celui de la figure suivante :

Figure 2 : Architecture de Von Neumann

Les deux innovations majeures introduites par Von Neumann par rapports aux calculateurs existant à

son époque sont, ainsi, l'intégration :

d'une «unité de commande» qui donne les ordres et synchronise les opérations ;

d'une mémoire centrale interne permettant de stocker aussi bien des données que des

programmes.

Pour bien comprendre comment fonctionne un ordinateur, il nous faut détailler chacun des

composants de cette architecture.

2.3.1 La mémoire centrale (RAM)

La mémoire vive d'un ordinateur est composée d'un ensemble de «mots mémoire», qui sont

des suites de bits de taille fixe. Chaque mot mémoire est identifié par son «adresse». Celle-ci est

indispensable pour référencer chaque mot mémoire et ainsi retrouver ce qui a été préalablement

stocké dans l'un d'eux. L'adresse est simplement un code, donc une autre suite de bits. Le nombre de

bits réservé au codage de l'adresse doit évidemment être suffisant pour permettre d'associer une

adresse différente à chaque mot mémoire. La figure suivante montre un exemple de mémoire RAM

(ultra simple) constituée de 16 mots mémoire de 2 octets chacun (le contenu de la mémoire n'est pas

représenté). Chaque mot mémoire a donc une adresse comprise entre 0 et 15.





Figure 3 : Structure d'une RAM élémentaire

Une particularité fondamentale de la mémoire centrale, dans l'architecture de Von Neumann, c'est

qu'elle sert à stocker indifféremment aussi bien des bits codant des données que des bits codant des

traitements, des instructions. Il n'y a pas de distinction entre les deux, pas de séparation. Cette

capacité à coder avec des 0/1 aussi bien des données que des traitements, c'est le fondement de

l'informatique.

2.3.2 L'unité de commande

Elle est composée de deux «registres». Un registre est simplement une petite unité de mémoire

vive (un ensemble de bits, donc, encore !), d'accès rapide. Les deux registres de l'unité de commande

sont :

le compteur ordinal (ou CO) : ce registre sert à stocker en permanence l'adresse où se trouve en

mémoire centrale interne l'instruction en train d'être exécutée (on dit aussi «l'instruction

courante»). Sa taille coïncide donc avec la taille des adresses de la mémoire (4 bits dans notre

exemple) ;

le registre d'instruction (ou RI) : il sert à stocker en permanence l'instruction en train d'être

exécutée (ou «instruction courante»). Sa taille est donc la même que celle d'un mot mémoire.

On peut représenter l'unité de commande de notre machine rudimentaire comme dans la figure

suivante :

Figure 4 : Structure de l'unité de commande





Détaillons maintenant de quoi est composée une instruction élémentaire, telle qu'elle peut être

stockée dans un mot mémoire ou dans le registre d'instruction. Une telle instruction est en fait

constituée de 4 parties. Dans notre exemple, chaque partie tiendra donc sur ½ octet soit 4 bits.

Nous détaillerons simplement le codage des instructions élémentaires de type arithmétique (addition,

soustraction, multiplication, division). Les 4 parties du code de l'instruction ont alors la signification

suivante : :

Code instruction Adresse donnée1 Adresse donnée2 Adresse résultat

la première partie « code instruction » : est le code de l'opération à effectuer. Dans notre

exemple, nous nous contenterons des 4 opérations arithmétiques de base et nous nous fixons

la convention suivante : 0000 code l'addition, 0001 la multiplication, 0010 la soustraction et

0011 la division. Il reste des codes disponibles pour d'autres opérations possibles.

la deuxième et la troisième partie, notées « Adresse donnée1 » et « Adresse donnée2 » :

contiennent l'adresse mémoire où se trouvent stockées respectivement la première et la

deuxième donnée (dans cet ordre) sur lesquelles l'opération arithmétique doit être effectuée ;

la quatrième partie, notée « Adresse résultat » : est l'adresse mémoire où doit être stocké le

résultat de l'opération.

Ainsi, par exemple, «0011 1001 0011 0001» est l'instruction d'effectuer une division (code 0011) entre

le nombre stocké dans le mot mémoire d'adresse 9 (code 1001) et celui stocké à l'adresse 3 (code

0011) et de stocker le résultat dans le mot mémoire d'adresse 1 (code 0001).

2.3.3 L'horloge

L'horloge de l'Unité Centrale est un métronome électronique qui lance des «tops» ou

« impulsions » à intervalles de temps réguliers. Ces «tops d'horloge» donnent la cadence à laquelle

travaille l'ordinateur et permettent à l'ensemble des composants de l'Unité Centrale de se

synchroniser.

Plus les tops sont rapprochés, plus l'ordinateur est rapide. La fréquence de l'horloge se compte en

nombre de tops par secondes, dont l'unité de mesure est le Hertz, ou plutôt le Mega-Hertz MH (1MH =

106Hertz





2.3.4 L'unité de traitement

L'unité de traitement est le composant qui exécute les calculs. Il est lui-même composé de :

Trois registres, servant respectivement à stocker les données (que nous notons donnée 1 et

donnée 2) d'une opération arithmétique et son résultat : leur taille est celle d'un mot mémoire

(2 octets dans notre exemple) ;

L'Unité Arithmétique et Logique (UAL) capable, quand on lui fournit le code d'une opération

arithmétique à exécuter, de prendre les contenus des deux premiers registres (ceux contenant

les données 1 et 2) et de remplir le troisième registre avec le résultat de cette opération.

L'unité de traitement se représente habituellement comme dans la figure suivante :

Figure 5 : Structure de l'unité de traitement

L'UAL est ainsi la «machine à calculer» de l'ordinateur (dans notre exemple : simplement les 4

opérations arithmétiques de base).

2.3.5 Les bus

Les flèches reliant les composants entre eux sont en fait des ensembles de fils permettant de

transporter plusieurs bits en parallèle. On les appelle pour cela des bus.

Dans le schéma de la figure 1, figurent ainsi 3 bus dont les noms désignent le type de données

qu'ils transportent. Le bus «ordres» sert à transmettre les demandes d'exécution d'opérations de

l'unité de commande vers l'unité de traitement. Le bus «instructions» fait transiter les instructions

élémentaires des mots mémoire vers le registre d'instruction de l'unité de commande, et le bus

«données/résultats» fait circuler (dans les deux sens) le contenu des mots mémoires entre la mémoire

et les différents registres de l'unité de traitement.





Ces différents bus peuvent contenir un nombre de fils différent. Le nombre de fils du bus de

données/résultats détermine la capacité du microprocesseur. Un «microprocesseur 32 bits» contient

donc un bus données/résultats composé de 32 fils.

2.4 Le cycle d'exécution d'une instruction

Supposons maintenant que la mémoire centrale de notre ordinateur contienne un programme et

des données, et que l'on souhaite exécuter ce programme sur ces données. Lancer cette exécution

revient à mettre dans le compteur ordinal (CO) l'adresse où se trouve stockée la première instruction

du programme. A partir de là, le programme est exécuté étape par étape, instruction par instruction.

L'exécution d'une instruction se fait suivant un cycle comprenant 3 phases :

phase 1 : L'instruction courante, dont l'adresse est stockée dans le CO, est recopiée dans le

registre d'instruction (RI) en transitant par le bus «instructions» ;

phase 2 : cette instruction courante est décodée à destination de l'UAL ; ainsi le bus «ordres»

transfère le code de l'opération (les 4 premiers bits) et le bus «données/résultats» transfère

dans les registres appelés «donnée 1» et «donnée 2» le contenu des mots mémoire se trouvant

aux adresses référencées dans l'instruction ;

phase 3 : l'UAL exécute l'opération qui lui est demandée en mettant à jour son registre

«résultat» et transfère ce résultat dans la mémoire centrale, à l'adresse référencée dans

l'instruction, en utilisant le bus «données/résultats» ; par ailleurs le CO est automatiquement

incrémenté (c'est-à-dire qu'il est augmenté de 1), pour signifier que l'instruction suivante à

exécuter doit se trouver normalement à l'adresse qui suit immédiatement la précédente. Un

nouveau cycle peut commencer alors pour la nouvelle instruction courante.

Ces cycles sont rythmés par les tops d'horloge, chaque phase correspondant à un nombre fixe de

«tops» successifs. Dans notre exemple, pour la phase 1, qui nécessite de faire transiter l'instruction

courante de la mémoire vers le RI en utilisant le bus d'instruction, 4 tops d'horloge seront nécessaires

(car un mot mémoire fait 16 bits et le bus n'a une capacité que de 4 bits).

Illustrons ce fonctionnement à l'aide d'un exemple complet sur notre ordinateur miniature (seuls les

bits «utiles» de la mémoire et des registres sont donnés). La figure 6 montre la situation de départ, les

trois suivantes montrent l'état de l'ordinateur après l'exécution de chaque phase d'un cycle.





Figure 6: Situation de départ

Pour aider à la compréhension, on fait à chaque étape figurer en gras les composants actifs à cette

étape.

La figure 7 montre l'état de l'ordinateur à l'issue de la première phase du premier cycle. L'instruction

courante a transité à travers le bus «instructions» et se retrouve désormais dans le registre

d'instruction. Notons que, si le bus «instructions» est composé de 4 fils, comme sur notre schéma,

alors qu'une instruction dans un mot mémoire est stockée sur 2 octets, alors ce transfert a dû se faire,

au mieux, en 4 passages successifs (correspondant chacun à un top d'horloge).

Figure 7 : Premier cycle, phase 1





La figure 8 montre l'état de l'ordinateur à l'issue de la deuxième phase du premier cycle. Le bus

«ordres» a fait tout d'abord transiter les 4 premiers bits de l'instruction courante à l'UAL, qui a reconnu

que c'était le code d'une addition (l'opération active dans l'UAL est donc l'addition). Les deux suites de

4 bits suivantes correspondent aux adresses en mémoire où l'UAL doit aller chercher les données sur

lesquelles effectuer cette opération. Ces données viennent remplir les registres «donnée 1» et

«donnée 2» de l'UAL en passant pas le bus «données/résultats».

Figure 8: Premier cycle, phase 2

La figure 9 montre l'état de l'ordinateur à l'issue de la troisième et dernière phase du premier

cycle. L'UAL a réalisé l'opération qui lui était demandée et a rempli avec le résultat son registre

«résultat». La dernière partie de l'instruction courante indique l'adresse du mot mémoire où ce

résultat doit être stocké. C'est ce qui est fait en utilisant de nouveau le bus «données/résultats». Par

ailleurs, pour préparer le cycle suivant, le compteur ordinal est augmenté de 1.

Figure 9 : Premier cycle, phase 3





A l'issue de ce cycle, la première instruction élémentaire a été entièrement exécutée et la

machine est prête à démarrer un nouveau cycle pour exécuter la deuxième (et dernière) instruction du

programme.

La figure 10 montre la situation de l'ordinateur à la fin de l'exécution de ce deuxième cycle (sans

détailler les 3 phases, cette fois). Un nouveau cycle peut commencer, mais nous supposons qu'il n'y a

plus d'information pertinente à l'adresse référencée par le CO (ou il y en a une signifiant «FIN») :

l'exécution du programme est donc terminée.

Figure 10 : Situation à l'issue du deuxième cycle

Mais quel programme, finalement, notre ordinateur a-t-il effectué, sur quelles données, et pour

trouver quel résultat ? Reprenons le fil de cet exemple.

la première instruction commandait l'exécution d'une addition entre 2 nombres stockés en

mémoire que nous appellerons respectivement «nombre 1» et «nombre 2» ; le résultat étant

«nombre 3» ;

la deuxième instruction demandait de multiplier «nombre 3» (donc, le résultat intermédiaire

précédent) par un nouveau nombre, disons «nombre 4», pour donner le résultat final.

Le programme, l'algorithme réalisait donc l'opération composée suivante :

Nombre 1 + nombre 2 = nombre 3

Nombre 3 * nombre 4 = résultat

ou encore : résultat = (nombre 1 + nombre 2 ) * nombre 4





Les nombres 1, 2 et 4 sont les données sur lesquelles le programme a été exécuté. Nombre 3 est

un résultat intermédiaire et le résultat final est noté «résultat». En fait, l'algorithme composé des 2

instructions exécutées par l'ordinateur réalise le programme en C suivant : v=(x+y)*z ;

La valeur réelle des nombres sur lesquels le calcul a été effectué dépend de ce qui est stocké dans la

mémoire aux adresses utilisées par le programme. Dans notre exemple, elles valaient respectivement

(en décimal) : x=5, y=14 et z=2. La valeur du résultat final de notre exécution est donc : (5 + 14) * 2 =

38.

Sur la figure 6, les deux mots mémoire présents aux adresses 0001 et 0010 respectivement

contenaient des instructions, tandis que les mots mémoire dont les adresses étaient 1011, 1100 et

1101 contenaient des données. L'exemple a aussi montré comment l'enchaînement de plusieurs

opérations élémentaires pouvait permettre de réaliser une opération plus complexe.





Chapitre 3 : les circuits séquentiels – les Bascules

Introduction

La mémoire de l’ordinateur stocke les données et les instructions du programme en cours

d’exécution. Pour réaliser cette mémoire, des circuits dits de mémorisation sont utilisés. Pour

mémoriser un bit (0 ou 1), il faut utiliser un circuit capable de se souvenir de la valeur qu’il a

enregistrée.

Ces circuits sont appelés circuits séquentiels. A l’inverse des circuits combinatoires, la valeur

de sortie d’un circuit séquentiel ne dépend pas que des variables d’entrée, mais dépend aussi de la

valeur de sortie antérieure.

« La logique combinatoire présente des sorties qui, à un instant donné, ne dépendent que des valeurs

présentes sur les entrées. La logique séquentielle prend en considération les conditions antérieures à l'instant

donné, ce qui permet de réaliser des dispositifs à mémoire. »

3.1 Exemple

On prend un exemple d’un poste Marche/Arrêt qui commande le fonctionnement d’un

moteur. Une action momentanément sur le bouton « Marche » met le moteur en fonction aussi

longtemps que le bouton poussoir « Arrêt » n’est pas actionné. Dans le tableau suivant, on remarque

que les variables d’entrée des étapes 1 et 3 ont la même valeur mais l’état de sortie est différent. Un

dispositif de mémoire à maintenir le moteur en marche. Il devient donc impossible de construire une

table de KARNAUGH comme en logique combinatoire et de réaliser le circuit à l’aide des simples portes

logiques.

Etape Bouton « Marche » Bouton « Arrêt » Moteur

1 0 0 0

2 1 0 1

3 0 0 1

4 0 1 0

5 0 0 0

En logique combinatoire, la sortie dépend directement des entrées. Par contre dans le tableau, on

remarque que les variables d’entrée des étapes 1 et 3 ont la même valeur (bouton M =0 et bouton





A=0) mais la valeur de la sortie est différente ; donc il s’agit d’une logique séquentielle dont la sortie

dépend de l’état de sortie précédente.

3.2 Définition d’un circuit séquentiel

Un circuit séquentiel est composé d’un circuit combinatoire et de dispositifs à mémoire appelés

bascules.

On distingue 2 types de circuits séquentiels :

les circuits séquentiels synchrones.

les circuits séquentiels asynchrones.

La différence fondamentale entre ces deux catégories se situe dans l'introduction de la notion de

temps dans les circuits :

Un circuit logique séquentiel synchrone incorpore une horloge qui sert à enclencher les

actions,

Les circuits logiques séquentiels asynchrones n'en présentent pas.

L’horloge est une variable logique qui successivement passe de 0 à 1 et de 1 à 0 d’une façon

périodique (c’est-à-dire le passage se répète identiquement).

Cette variable est utilisée souvent comme une entrée des circuits séquentiels appelés circuits

synchrones. L’horloge est notée par H ou CK (clock

Circuit séquentiel synchrone

E0

E1

H

S0

S1





La fréquence f :

, la fréquence est en hertz

Lorsqu’un circuit séquentiel n’a pas d’horloge comme variable d’entrée ou si le circuit fonctionne

indépendamment de cette horloge alors ce circuit est asynchrone.

3.3 Les Bascules

La bascule est un circuit bistable pouvant prendre deux états logiques "0" ou "1". L'état de la

bascule peut être modifié en agissant sur une ou plusieurs entrées. Le nouvel état de la bascule dépend de l'état précédent, c'est l'élément de base des circuits séquentiels. La bascule peut conserver son état pendant une durée quelconque, elle peut donc être utilisée comme mémoire. Une bascule est un élément capable de stocker (mémoriser) un bit et de le restituer au temps voulu.

Les Bascules sont les circuits de bases de la logique séquentielle.

Une Bascule peut posséder une horloge (synchrone) ou non (asynchrone)

Chaque Bascule possède des entrées et 2 sorties et

Une Bascule possède la fonction de mémorisation et de basculement

Circuit séquentiel asynchrone

E0

E1

S0

S1





: est la variable de sortie de la bascule. Elle fournit l’état de la bascule. Si , on dit que l’état de

la bascule est à 1. Sinon, l’état de la bascule est à 0.

: C’est l’inverse ou le complément de la sortie

Nom de la bascule : Un nom est associé à chaque bascule, il indique les entrées de la bascule en

question.

Il existe quatre Bascules de base :

Bascule R S

Bascule J K

Bascule D

Bascule T

3.3.1 Bascule R-S asynchrone

La bascule R-S est une bascule asynchrone (sans entrée d’horloge). C’est la bascule élémentaire,

qui constitue la base de tous les autres types de bascules. La bascule R-S peut être réalisée avec des

portes NOR ou avec des portes NAND.

Ce circuit possède deux entrées (R,S) et deux sorties , . Est toujours le complément

Les lettres R et S proviennent des initiales de deux mots anglo-saxons:

R : signifiant Reset qui veut dire replacer (mise à zéro),

S : signifiant Set qui veut dire placer (mise à un)

Logigramme :

Bascule R-S : portes NOR Bascule R-S : portes NAND

Pour comprendre le fonctionnement de la bascule R-S, on va étudier le comportement des variables

de sorties en fonction des entrées R et S.

Nom de la bascule

Entrées de la bascule

Sorties de la

Bascule





Pour cela, on désigne par :

: la variable de sortie à l’instant t (l’état présent de la bascule)

: la variable de sortie à l’instant t+1 (l’état futur de la bascule)

a- Quand S=R=0

On suppose que , dans ce cas on aura le schéma suivant :

Ce schéma montre bien que, lorsque , la variable de sortie de la porte NOR inferieur est à 1

. Donc on aura

.

Du moment que , la variable de sortie de la porte NOR supérieur sera à 0

et on a .

Ainsi, on a : . On dit, alors que l’état de la bascule est stable (ne change pas)

On suppose que , dans ce cas on aura le schéma suivant :

(

Dans ce cas, aussi, on a





b- Quand S passe à 1 ( S=1 , R=0)

Dans le cas où , on aura le schéma suivant :

A l’instant t A l’instant t+1

On en conclut que, quand S passe à 1, la variable de sortie est mise à 1 (



On remarque que la variable de sortie ne change pas d’état (

Remarque : voyons ce qui se passe si on remet S à 0






On voit bien que le fait de remettre S à 0 n’a aucun effet sur la variable de sortie qui reste toujours à

1. C’est comme si la bascule se souvenait de son état antérieur.

Conclusion : On en conclut que, quand la variable d’entrée S passe à 1, la variable de sortie garde son

état si elle est à 1, sinon, elle prend la valeur 1.

c- Si R passe à 1 et S=0



Le schéma montre bien que la variable de sortie ne change pas d’état, mais garde l’état 0

( ).



Le schéma montre que la variable de sortie change d’état prend l’état 0 ( ).

Conclusion : Lorsque R passe à 1, la variable de sortie maintient son état si elle est à 0, sinon,

elle est remise à 0.

Remarque : voyons, maintenant, le comportement de la bascule quand R est remis à 0






On voit que le fait de remettre R à 0 n’a aucun effet sur l’état de la bascule, elle garde toujours l’état 0.

On dit que la bascule se souvenait de son état antérieur.

d- Si S et R passe à 1 simultanément


Si , à l’instant t+1, le circuit fournit la variable de sortie


Si , à l’instant t+1, le circuit fournit la variable de sortie

Conclusion : lorsque R et S passent à 1, la variable de sortie peut prendre l’un des états 1 ou 0. On dit

alors, que l’état de la bascule est indéterminé, il peut être à 1, comme il peut être à 0.





On peut résumer le comportement de la bascule R-S, par la table de vérité suivante :

Etats présents état futurs

R S

0 0 0 0 0 0 1 1

0 1 0 1 (Mise à 1) 0 1 1 1

1 0 0 0 (Remise à 0) 1 0 1 0

1 1 0 X Etats indéterminés 1 1 1 X

Cette table est appelée table caractéristique de la bascule R-S

A partir de cette table, on peut déduire l’expression algébrique de , pour obtenir la fonction

simplifiée, on utilise un tableau de KARNAUGH :

R\S 00 01 11 10

0 0 1 1 1

1 0 0 X X

L’expression simplifiée de est : , cette équation est appelée équation

caractéristique.

On peut représenter la table caractéristique de R-S comme suit :

R S

0 0

0 1 1 0

1 0 0 1

1 1 X X Indéterminé





Chronogramme de la bascule R-S : avec a=R et b=S

3.3.2 Bascule R S synchrone (RSH)

L’utilisation d’une horloge permet de synchroniser les changements d’état de la bascule. En effet,

il est souvent utile de ne faire changer d’état à une bascule qu’à des instants bien précis.

Le schéma suivant illustre la bascule R-S commandée par une horloge H

A partir de ce schéma, on constate ce qui suit :

Si H=0, les valeurs de R et S n’ont aucun effet sur la bascule. Cette dernière garde l’état antérieur.

Si H=1, à ce moment-là, la bascule se retrouve sous le contrôle de deux variables R et S.





La table caractéristique de cette bascule synchrone est la suivante :

H R S

0 0 0 0 0 = L’état de la bascule ne change pas. Les valeurs de R et S n’ont aucun effet, tant que H=0

0 0 0 1 1

0 0 1 0 0

0 0 1 1 1

0 1 0 0 0

0 1 0 1 1

0 1 1 0 0

0 1 1 1 1

1 0 0 0 0 = 1 0 0 1 1

1 0 1 0 1 = 1 (Mise à 1) 1 0 1 1 1

1 1 0 0 0 = 0 (Remise à 0) 1 1 0 1 0

1 1 1 0 X Etats indéterminés 1 1 1 1 X

Signal d'horloge: Une bascule synchronisée peut être déclenchée sur le front montant ou sur le front descendant de l'impulsion d'horloge.

Chronogramme de la bascule RSH : front montant





3.3.3 Bascule J-K synchrone

La bascule J-K diffère de la bascule R-S du fait que, quand les deux variables d’entrées passent

simultanément à 1, l’état de la bascule n’est pas indéterminé. Ceci peut être obtenu en asservissant les

entrées R et S aux sorties selon le schéma logique indiqué.

Nous avons alors les signaux R et S comme suit :

J-K synchrone avec des portes NOR J-K synchrone avec des portes NAND

Ce qui permet de construire la table de vérité de la bascule J-K suivante :

J K R S

0 0 0 1 0 0 0 1

0 0 1 0 0 0 1 0

0 1 0 1 0 0 0 1

0 1 1 0 1 0 0 1

1 0 0 1 0 1 1 0

1 0 1 0 0 0 1 0

1 1 0 1 0 1 1 0

1 1 1 0 1 0 0 1

En effet, quand J=K=1, on obtient la fonction de complémentation





La table caractéristique de J-K

J K

0 0 0 0 0 0 1 1

0 1 0 0 (Remise à 0) 0 1 1 0

1 0 0 1 (mise à 1) 1 0 1 1

1 1 0 1 complémentation 1 1 1 0

A partir de la table caractéristiques de la bascule J-K, on obtient l’expression de du tableau de

KARNAUGH suivant :

J\K 00 01 11 10

0 0 1 0 0

1 1 1 0 1

Ainsi l’équation caractéristique de la bascule J-K est :

D’où la table caractéristique de J-K

A partir de l’équation caractéristique, on peut élaborer la table suivante qui est d’une très grande

utilité lors de la réalisation d’un circuit séquentiel à base de bascules J-K:

J K

0 0

0 1 0

1 0 1

1 1

J K

0 0 0 X La valeur que peut prendre K n’a aucun effet sur l’état de la bascule

0 1 1 X

1 0 X 1 La valeur que peut prendre J n’a aucun effet sur l’état de la bascule

1 1 X 1





3.3.4 La bascule D (Data)

Une autre manière de résoudre le problème d’ambiguïté rencontré avec la bascule R-S lorsque

R=S=1, est de faire en sorte que ce cas ne se présente jamais à l’entrée de la bascule. Pour cela, on

n’utilise qu’une seule variable d’entrée externe D et on parle de la bascule D. Elle est illustrée par le

schéma suivant :

a) Logigramme de la Bascule D asynchrone b) Logigramme de la Bascule D synchrone

la variable d’entrée de la porte NOR inférieur (a) étant égale à , les entrées de la bascule ne peuvent

jamais être identiques c'est-à-dire la bascule D ne traite jamais le cas (0,0) et (1,1).

Si D=1, la bascule passe à l’état 1 (S=1, R=0)

Si D=0, la bascule passe à l’état 0 (S=0, R=1)

La table caractéristique de la bascule D est la suivante :

D H

0 0 0 0

, pas de changement 0 0 1 1

0 1 0 0

, la donnée D passe 0 1 1 0

1 0 0 0

, pas de changement 1 0 1 1

1 1 0 1

, la donnée D passe 1 1 1 1





A partir de cette table, on peut déterminer l’expression algébrique de

D\H 00 01 11 10

0 0 1 0 0

1 0 1 1 1

L’équation caractéristique de la bascule D synchrone est

Il existe deux types de bascule D selon le mode de synchronisation :

Bascule D active sur le niveau (bas ou haut) est dite bascule D Latch

Bascule D active sur le front (montant ou descendant) est dite bascule flip-flop ou normale

3.3.4.1 La bascule D-Latch

Les bascules Latchs réagissent sur un niveau d’horloge. Cela revient à dire que ce type de bascule est

déclenché quand l’horloge H=1 (niveau haut) ou quand H=0 (niveau bas).

a- Bascule D-Latch déclenchable au niveau haut (H=1) :

Le schéma standard est comme suit :

Table de vérité correspondante :

H D

0 X

1 0 0 1

1 1 1 0

Cette table de vérité peut être interprétée comme suit :

Si H=0 alors (mémorisation)

Et si H=1 alors . Donc on peut représenter la table de vérité de la manière suivante :

H

0

1

D

H





On va illustrer le fonctionnement de cette bascule par un chronogramme :

Soit la séquence de bits à se présenter à l’entrée D de la bascule : 00100000100011000000 On va voir

quelle sera la séquence de bits produite à la sortie Q de la bascule :

La séquence de bits en sortie est Q=00000000100011111000

- A l’instant t1 : l’entrée D passe à 1 mais cette entrée n’est pas prise ne compte, car H=0, la

sortie Q ne change pas d’état.

- A l’instant t2 : l’entrée D revient à 0, mais il n’ya toujours pas d’effet sur la sortie car H=0

- A l’instant t3 : l’entrée H passe à 1, mais comme D est à 0, la bascule demeure en position

RESET ( .

- A l’instant t4 : D passe à 1, ce changement d’état se produisant lorsque H=1 et est recopié sur

les sorties de la bascule de telle sorte que celle-ci devient SET ( .

- A l’instant t5 : D revient à 0, ce changement de niveau, intervenant lorsque H=1 et est recopié

sur les sorties de la bascule de telle sorte que celle-ci devient RESET ( .

- A l’instant t6 : D passe à 1, la bascule redevient SET car H=1.

- A l’instant t7 : H passe à 0, la bascule passe en position mémoire.

- A l’instant t8 : D passe à 0 mais ce changement d’état de l’entrée D n’est pas pris en compte par

la bascule car H=0.

- A l’instant t9 : h passe à 1 et comme D est à 0, la sortie Q passe également à 0, la bascule

devient RESET ( .





b- Bascule D-Latch déclenchable au niveau bas (H=0) :


Table de vérité correspondante :

H D

1 X

0 0 0 1

0 1 1 0

Cette table de vérité peut être interprétée comme suit :

Si H=1 alors (mémorisation)

Et si H=0 alors . Donc on peut représenter la table de vérité de la manière suivante :

H

1

0

Exercice : réaliser une bascule D-Latch à l’aide d’un multiplexeur 2 1

En niveau Haut (H=1) En niveau bas (H=0)

3.3.4.1 La bascule D flip-flop (ou Normale)

Ce type de bascule change d’état pendant la transition du signal d’horloge de l’état 0 à1 (Front

Montant) ou lors de la transition de l’état 1 à 0 (Front descendant)

D

H

H

Q D

0

1

H

Q D 0

1






Sur Front Montant Sur Front descendant

On considère la séquence 011010011010 présentée à l’entrée D de la bascule.

Le signale appliqué est un signale d’horloge sur Front montant. On va illustré le fonctionnement de la

bascule D par le chronogramme suivant :

3.3.5 La bascule T (Toggle= basculer)

Le schéma fonctionnel de la bascule T est donné par :

La bascule T change d'état si T =1 et ne change pas d’état si T = 0. La Table 1 résume son fonctionnement. Elle peut être réalisée à partir d’une bascule D de deux manières différentes. La bascule T s’obtient à partir de la bascule J-K en injectant le même signal dans les entrées J et K.

Cette bascule peut être dotée d’une entrée Horloge

D

H

D

H





Son fonctionnement est illustré par la table caractéristique suivante :

T

0 0 0

0 1 1

1 0 1

1 1 0

Cette table nous permet de simplifier la fonction de l’état de sortie comme suit :

La table suivante montre l’entrée T de la bascule pour obtenir les différentes transitions entre l’état

présent et l’état futur.

T

0 0 0

0 1 1

1 0 1

1 1 0

- La bascule T s’obtient à partir de la bascule J-K en injectant le même signal dans les entrées J et

K. Cette bascule peut être dotée d’une entrée Horloge, elle fonctionne généralement en front

de l’horloge.

H T

0/1 X

↑ 0

↑ 1

- La bascule T ressemble à une bascule J-K à une seule entrée, son schéma est le suivant :

- Elle peut être aussi obtenue à partir de la bascule D, son schéma est le suivant :





3.4 Déclenchement d’une bascule

Le déclenchement d’une bascule se traduit par un changement momentané de ses variables

d’entrées.

Cependant, le déclenchement d’en bascule asynchrone diffère du déclenchement d’une bascule

synchrone.

En effet, dans le 1er cas (asynchrone), la bascule est déclenchée lorsque les signaux appliqués en entrée

changent.

Dans le second cas (synchrone), le déclenchement de la bascule est plus compliqué. Une bascule

synchrone est pilotée par une horloge, de ce fait, le déclenchement d’une telle bascule est provoqué

par des impulsions.

3.4.1 Déclenchement sur niveau

Les entrées sont prises en compte pendant un niveau fixé de l’horloge ( H=1 ou H=0).

Niveau haut : le signale H est utilisé directement (H=1)

Niveau bas : le signale H est utilisé avec un inverseur (H=0)

3.4.2 Déclenchement sur Front

Les entrées sont prises en compte pendant un Front de l’horloge qui est le passage d’un niveau à

autre :

Front montant : le moment de passage du niveau bas au niveau haut

Front descendant : le moment de passage du niveau haut au niveau bas.

3.5 Analyse d’un circuit séquentiel

L’analyse d’un circuit séquentiel est basée sur la théorie des automates finis.

3.5.1 Automate fini

Un automate fini possède un nombre fini d’éléments et de mémoires. Un automate fini ne peut prendre que 2n états appelés états internes, où n est le nombre de bits de mémoire. On peut caractériser un automate par :

Sa fonction de transfert

Sa table de transition

Son diagramme d’états ou de transition





3.5.2 Analyse

L’analyse du circuit séquentiel consiste à trouver les équations caractéristiques ou les diagrammes temporels qui décrivent le travail du circuit séquentiel. En d’autres termes, trouver les états futurs et les sorties du circuit séquentiel en fonction de ces entrées et ces états présents. On suit pour une démarche à 5 étapes :

1- Déterminer les équations des entrées aux bascules. 2- Substituer les équations des entrées dans les équations caractéristiques des bascules pour

obtenir les équations de transition. 3- Déterminer les équations des sorties en fonction des entrées et de l’état actuel des

bascules. 4- Etablir la table d’état (dite aussi la table de vérité) du circuit qui contient 4 colonnes

montrant l’état actuel des bascules, les entrées, les états futures et les sorties. 5- Déduire le diagramme de transition du circuit qui est une autre forme de la table d’état :

dans ce diagramme, l’état est présentée comme un cercle et les transitions (déclenchées par l’horloge) entre états sont représentées par des flèches qui se dirigent d’un cercle à l’autre montrant les conditions de passage (entées/sorties)

Exemple 1 : Analyser le circuit suivant :

Les étapes d’analyse : Le circuit est composé de deux bascules D Notées et

A représente l’état actuel de la bascule et A+ représente l’état future B représente l’état actuel de la bascule et B+ représente l’état future

1- Déterminons les équations des entrées des bascules :

Etat i Etat k

Entrée/sortie





2- Déterminons les équations caractéristiques des bascules : Rappelons que dans une bascule D la sortie (état futur) , donc :

3- Donnons les équations de sortie :

4- la table d’état :

Entrées Etats présents Etats futurs Sorties

X A B A+ B+ Y

0 0 0 0 0 0

0 0 1 0 0 1

0 1 0 0 0 1

0 1 1 0 0 1

1 0 0 0 1 0

1 0 1 1 1 0

1 1 0 1 0 0

1 1 1 1 0 0

5- Diagramme d’état : une autre représentation de la table d’état :

Exemple 2 : Analyser le circuit séquentiel suivant :





1- Les équations d’entrées :

2- Les équations caractéristiques de deux bascules :

Rappelons que dans une bascule J-K la sortie , donc

3- Les sorties du circuit sont A+ et B+ 4- Table d’état :

Entrées Etats présents Etats futurs

1 A B A+ B+

1 0 0 1 0

1 0 1 1 1

1 1 0 0 1

1 1 1 0 0

5- Diagramme d’état :

Exercice : analyser le circuit séquentiel suivant :





3.6 Conception d’un circuit séquentiel

Les étapes de conception d’un circuit séquentiel synchrone sont à peu près les mêmes étapes que celles de l’analyse d’un circuit séquentiel, sauf qu’elles sont inversées.

1- Comprendre le fonctionnement du circuit et le traduire éventuellement en un diagramme de transition.

2- Détermination de la table d’état qui montre les états futurs et les sorties en fonction des entrées et des états présents.

3- Réduction du nombre d’états.

4- Détermination du nombre de bascules nécessaires et donner un nom à chacune.

5- Détermination du type de bascules et de la table des entrées de chaque bascule.

Cette table est appelée aussi table d’excitation

6- Détermination des équations d’entrées des bascules et des équations de sorties. 7- Dessin dur circuit séquentiel.

Exemple 1 : Soit à réaliser un circuit synchrone formé de bascule J-K et compte de zéro jusqu’à sept (0 à 7) :

1- Comprendre le fonctionnement du circuit à réaliser : 01234567

2- Déterminons la table d’état : On a 8 états (8=23), donc on a besoin de mémoriser 3 bits, d’où la nécessité d’utiliser 3 bascules. Les entrées de ces bascules sont respectivement : J0, K0, J1, K1, J2, K2 et les sorties Q0, Q1 et Q2.





Le compteur binaire est caractérisé par la table suivante :

Etats présents Etats futurs

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

On va élaborer une table de vérité (table d’état) qui nous permettra de définir les variables d’entrées en fonction des variables de sorties. Une telle table est appelée table d’excitation Pour pouvoir remplir cette table d’excitation facilement, on utilise la table d’excitation de la bascule J-K donnée dans la section (§3.6)

Etats présents Etats futurs Entrées

0 0 0 0 0 1 0 X 0 X 1 X

0 0 1 0 1 0 0 X 1 X X 1

0 1 0 0 1 1 0 X X 0 1 X

0 1 1 1 0 0 1 X X 1 X 1

1 0 0 1 0 1 X 0 0 X 1 X

1 0 1 1 1 0 X 0 1 X X 1

1 1 0 1 1 1 X 0 X 0 1 X

1 1 1 0 0 0 X 1 X 1 X 1

3- Réduction

Cette étape consiste à trouver les équations d’entrées en fonctions des états présents. Pour déterminer les équations de J0, K0, J1, K1, J2, K2, on utilise donc le tableau de KARNAUGH comme suit :

0

/

00 01 11 10

0 0 0 1 0

1 X X X X

/

00 01 11 10

0 X X X X

1 0 0 1 0





4- Le circuit :

Fin du chapitre

/

00 01 11 10

0 0 1 X X

1 0 1 X X

/

00 01 11 10

0 X X 1 0

1 X X 1 0

/

00 01 11 10

0 1 X X 1

1 1 X X 1

/

00 01 11 10

0 X 1 1 X

1 X 1 1 X





Chapitre 4 : Les compteurs/décompteurs Introduction

Une bascule peut avoir 2 états différents à sa sortie (0 et 1), et peut donc permettre de compter de 0 à 1. Avec 2 bascules on peut avoir jusqu’à 4 états différents : 00, 01, 10 et 11, ce qui permet de compter de 0 à 3 en binaire naturel. Avec 3 bascules on a 8 états (de 000 à 111), et en général avec n bascules on a 2n états : on peut donc compter de 0 à 2n-1. Il reste à trouver comment doivent être connectées les n bascules entre elles pour réaliser un compteur, sachant qu’il existe plusieurs types de compteurs, et donc plusieurs techniques de réalisation. C’est ce que nous allons voir dans ce cours à travers différents exemples. 4.1 Définition

Un compteur est un circuit séquentiel qui servent à compter suivant un code bien déterminé (binaire, BCD, décimal….) et leur état à un instant donné dépend de leur état antérieur. Ils sont constitués par l’association de bascules. 4.2 Modulo d’un compteur

Le compteur en fonctionnement génère de manière répétitive une séquence de nombres binaires. Lorsque le compteur compte jusqu' à N-1 alors il est dit modulo N: les états successifs étant dans l'ordre 0, 1, ..., N-1. Quand N=2n, n étant le nombre de bascules utilisées pour réaliser le compteur, on dit qu'il compte sur n bits. De manière générale, si le comptage comporte un nombre X d'états, il faudrait n bascules telles que 2 n-1 < X ≤ 2n 4.3 Types de compteurs-décompteurs

Il existe 2 types de compteurs-décompteurs :

Compteurs-décompteurs asynchrones

Compteurs-décompteurs synchrones. 4.3.1 Les compteurs-décompteurs asynchrones Ce type de circuit est constitué de plusieurs bascules montées en cascade. Chaque bascule constitue un étage du compteur et reçoit une impulsion d’horloge différente d’où le terme asynchrone. L’horloge principale commande la première bascule alors que l’horloge de chacune des autres bascules peut être une fonction logique des sorties des autres bascules





4.3.1.1 compteurs/décompteurs asynchrones modulo N=2n Ce type de compteur est réalisé à l’aide de n bascules montées en cascade. Les états successifs étant codés en binaire, la sortie de chacune des n bascules constitue un bit. Exemple 1 : compteur asynchrone modulo 8

- Réaliser un compteur binaire asynchrone modulo 8 à l’aide de bascules J-K à front descendant Pour commencer, il faut d’abord déterminer le nombre de bascules à la réalisation du compteur. Pour un compteur modulo 8, il faut 3 bascules car 8=23. a- Table d’état :

Etat présent Etat futur

valeur

0 0 0 0 0 0 1

1 0 0 1 0 1 0

2 0 1 0 0 1 1

3 0 1 1 1 0 0

4 1 0 0 1 0 1

5 1 0 1 1 1 0

6 1 1 0 1 1 1

7 1 1 1 0 0 0

b- Le chronogramme :

La sortie Q1 passe de 0 à 1 chaque front descendant.

La sortie Q2 change d’état chaque fois que l’état Q1 passe de 1 à 0 (front descendant)

La sortie Q3 change d’état chaque fois que l’état Q2 passe de 1 à 0 (front descendant)





c- Analyse du chronogramme

On constate, en analysant les transitions de ce chronogramme, que la sortie Q3 change d’état si la sortie Q2 (précédente) passe de l’état ‘1’ à l’état ‘0’ et conserve son état dans les autres situations. La sortie Q1 qui n’a pas d’antécédent commute à chaque impulsion d’horloge H. 1- A chaque front descendant de H, on aura :

(Complémentation) D’après la table de transition de la bascule JK :

Sachant que la bascule 1 commute au front descendant, on peut écrire que H=H1 (H1 est l’horloge de bascule 1)

2- A chaque front descendant de Q1, on aura

(Complémentation)

D’après la table de transition de la bascule JK :

Sachant que la bascule 2 commute au front descendant, on peut écrire que (H2 est l’horloge de bascule 2) D’où

3- A chaque front descendant de Q2, on a :


4- Sachant que la bascule 3 commute au front descendant, on peut écrire que (H3

est l’horloge de bascule 3) D’où

Le circuit :

•

• •

•

•

•

•

•

1 1 1

J1

H1

K1

J3

H3

K3

J2

H2

K2 H

> > >

o o o





Exemple 2 : décompteur asynchrone modulo 8

- Réaliser un décompteur binaire asynchrone modulo 8 à l’aide de bascules J-K à front descendant

Pour commencer, il faut d’abord déterminer le nombre de bascules à la réalisation du décompteur. Pour un décompteur modulo 8, il faut 3 bascules car 8=23. a- Table d’état :


valeur

7 1 1 1 1 1 0

6 1 1 0 1 0 1

5 1 0 1 1 0 0

4 1 0 0 0 1 1

3 0 1 1 0 1 0

2 0 1 0 0 0 1

1 0 0 1 0 0 0

0 0 0 0 1 1 1

b- Chronogramme :

c- Analyse du chronogramme :

1- A chaque front descendant de H, on aura :


Sachant que la bascule 1 commute au front descendant, on peut écrire que H=H1 (H1 est l’horloge de bascule 1)





2- A chaque front montant de Q1, on aura


Sachant que la bascule 2 commute au front descendant, on peut écrire que (H2 est l’horloge de bascule 2) D’où

3- A chaque front montant de Q2, on a :


Sachant que la bascule 3 commute au front descendant, on peut écrire que (H3 est l’horloge de bascule 3)

D’où

Le circuit : 4.3.1.2 compteurs/décompteurs asynchrones modulo N≠2n

Pour réaliser ce type de compteur il faut n bascules telles que 2n-1 < N ≤ 2n. Lorsque la sortie présente l’état correspondante au nombre binaire N, on remet le compteur à zéro. Les bascules devront donc disposer d’une entrée de remise à zéro asynchrone CLEAR (CLR). Exemple 3 : compteur asynchrone modulo 6

- Réaliser un compteur binaire asynchrone modulo 6 à l’aide de bascules J-K à front montant. Pour un compteur modulo 6, il faut 3 bascules. En effet, 22 < 6 ≤ 23. Si on utilisait seulement 2 bascules, on ne pourrait pas coder l’état 5, donc il faut 3 bascules permettant de coder 8 états y compris l’état 5. Arrivé à 5, le comptage doit être interrompu pour recommencer de zéro. On doit, donc, remettre toutes les bascules à zéro après l’apparition de 5. Pour ce faire, on utilise les entrées asynchrones de remise à zéro (CLR).

•

•

•

•

•

•

1 1 1

J1

H1

K1

J3

H3

K3

J2

H2

K2 H

> > > o o o





a- Table de transition :


valeur

0 0 0 0 0 0 1

1 0 0 1 0 1 0

2 0 1 0 0 1 1

3 0 1 1 1 0 0

4 1 0 0 1 0 1

5 1 0 1 0 0 0

b- Chronogramme :

c- Analyse du chronogramme :

On constate qu’à l’état 5 les 3 bascules sont remises à zéro en même temps. Or l’état 5 correspond à . Pour remettre à zéro, en même temps, ces 3 bascules, il faut appliquer une entrée CLEAR (CLR) de chacune d’elle, un niveau logique 0. C'est-à-dire à l’état 5, CLR =1, pour que CLR soit égale à 1 il faut que , pour que

CLR=0, il suffit de la complémenter. D’où

o





Le circuit :

4.3.2 Compteurs/décompteurs synchrones Un compteur synchrone est constitué de bascules synchrones recevant en même temps le signal d’horloge unique. Les sorties des différentes bascules du compteur changent en même temps. La méthode la plus simple et la plus couramment utilisée fait appelle au tableau de KARNAUGH. Elle consiste à déterminer les fonctions logiques des entrées synchrones des différentes bascules en fonction des états connus des sorties avant et après le front actif de l’horloge. Pour ce faire, on doit utiliser la table d’excitation de la bascule. Exemple 4 : compteur synchrone modulo 4

- Réaliser un compteur binaire synchrone modulo 4 à l’aide de bascule D à front montant. Pour commencer, il faut d’abord déterminer le nombre de bascules à la réalisation du compteur. Pour un compteur modulo 4, il faut 2 bascules car 4=22.

Rappelons la table d’excitation de la bascule D :

D

0 0 0

0 1 1

1 0 0

1 1 1

En utilisant cette table d’excitation de la bascule D , on peut établir la table de transition du compteur.

o

•

• •

•

•

•

•

•

1 1 1

J1

H1

K1

J3

H3

K3

J2

H2

K2 H

> > >

•

o

o o





Table de transition :

Valeur

0 0 0 0 1 0 1

1 0 1 1 0 1 0

2 1 0 1 1 1 1

3 1 1 0 0 0 0

Les équations logiques :

/ 0 1

0 0 1

1 1 0

/ 0 1

0 1 0

1 1 0

Le circuit :

Chronogramme :

Exemple 5 : décompteur synchrone modulo 4

- Réaliser un décompteur binaire synchrone modulo 4 à l’aide de bascule D à front montant. De la même manière, on a besoin de 2 bascules D pour réaliser ce décompteur.


Valeur

3 1 1 1 0 1 0

2 1 0 0 1 0 1

1 0 1 0 0 0 0

0 0 0 1 1 1 1






/ 0 1

0 1 0

1 0 1

/ 0 1

0 1 0

1 1 0

Le circuit : Chronogramme :

Exemple 6 : compteur synchrone modulo 5

- Réaliser un compteur synchrone modulo 5 formé de bascule J-K à front descendant. On a besoin de 3 bascules pour réaliser ce compteur car : 4<5<=8=23


Valeur

0 0 0 0 0 0 1 0 X 0 X 1 X

1 0 0 1 0 1 0 0 X 1 X X 1

2 0 1 0 0 1 1 0 X X 0 1 X

3 0 1 1 1 0 0 1 X X 1 X 1

4 1 0 0 0 0 0 X 1 0 X 0 X

5 1 0 1 X X X X X X X X X

6 1 1 0 X X X X X X X X X

7 1 1 1 X X X X X X X X X






Le circuit :

00 01 11 10

0 0 0 1 0

1 X X X X

00 01 11 10

0 X X X X

1 1 X X X

00 01 11 10

0 0 1 X X

1 0 X X X

00 01 11 10

0 X X 1 0

1 X X X X

00 01 11 10

0 1 X X 1

1 0 X X X

00 01 11 10

0 X 1 1 X

1 X X X X

J3 Q3 >H3 K3 /Q3

J2 Q2 > H2 K2 /Q2

J1 Q1 >H1 K1 /Q1

H

1 1





Chronogramme :

Fin du chapitre





Chapitre 5 : Les Registres

Introduction

Un registre est un circuit séquentiel synchrone qui permet la mémorisation de n bits en même temps. Il existe dans un ordinateur plusieurs variétés de registres, les registres parallèles, les registres à décalage (décalage à droite ou décalage à gauche) les registres séries.

Les bascules de type D sont les plus utilisées pour construire des registres de différents types en fonction de la disposition des entrées et des sorties des bascules :

les registres à entrée série/sortie série, à entrée série/sortie parallèle, à entrée parallèle/sortie parallèle, à entrée parallèle/sortie série.

On distingue deux types de registres :

Registre de mémorisation Registre à décalage

5.1. Registre de mémorisation

Un registre de mémorisation (ou registre de données) est un registre capable de réaliser la fonction de mémorisation en emmagasinant une information binaire sous forme d’un mot de n bits.

Voici un exemple de registre à n entrées parallèles (a0,a1,…,an-1) et à n sorties parallèles (s0,s1,…,sn-1) construit avec des bascules de type D :

Examinons le fonctionnement de ce « registre » : - C’est un registre parallèle à n bits : - La ligne H fournit le signal d’horloge, et permet de charger les n bits





- La ligne w permet de lire l’information sur n bits Lorsque w= 0 on a (s0=0, s1=0, …, sn-1=0) Lorsque w = 1 on a (s0= Q0, s1= Q1, …, sn-1= Qn-1)

5.2. Registre à décalage Un registre à décalage est un registre ayant la possibilité de décaler à droite ou à gauche ou réversible son contenu. Ce type de registre est principalement utilisé comme mémoire d’information dynamique ; la fonction de décalage consiste de faire glisser l’information de chaque cellule élémentaire dans une autre cellule élémentaire adjacente. 5.2.1 Registre à décalage à droite Il est composé de n bascules interconnectées de façon à ce que l’état logique de la sortie Qi de la ième bascule soit reproduit à la sortie Qi+1 de la (i+1)ème bascule quand un signal d’horloge est appliqué à l’ensemble des bascules. Ce type de registre à décalage possède une seule entrée à gauche Eg et n sorties (Q1, Q2,…, Qn).

Exemple : Registre à décalage à droite formé de quatre bascules type D à front montant. Les expressions algébriques des variables des variables d’entrée : Nous avons :

(caractéristique du décalage à droite)

(caracteristique de la bascule D)

A partir de ces deux égalités, on déduit que : D’où :

Horloge

Entrée à Gauche Eg

Sorties (Q1, Q2,…, Qn)

Registre à décalage à droite





Le circuit : 5.2.2 Registre à décalage à gauche Il est composé de n bascules interconnectées de façon à ce que l’état logique de la sortie Qi+1 de la (i+1)ème bascule soit reproduit à la sortie Qi de la ième bascule quand un signal d’horloge est appliqué à l’ensemble des bascules. Ce type de registre à décalage possède une seule entrée à droite Ed et n sorties (Q1, Q2,…, Qn). Exemple : Registre à décalage à gauche formé de quatre bascules type D à front montant. Les expressions algébriques des variables des variables d’entrée : Nous avons :

(caractéristique du décalage à gauche)

(caracteristique de la bascule D)

A partir de ces deux égalités, on déduit que : D’où :

D1 Q1 >H1

D2 Q2 >H2

D3 Q3 >H3

D4 Q4 >H4

Q1 Q2 Q3 Q4

Horloge

Entrée à droite Ed


Registre à décalage à gauche

Eg

H





Le circuit :

5.2.3. Registre à décalage réversible C’est la composition des deux registres précédents en ajoutant une entrée supplémentaire pour la sélection du sens de décalage. Ce type de décalage possède n sorties (Q1, Q2,…, Qn) et deux entrées Ed et Eg telles que Ed est l’entrée à droite et Eg est l’entrée à gauche. Exemple : Registre à décalage à gauche ou à droite formé de quatre bascules type D à front montant. Un tel registre possède une entrée de commande x pour la sélection du sens de décalage, telle que : correspond au décalage à droite correspond au décalage à gauche

Rappelons que :

- Les équations d’un registre à décalage à droite, formé de 4 bascules D à front montant sont :

D2 Q2 >H2

D3 Q3 >H3

Q2 Q3 Q4

H

D1 Q1 >H1

D4 Q4 >H4

< Ed

Q1

Horloge

Entrée à droite Ed


Registre à décalage à gauche

Entrée à Gauche Eg

Entrée de commande





- Les équations d’un registre à décalage à gauche, formé de 4 bascules D à front montant sont :

D’après la table de vérité :

0

1

- Les équations d’un registre à décalage à droite ou à droite, formé de 4 bascules D à front

montant sont :

Le circuit :





5.3. Types de registres à décalage On distingue quatre (04) types de registres à décalage : Registre à entrée série et sortie série ( serial in seriel out ) : SISO Registre à entrée série et sortie parallèle (serial in paralel out) : SIPO Registre à entrée parallèle et sortie parallèle : PIPO Registre à entrée parallèle et sortie série : PISO

5.3.1 registre à entrée série et sortie série (SISO) Dans ce type de registre, l’information est introduite bit par bit à l’entrée de la première bascule et se propagent à travers le registre à chaque impulsion d’horloge, pour sortir par la dernière bascule, c’est donc une sortie série.

5.3.2 Registre à entrée série et sortie parallèle (SIPO) C'est un type de registre dans lequel les données arrivent en série ( bit par bit) et ressortent en parallèle ( en un seul bloc).

La transmission parallèle des informations d'un registre à un autre est la plus facile. La transmission série utilise peux d'élément donc peux coûteux.





5.3.3 Registre à entrée parallèle et sortie parallèle (PIPO) Dans ce type de registre, l’information est introduite en un seul bloc et récupérée de la même façon.

5.3.4 Registre à entrée parallèle et sortie série (PISO) Dans ce type de registre, l’information ou la donnée est introduite en un seul bloc, mais ne peut être récupérée que bit par bit.

Fin du chapitre





Cours strm mme_touil_all

Internet