Architecture 2-CL & UF

Plan cours Architecture
• I - Introduction aux Ordinateurs

• II - Structure de l’information digitale
III - Circuit Logique et Unités
Fonctionnelles
• IV - Les Mémoires
• V - Le processeur
• VI - Architectures Actuelles
• VII - Assemblage de l’UC
J.Elhachmi & Med Senhadji Architecture_CL&UF 1

Chapitre III : CL & UF
• I - Elément de Mémoire
• II - Registre
• III - Bus
• IV - Multiplexage des bus
• V - Compteur
• VI - Opérations Arithmétique & Logique

Elément Mémoire
 Avec une Bascule on peut mémoriser une information sur

un seul bit.
 Avec un registre , il est possible de mémoriser une

information de n bits.
 Si on veut mémoriser une information de taille importante

 il faut utiliser une mémoire.

Elément Mémoire
LES BASCULES:
- Les bascules sont de manière générale des bistables, ce qui

permet d'obtenir des niveaux logiques stables sur leur
sorties (soit "1" ou "0").
- Elles réalisent de ce fait une fonction mémoire temporaire

permettant ainsi de stocker des informations. Ces dernières
pouvant être aussi annulées à tout moment.
 Bistable: Qui possède deux états stables. En logique
ceci se traduit par les états logiques "1" ou "0".
 Monostable: Qui possède un seul état stable, l'autre
état est temporaire
Elément Mémoire

Elément Mémoire
BASCULE R-S: table de vérité
BASCULE R-S: fonctionnement

Elément Mémoire
BASCULE R-S: réalisation

Elément Mémoire
BASCULE R-S-H ( Bascule synchrone):

Elément Mémoire
BASCULE R-S-H ( Bascule synchrone):

Elément Mémoire
Application : Diviseur de fréquence

Bascule D : (Delay)ou Latch
A partir d’une bascule R-S-H, on commande les entrées par le même en utilisant un
inverseur sur S.

Bascule JK :
Le principe des bascules dynamiques permet de mieux protéger la
bascule contre les changements indésirables des entrées. La bascule JK
permet en plus de lever l’ambiguïté qui existe pour l’état S=R=1 d’une
bascule SR.
Son symbole et sa table de vérité sont les suivants :

Bascule JK : Utilité
Si on utilise la bascule JK avec J = K = 1, on obtient l’une
des principales applications de la bascule JK à savoir le
diviseur de fréquence par 2 :

Utilité : Diviseur par 2
vvvvv
+5V
Q
D
Ck Q
1
2
Ck
T T T
Application : éliminer les différences entre 1 et 2 pour avoir des cycles constants

Fonctionnement forcé des bascules
Il est parfois nécessaire d’affecter le niveau de sortie d’une bascule de manière

non synchrone c'est-à-dire indépendamment de l’horloge.
C’est le rôle des entrées de forçage asynchrone Preset (Set) et Clear (Clr) qui
permettent d’initialiser la bascule :

Elément Mémoire :récapitulatif
Set J Q S Q
C C
Reset K Q R Q
3 Etats : b7 . . . . . . b0
S
S1 C
CQ R
R0 Q7 Q0

Utilité : Diviseur par 2
vvvvv
+5V
Q
D
Ck Q
1
2
Ck
T T T
Application : éliminer les différences entre 1 et 2 pour avoir des cycles constants

Registres
Qn Qn-1 Q0
Set
D D D
Dn Dn-1 D0
Ck
Clear
bn bn-1 b0

Bus
Commande
Ck
Ck
S D
Registre Registre
ou ou
Mémoire Mémoire

Transfert parallèle
An An-1 A0 Bn Bn-1 B0
Bus
Sn Sn-1 S0

Multiplexage Démultiplexage des bus
• Lorsque le nombre d ’unité a interconnecter

est important :

Multiplexage des bus

Compteur Binaire
Un compteur est un ensemble de n bascules interconnectées
par des portes logiques. Ils peuvent décrire, au rythme d’un
signal de commande appelé horloge, une suite d'états
binaires.
Il ne peut y avoir au maximum que 2n combinaisons et le

nombre total N des combinaisons successives est appelé le
modulo du compteur. Les compteurs binaires peuvent être
classés en deux catégories :
 Les compteurs asynchrones ;

 Les compteurs synchrones ;

Compteur Binaire
1. Compteur asynchrone modulo N = 2n :
Ce type de compteur est constitué de n bascules JK fonctionnant en mode
T (Toggle) : J=K=1.
bascules sont montées en cascade c'est-à-dire le signal d’horloge
commande uniquement la première bascule tandis que pour chacune des
autres bascules le signal d'horloge est fourni par la sortie de la bascule de
rang immédiatement inférieur.
Exemple : Compteur asynchrone module 8

Compteur Binaire
1. Compteur asynchrone modulo N = 2n :
Exemple : Compteur asynchrone module 8

Pour bien comprendre le principe, réalisons un compteur modulo 8
permettant de compter de 0 à 7 comme le montre la figure suivante :

Compteur Binaire
Les Chronogrammes et table de vérité d’un tel compteur sont ainsi:

Compteur Binaire
Les Chronogrammes et table de vérité d’un tel compteur sont ainsi:

Compteur Binaire
0 1 2 3 4 5 6 7 8 9
Ck
QA
QB
QC
QD
0 1 0 1 0 1 0 1 0 1 0
0 0 1 1 0 0 1 1 0 0 1
0 0 0 0 1 1 1 1 0 0 0
0 0 0 0 0 0 0 0 1 1 1
Utilité : PC, Timer, Distributeur de phase

Opérations
Arithmétique
&
Logique
Les registres : présentation
Un registre est constitué d’un assemblage de n bascules D permettant la

mémorisation temporaire de n bits avec ou sans décalage.
L'information est emmagasinée sur un signal de commande et ensuite
conservée et disponible en lecture.
C’est le signal d'écriture W (Write) qui commande la mémorisation des

données D0, D1, D2 et D3.

Registre à décalage : principe
Souvent formés de bascules synchrones reliées l'une à la suite de l'autre et

commandées par le même signal d'horloge.
L'état de la première bascule se décale aux bascules suivantes d'où le nom
de «circuits à décalage».
La propriété de décalage d’un registre permet le déplacement des données

de l’entrée vers la sortie du registre de différentes manières

Il existe plusieurs types de registres :
– Registre à entrées parallèles et sorties parallèles

(Registre à chargement parallèle ).
– Registre à entrée série et sortie série
– Registre à entrée série et sortie parallèle.
– Registre à entrée parallèle et sortie série.
– Registre à décalage circulaire.

Registre à entrées parallèles et sorties parallèles (Registre à chargement parallèle)
• Il peut charger une information sur N bits en même temps.

• Les n bascules changement d’états en même temps.
• Chaque bascule Bi prend la valeur de l’information i.
• Il possède une entrée de chargement chg ( chg=0  état
mémoire, chg=1  chargement )

Ck
Es
Q0
Q1
Q2
Q3

Registre à entrées série et sorties série (Registre à chargement série)
• L’information est introduite bit par bit ( en série).

• L'ensemble du registre est décalé d'une position ( Bi, Bi+1)
et la bascule B0 reçoit une nouvelle entrée ES.
• Un tel registre est appelé registre à entrée série à gauche et à
sortie série à droite.

Registre à entrée série à droite et à sortie série à gauche.

Ck
Es
Q0
Q1
Q2
Q3

Décalage à droite
QA QB QC QD
Set Set Set Set
Es D Q D Q D Q D Q Ss
Clear Clear Clear Clear

Ck

Décalage à droite
QA QB QC QD
Set Set Set Set

Ck

Décalage à droite
A B C D
Load //
QA QB QC QD
Set Set Set Set

Ck

Décalage à gauche
A B C D
Load //
QA QB QC QD
Set Set Set Set
Ss D Q D Q D Q D Q Es

Ck

Le circuit 74LS194A
A B C D
R L
S0
Clear
S1
QA QB QC QD
Ck
S0 S1
0 0 Hold
0 1 Shift Right R QA,QA QB,QB QC,QC QD
1 0 Shift Left L QD,QD QC,QC QB,QB QA
1 1 Load // A QA,B QB,C QC,D QD

Opérations Arith. & Logique
Opérateurs Elémentaires
Ri R0
+, - , Acc
OU
ET
XO
R
* ,/
ALU
Op. Elem ......... Op. Elem
Q Q Q Q
S1 S2 S1i S2i S10 S20
Q Q
D D
Acc Acci Acc0
ALU Op. Elem ....... Op. Elem
S Si S0

Additionneur Binaire
ADDITION DE DEUX CHIFFRES BINAIRES
Puisque nous connaissons les règles de l'addition binaire, nous

allons voir à présent comment cette opération peut être réalisée par
des circuits logiques.
Il faut réaliser un circuit combinatoire (figure 2) dont les deux
entrées A et B et les sorties S et C répondent à la table de vérité de
la figure suivante.

ADDITION DE DEUX CHIFFRES BINAIRES
• On remarque que S est à l'état 1 si une seule des entrées est à l'état 1.
Nous avons donc affaire à la fonction logique OU Exclusif, soit :
• D'autre part, on remarque que C est à l'état 1 uniquement dans le cas

où A et B sont à l'état 1. On en déduit donc que :

ADDITION DE NOMBRES BINAIRES DE PLUSIEURS CHIFFRES
Il faut donc réaliser un circuit qui puisse additionner les deux

chiffres de même rang d'un nombre binaire avec la retenue de
l'étage précédent, soit trois chiffres binaires.

Table de vérité
A B R’ R S Etage additionneur
0 0 0 0 0
0 0 1 0 1 An Sn
Bn ADD
0 1 0 0 1 R’n-1 Rn
0 1 1 1 0
1 0 0 0 1
1 0 1 1 0
1 1 0 1 0
1 1 1 1 1

.......
Q Q Q
D D D
Accn Acc1 Acc0
Acc0
ADD ADD 1/2ADD
Bn .......... B1 B0

A1 A2 A3 A4
1 2 3 4
B1 B2 B3 B4
r0  r1 r2 r3 r4
2 3
Retard n étages n
Pour éviter le retard :
r1 = f(A1,B1,r0)
r2 = f(A1,B1,A2,B2,r0)
r3 =
f(A1,B1,A2,B2,A3,B3,r0)
exemple : 74LS83
Assemblage d ’additionneur
A16 B16
….. A13 B13 A4 B4
….. A1 B1
C15 74LS83 C12 C8 C0 C4 74LS83 C0
S16 S13 S12 S9 S8 S5 S4 S1

Additionneur BCD
9 9 9 9
Problème de la retenu
4 3 2 1
+
4 3 2 1 A+B+6
5 4 3 2 1
Oui Retenu Non
Exemples :
- 3+4 A+B+6 A+B

- 7+8
- 41+83
- 34+69 Résultat Résultat
- 39+19

Additionneur BCD 1er étage
4 3 2 1
1 (1111) +
 0’ 4 3 2 1
74LS83
1 (1111) 0 5 4 3 2 1
74LS83
r r0’ (0110)
r r0
0
 0’ 74LS157 1
Select
Strobe
r1
Med Senhadji Architecture_CL&UF 55

Additionneur BCD dernier étage
4 3 2 1
4 (1111) +
 0’ 4 3 2 1
74LS83
4 (1111) 0 5 4 3 2 1
74LS83
r r4 (0110)
r3 r r0
0
 0’ 74LS157 4
Select
Strobe (0001) 5
74LS157
(0000)
Select

Soustraction
Le traitement se fait selon deux solutions :
– signe et valeur absolue + N
– complément à 2 (utilisation d ’un additionneur comme soustracteur)
SN 74H87 : complément vrai ( ou restreint )
Table de vérité :
Entré de Sortie
contrôle
B A4 A3 A2 A1 B C Y1 Y2 Y3 Y4
74H87 _ _ _ _
C L L A1 A2 A3 A4
Y4 Y3 Y2 Y1
L H A1 A2 A3 A4
H L H H H H
H H L L L L

Soustraction/Addition
Extension 8 bits Addition/Soustraction (4bits)
A8 A7 A6 A5 C A4 A3 A2 A1 C
74H87 B 74H87 B
Y4 Y3 Y2 Y1 Y4 Y3 Y2 Y1
... B8 B7 B6 B5 A8 A7 A6 A5
C4
8
74LS83
7 6 5
C0
B4 B3 B2 B1 A4 A3 A2 A1
C4
4
74LS83
3 2 1
C0
Op
Op=0 Soust.
Somme/Différence Somme/Différence Op=1 Add.

Multiplication Binaire
1011 Multiplicande : A 1 0 1 1
0101 Multiplicateur : B 0 1 0 1
Décalage a droite

0101 Multiplicateur : B 0 0 0 0 0 1 0 1
Décalage a droite
Remplissage par des 0

+
1011
- Test du bit de droite
- si 1 addition (A+BH) BH
Décalage a droite (1)

1011
- Test du bit de droite
- si 1 addition (A+BH) BH

1011
0000 - Test du bit de droite

1011

+
1011
1011 - si 1 addition (A+BH) BH

1011
1011 - si 1 addition (A+BH) BH

1011
1011

0101 Multiplicateur : B 0 0 1 1 0 1 1 1 0
1011
0000
1011
110111 Le registre B contient le résultat

1011 Multiplicande : A
0101 Multiplicateur : B Oui Bit BL0 Non
=0
1011
0000 .
(A +BH) BH
1011 .
110111
Déroulement : Décalage droite
de BH,BL
- Chargement du Multiplicande dans A
- Chargement Multiplicateur dans BH
- Décalage droite BH,BL Non Dernier bit Oui Fin
multiplicateur

Multiplicateur
L R L
R
S0 S0 Clear
S1 S1 74LS194
QA QB QC QD
Ck
Ck
S0 S1
0 0 Hold
C4 74LS83 C0
S4 S1 0 1 Shift Right
1 0 Shift Left
1 1 Load //
Multiplicande

Multiplicateur
0 1 0 1 Chargement registre Multiplicateur
Décalage a droite du RD
L R L
R
séquenceur
S0 0 1 0 1 S0 Clear
S1 S1 74LS194
QA QB QC QD
Ck
Ck
S0 S1
0 0 Hold
C4 74LS83 C0
1 0 Shift Left
1 1 Load //
Multiplicande

Multiplicateur
0 0 0 0 RAZ du registre Multiplicateur
Chargement dans le RD
L R L
R
séquenceur
S0 0 0 0 0 S0 Clear
S1 S1 0 1 0 1
QA QB QC QD
Ck
Ck
S0 S1
0 0 Hold
C4 74LS83 C0
1 0 Shift Left
1 1 Load //
1 0 1 1 Chargement Multiplicande
Multiplicande

Multiplicateur
0 0 0 0
L R L
R
séquenceur
S0 0 0 0 0 S0 Clear
S1 S1 0 1 0 1
QA QB QC QD
Ck
Ck
S0 S1
0 0 Hold
C4 1 0 1 1 C0
1 0 Shift Left
1 1 Load //
1 0 1 1 Chargement Multiplicande
Multiplicande

Multiplicateur
1er Bit est : 1 Addition & décallage
0 0 0 0
L R L
R
séquenceur
S0 0 0 0 0 S0 Clear
S1 S1 0 1 0 1
QA QB QC QD
Ck
Ck 1
S0 S1
0 0 Hold
C4 1 0 1 1 C0
1 0 Shift Left
1 1 Load //
1 0 1 1
Multiplicande

Multiplicateur
1er Bit est : 1  Addition & décallage
0 0 0 0
L R L
R
séquenceur
1 S0 0 0 0 0 S0 Clear
S1 S1 0 1 0 1
1 QA QB QC QD
Ck
Ck 1
S0 S1
0 0 Hold
C4 1 0 1 1 C0
1 0 Shift Left
1 1 Load //
1 0 1 1
Multiplicande

Multiplicateur
Addition A+ BH
0 0 0 0
L R L
R
séquenceur
1 S0 1 0 1 1 S0 Clear
S1 S1 0 1 0 1
1 QA QB QC QD
Ck
Ck 1
S0 S1
0 0 Hold
C4 1 0 1 1 C0
1 0 Shift Left
1 1 Load //
1 0 1 1
Multiplicande

Multiplicateur
Décalage droite du RD
0 0 0 0
L R L
R
séquenceur
0 S0 1 0 1 1 S0 Clear
S1 S1 0 1 0 1
1 QA QB QC QD
Ck
Ck 1
S0 S1
0 0 Hold
C4 1 0 1 1 C0
1 0 Shift Left
1 1 Load //
1 0 1 1
Multiplicande

Multiplicateur
0 0 0 0
L R L
R
séquenceur
0 S0 0 1 0 1 S0 Clear
S1 S1 1 0 1 0
1 QA QB QC QD
Ck
Ck
S0 S1
0 0 Hold
C4 1 0 1 1 C0
1 0 Shift Left
1 1 Load //
1 0 1 1
Multiplicande

Multiplicateur
Test du 2eme bit
0 0 0 0
Décalage droite
L R L
R
séquenceur
0 S0 0 1 0 1 S0 Clear
S1 S1 1 0 1 0
1 QA QB QC QD
Ck
Ck 0
S0 S1
0 0 Hold
C4 1 0 1 1 C0
1 0 Shift Left
1 1 Load //
1 0 1 1
Multiplicande

Multiplicateur
Test du 3eme bit
0 0 0 0
Addition A+BH
L R L
R
séquenceur
1 S0 0 0 1 0 S0 Clear
S1 S1 1 1 0 1
1 QA QB QC QD
Ck
Ck 1
S0 S1
0 0 Hold
C4 1 0 1 1 C0
1 0 Shift Left
1 1 Load //
1 0 1 1
Multiplicande

Multiplicateur
Addition A+ BH
0 0 0 0
L R L
R
séquenceur
1 S0 1 1 0 1 S0 Clear
S1 S1 1 1 0 1
1 QA QB QC QD
Ck
Ck 1
S0 S1
0 0 Hold
C4 1 0 1 1 C0
1 0 Shift Left
1 1 Load //
1 0 1 1
Multiplicande

Multiplicateur
0 0 0 0
L R L
R
séquenceur
0 S0 1 1 0 1 S0 Clear
S1 S1 1 1 0 1
1 QA QB QC QD
Ck
Ck 1
S0 S1
0 0 Hold
C4 1 0 1 1 C0
1 0 Shift Left
1 1 Load //
1 0 1 1
Multiplicande

Multiplicateur
Test du 4eme bit
0 0 0 0
Décalage a droite
L R L
R
séquenceur
0 S0 0 1 1 0 S0 Clear
S1 S1 1 1 1 0
1 QA QB QC QD
Ck
Ck 0
S0 S1
0 0 Hold
C4 1 0 1 1 C0
1 0 Shift Left
1 1 Load //
1 0 1 1
Multiplicande

Multiplicateur
0 0 0 0
Décalage a droite
L R L
R
séquenceur
0 S0 0 0 1 1 S0 Clear
S1 S1 0 1 1 1
1 QA QB QC QD
Ck
Ck
S0 S1
0 0 Hold
C4 1 0 1 1 C0
1 0 Shift Left
1 1 Load //
1 0 1 1
Multiplicande

Multiplication Rapide
P6 P5 P4 P3 P2 P1 P0 = M3 M2 M1 M0 * N2 N1 N0
M3 M2 M1 M0
N2 N1 N0
N0M3 N0M2 N0M1 N0M0

N1M3 N1M2 N1M1 N1M0
N2M3 N2M2 N2 M1 N2 M0
P6 P5 P4 P3 P2 P1 P0

Multiplication Rapide
M0 P0
P1
M0 C0 M0 C0
P2
M1
M1 M1 P3
3
3
M2
S8
S8
7 4L
P4
7 4L
M2 M2
M3
P5
M3 M3
C4 C4 P6
N0 N1 N2

Division Binaire
100101 101 Dividende : A 0 0 1 0 0 1 0 1

0 Diviseur :B 0 1 0 1
Comparaison de AH et de B :
- Si AH < B décalage gauche de A et A0=0
- Si AH >= B alors (AH - B)  AH
Puis décalage à gauche et A0=1

Division Binaire
100101 101 Dividende : A 0 0 1 0 0 1 0 1

-000 0 Diviseur :B 0 1 0 1
10
AH < B décalage gauche du registres A
Et A0=0

Division Binaire
100101 101 Dividende : A 0 1 0 0 1 0 1 0

-000 00 Diviseur :B 0 1 0 1
10 0
000
AH < B décalage gauche du registre A
et A0=0

Division Binaire
100101 101 Dividende : A 0 1 0 0 1 0 1 0

-000 00 Diviseur :B 0 1 0 1
10 0
-000
Décalage gauche du registre A
1001

Division Binaire
100101 101 Dividende : A 1 0 0 1 0 1 0 0

-000 0 01 Diviseur :B 0 1 0 1
10 0
-000
1001
AH > B Donc AH - B  AH
Puis décalage de A vers la gauche et A0=1

Division Binaire
100101 101 Dividende : A 1 0 0 1 0 1 0 0

-000 0 01 Diviseur :B 0 1 0 1
10 0
-000
1001
-101

Division Binaire
100101 101 Dividende : A 1 0 0 1 0 1 0 0

-000 0 01 Diviseur :B 0 1 0 1
10 0
-000
(AH - B)  AH
1001
-101
100

Division Binaire
100101 101 Dividende : A 0 1 0 0 0 1 0 0

-000 0 01 Diviseur :B 0 1 0 1
10 0
-000
(AH - B)  AH
1001
-101
100

Division Binaire
100101 101 Dividende : A 1 0 0 0 1 0 0 1

-000 0 01 Diviseur :B 0 1 0 1
10 0
-000
1001
-101 1
A0
1000

Division Binaire
100101 101 Dividende : A 1 0 0 0 1 0 0 1

-000 0 011 Diviseur :B 0 1 0 1
10 0
-000
1001 AH > B
-101
1000 (AH - B)  AH
-101
011

Division Binaire
100101 101 Dividende : A 0 0 1 1 1 0 0 1

-000 0 011 Diviseur :B 0 1 0 1
10 0
-000
Décalage gauche du registre A et
1001
-101 A0 1
1000
-101
011

Division Binaire
100101 101 Dividende : A 0 1 1 1 0 0 1 1

-000 0 011 Diviseur :B 0 1 0 1
10 0
-000
Décalage gauche du registre A et
100
-101 A0 1
1000
-101
011 1
-101
010

Division Binaire
100101 101 Dividende : A 0 0 1 0 0 0 1 1

-000 0 0 1 11 Diviseur :B 0 1 0 1
10 0
-000
(AH - B)  AH
100
-101
1000
-101
011 1
-101
010

Division Binaire
100101 101 Dividende : A 0 1 0 0 0 1 1 1

-000 0 0 1 11 Diviseur :B 0 1 0 1
10 0
-000
Décalage à gauche puis
100
-101
A0 1
1000
-101
011 1
-101
010

Exercice
• Réaliser les circuits qui peuvent faire cette

opération et vérifier le fonctionnement en
exécutant l ’opération en mode pas a pas.
• Utilisez les circuits suivant :
– registre à décalage
– Comparateur 74HC85 ou SN54LS682
– addition/soustraction

Architecture 2-CL &amp; UF

Transféré par

Informations du document

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Architecture 2-CL &amp; UF

Transféré par

Droits d'auteur :

Formats disponibles

Plan cours Architecture

• I - Introduction aux Ordinateurs

J.Elhachmi & Med Senhadji Architecture_CL&UF 1

J.Elhachmi & Med Senhadji Architecture_CL&UF 2

 Avec une Bascule on peut mémoriser une information sur

 Avec un registre , il est possible de mémoriser une

 Si on veut mémoriser une information de taille importante

J.Elhachmi & Med Senhadji Architecture_CL&UF 3

- Les bascules sont de manière générale des bistables, ce qui

- Elles réalisent de ce fait une fonction mémoire temporaire

J.Elhachmi & Med Senhadji Architecture_CL&UF 5

BASCULE R-S: fonctionnement

J.Elhachmi & Med Senhadji Architecture_CL&UF 6

J.Elhachmi & Med Senhadji Architecture_CL&UF 7

J.Elhachmi & Med Senhadji Architecture_CL&UF 8

J.Elhachmi & Med Senhadji Architecture_CL&UF 9

J.Elhachmi & Med Senhadji Architecture_CL&UF 10

J.Elhachmi & Med Senhadji Architecture_CL&UF 11

J.Elhachmi & Med Senhadji Architecture_CL&UF 12

J.Elhachmi & Med Senhadji Architecture_CL&UF 13

J.Elhachmi & Med Senhadji Architecture_CL&UF 14

Il est parfois nécessaire d’affecter le niveau de sortie d’une bascule de manière

J.Elhachmi & Med Senhadji Architecture_CL&UF 15

J.Elhachmi & Med Senhadji Architecture_CL&UF 16

J.Elhachmi & Med Senhadji Architecture_CL&UF 17

J.Elhachmi & Med Senhadji Architecture_CL&UF 18

J.Elhachmi & Med Senhadji Architecture_CL&UF 19

J.Elhachmi & Med Senhadji Architecture_CL&UF 20

• Lorsque le nombre d ’unité a interconnecter

J.Elhachmi & Med Senhadji Architecture_CL&UF 21

J.Elhachmi & Med Senhadji Architecture_CL&UF 22

Il ne peut y avoir au maximum que 2n combinaisons et le

 Les compteurs asynchrones ;

J.Elhachmi & Med Senhadji Architecture_CL&UF 23

Exemple : Compteur asynchrone module 8

J.Elhachmi & Med Senhadji Architecture_CL&UF 24

Exemple : Compteur asynchrone module 8

J.Elhachmi & Med Senhadji Architecture_CL&UF 25

Les Chronogrammes et table de vérité d’un tel compteur sont ainsi:

J.Elhachmi & Med Senhadji Architecture_CL&UF 26

J.Elhachmi & Med Senhadji Architecture_CL&UF 27

Utilité : PC, Timer, Distributeur de phase

J.Elhachmi & Med Senhadji Architecture_CL&UF 28

Un registre est constitué d’un assemblage de n bascules D permettant la

C’est le signal d'écriture W (Write) qui commande la mémorisation des

J.Elhachmi & Med Senhadji Architecture_CL&UF 31

Souvent formés de bascules synchrones reliées l'une à la suite de l'autre et

La propriété de décalage d’un registre permet le déplacement des données

J.Elhachmi & Med Senhadji Architecture_CL&UF 32

Il existe plusieurs types de registres :

– Registre à entrées parallèles et sorties parallèles

J.Elhachmi & Med Senhadji Architecture_CL&UF 33

• Il peut charger une information sur N bits en même temps.

J.Elhachmi & Med Senhadji Architecture_CL&UF 34

J.Elhachmi & Med Senhadji Architecture_CL&UF 35

• L’information est introduite bit par bit ( en série).

J.Elhachmi & Med Senhadji Architecture_CL&UF 36

J.Elhachmi & Med Senhadji Architecture_CL&UF 37

J.Elhachmi & Med Senhadji Architecture_CL&UF 38

Clear Clear Clear Clear

J.Elhachmi & Med Senhadji Architecture_CL&UF 39

Clear Clear Clear Clear

J.Elhachmi & Med Senhadji Architecture_CL&UF 40

Clear Clear Clear Clear

Architecture 2-CL & UF

Architecture 2-CL & UF