Vous êtes sur la page 1sur 74

Plan du cours : 1ère Partie (1/3)

 Introduction

 1ère Partie : Concepts de base


• Structure générale de l’ordinateur
• Représentation interne des données
• Éléments de logique
 2ème Partie : Traitement des données : les processeurs
 3ème Partie : Stockage des informations : les mémoires
 4ème Partie : Transfert des informations : les bus
 Conclusion

Année 2003-2004 Initiation à l'architecture des ordinateurs 1


Machine de Von Neumann (1/4)

Mémoire

Résultat des Instructions et Données


Opérations

Unité de Calcul Unité de


Arithmétique Contrôle Périphériques
et Logique (U C) (Clavier,Terminal,
(U A L) Imprimante, etc...)

Année 2003-2004 Initiation à l'architecture des ordinateurs 2


Chemin des données (2/4)

A+B

A
Registres
de travail
B

A B Registres d’entrée de L’UAL

UAL

A+B Registres de sortie de L’UAL

Année 2003-2004 Initiation à l'architecture des ordinateurs 3


Structure d’une instruction (3/4)

Code Opération Opérandes

 Types d’opération :
• Transfert de données (Load, Store, Move, …)
• Opérations arithmétiques (ADD, SUB, …)
• Opération logiques (NOT, OR, AND, XOR, …)
• Contrôle de séquence (Branch, Branch on condition, …)
• Entrées/Sorties (Read, Write, Print, Display)

Année 2003-2004 Initiation à l'architecture des ordinateurs 4


Exécution d’une instruction (4/4)

1. Charger la prochaine instruction à exécuter :


Mémoire => Registre d’instruction
2. Décoder le code opération de l’instruction
3. Modifier le compteur ordinal pour qu’il pointe sur l’adresse de
l’instruction suivante
4. Localiser, s’il y a lieu, les opérandes en mémoire
5. Charger, dans ce cas, ces opérandes dans les registres de l’UC
6. Exécuter l’instruction
7. Retourner à l ‘étape N° 1 pour traiter la prochaine instruction

Année 2003-2004 Initiation à l'architecture des ordinateurs 5


Schéma général d’une unité centrale

1. Charger la prochaine instruction à exécuter :


Mémoire => Registre d’instruction:

2. Décoder le code opération de l’instruction;

3. Modifier le compteur ordinal pour qu’il pointe


sur l’adresse de l’instruction suivante;

4. Localiser, s’il y a lieu, les opérandes en


mémoire;

5. Charger, dans ce cas, ces opérandes dans


les registres de l’UC;

6. Exécuter l’instruction;

7. Retourner à l ‘étape N° 1 pour traiter la


prochaine instruction.

D’après « Architecture et Technologie des Ordinateurs »


de Paolo Zanelle et Yves Ligier chez Dunod

Année 2003-2004 Initiation à l'architecture des ordinateurs 6


Plan du cours : 1ère Partie (2/3)
 Introduction

 1ère Partie : Concepts de base


• Structure générale de l’ordinateur
• Représentation interne des données
• Eléments de logique
 2ème Partie : Traitement des données : les processeurs
 3ème Partie : Stockage des informations : les mémoires
 4ème Partie : Transfert des informations : les bus
 Conclusion

Année 2003-2004 Initiation à l'architecture des ordinateurs 7


Représentation de l’information
 Plusieurs façon de représenter la même information :
• Exemples : une lettre: a A α 1000001
un chiffre : 13 XIII 1101 D

 Représentation usuelle des nombres


• base 10 : Symboles utilisés : [0,1,2,3,4,5,6,7,8,9]
• Exemple : 1703 = 1x103 + 7x102 + 0x101 +3x100

 Représentation des nombres en informatique :


• base 2 (Binaire) Symboles [0,1]
• base 16 (Hexadécimal) Symboles [0,1,2,3,4,5,6,7,8,9,A,B,C,D,E,F]
• Base 8 (Octal) Symboles [0,1,2,3,4,5,6,7]

Année 2003-2004 Initiation à l'architecture des ordinateurs 8


Conversion: table de base
Décimal Binaire Hexa Octal
décimal

0 0 0 0

20 1 1 1 1

21 2 10 2 2

3 11 3 3

22 4 100 4 4

5 101 5 5

6 110 6 6

7 111 7 7

23 8 1000 8 10

9 1001 9 11

10 1010 A 12

11 1011 B 13

12 1100 C 14

13 1101 D 15

14 1110 E 16

15 1111 F 17

24 16 10000 10 20

Année 2003-2004 Initiation à l'architecture des ordinateurs 9


Conversion: Puissances de 2

2n Décimal Hexa
décimal
20 1 1
21 2 2
22 4 4
23 8 8 2n Décimal Hexadécimal

24 16 10 210 1 024 400


2 5
32 20
220 1 048 576 100 000
26 64 40
27 128 80 230 1 073 741 824 40 000 000
28 256 100
240 1 099 511 627 776 10 000 000 000
29 512 200
210 1024 400
211 2048 800
212
4096 1000

Année 2003-2004 Initiation à l'architecture des ordinateurs 10


Plan du cours : 1ère Partie (2a/3)
 Introduction

 1ère Partie : Concepts de base


• Structure générale de l’ordinateur
• Représentation interne des données
• Entiers positifs
• Entiers négatifs
• Nombres fractionnaires
 2ème Partie : Traitement des données : les processeurs
 3ème Partie : Stockage des informations : les mémoires
 4ème Partie : Transfert des informations : les bus
 Conclusion

Année 2003-2004 Initiation à l'architecture des ordinateurs 11


Conversion: Décimal => Binaire (1/2)

 Restes successifs de la division par 2

173 / 2 = 86 reste 1
86 / 2 = 43 reste 0 17310 => 101011012
43 / 2 = 21 reste 1
21 / 2 = 10 reste 1
10 / 2 = 5 reste 0
5 / 2 = 2 reste 1
2 / 2 = 1 reste 0
1 / 2 = 0 reste 1

Arrêt lorsque le quotient est nul

Année 2003-2004 Initiation à l'architecture des ordinateurs 12


Conversion: Décimal => Binaire (1/2)

 Restes successifs de la division par 2


173 2
13 86 2
1 06 43 2
0 3 21 2
1 1 10 2
1 0 5 2
1 2 2
0 1 2
1 0

1 0 1 0 1 1 0 1

Année 2003-2004 Initiation à l'architecture des ordinateurs 13


Conversion: Décimal => Binaire (2/2)

 Division par les puissances de 2

128 < 173 <256 17310 => 101011012


27 < 173 < 28 173 / 128 = 1 reste 45
45 / 64 = 0 reste 45
45 / 32 = 1 reste 13
13 / 16 = 0 reste 13
13 / 8 = 1 reste 5
5/ 4 = 1 reste 1
1/ 2 = 0 reste 1
1/ 1 = 1 reste 0

Année 2003-2004 Initiation à l'architecture des ordinateurs 14


Conversion: Binaire => Décimal (1/2)

 Addition des puissances de 2 correspondant aux bits de valeur 1

101011012 => 17310

1 0 1 0 1 1 0 1
1 x 20 = 1 x x x x x x x x
+
0 x 21 = 0 27 26 25 24 23 22 21 20
+
1 x 22 = 4 (128) (64) (32) (16) (8) (4) (2) (1)
+
1 x 23 = 8
+
0 x 24 = 0
+ 128 + 0 + 32 + 0 + 8 + 4 + 0 + 1 173
1 x 2 = 32
5

+
0x2 =6
0
+
1 x 27 = 128
173

Année 2003-2004 Initiation à l'architecture des ordinateurs 15


Conversion: Décimal => Hexadécimal
 Restes successifs de la division par 16

1577510 => 3D9F16


15775 / 16 = 985 reste 15 F
985 / 16 = 61 reste 9 9
61 / 16 = 3 reste 13 D
3 / 16 = 0 reste 3 3

Arrêt lorsque le quotient est nul

Année 2003-2004 Initiation à l'architecture des ordinateurs 16


Conversion: Hexadécimal => Décimal
 On multiplie les chiffres hexadécimaux par les puissances de 16
correspondantes :

Exemple:

E5B716 => 5880710 7 7 x 160 (1) = 7


B 11 x 161 (16) = 176
5 5 x 162 (256) = 1280
E 14 x 163 (4096) = 57344
58807

Année 2003-2004 Initiation à l'architecture des ordinateurs 17


Conversion: Binaire => Hexadécimal

Les 16 symboles du code hexadécimal sont représentés par 4 bits dans le système
binaire (24 = 16), ainsi pour convertir un nombre binaire en hexadécimal, il suffit de
le découper en tranche de 4 bits à partir de la droite (poids les plus faibles) et de
faire correspondre à chaque quartet le code hexadécimal correspondant.

Bit de poids le plus faible


LSB (Less significant
Exemple : Bit)

Binaire 1101 1100 1111 0111 1011 0010 1010 1110


Hexadécimal D C F 7 B 2 A E
(13) (12) (15) (7) (11) (2) (10) (14)

Année 2003-2004 Initiation à l'architecture des ordinateurs 18


Conversion: Hexadécimal => Binaire

Il suffit de faire correspondre à chaque symbole hexadécimal, le quartet binaire


correspondant :

Exemple :

Hexadécimal 3 F B 0 E C 9
(3) (15) (11) (0) (14) (12) (9)

Binaire 0011 1111 1011 0000 1110 1100 1001

Année 2003-2004 Initiation à l'architecture des ordinateurs 19


Arithmétique binaire (1/4)

 Addition

A B ADD Retenue

Retenues
0 0 0 0 1 1 1 1 intermédiaires

101101 Opérande 1
0 1 1 0 +
110101 Opérande 2
1 0 1 0
1 100010 Résultat
1 1 0 1

Retenue (Dépassement de capacité)


Table de vérité (Overflow)

Année 2003-2004 Initiation à l'architecture des ordinateurs 20


Arithmétique binaire (2/4)

 Soustraction

A B A-B Retenue
11011001 Opérande 1
10101110 Opérande 2
0 0 0 0
1 11 1 Retenues intermédiaires
0 1 1 1
00101011 Résultat
1 0 1 0

1 1 0 0

Table de vérité

Année 2003-2004 Initiation à l'architecture des ordinateurs 21


Arithmétique binaire (3/4)

 Multiplication

1011 Opérande 1 (4 chiffres)


A B AxB x
1101 Opérande 2 (4 chiffres)
0 0 0
0 1 0 1011
1 0 0
1011 . .
1011 . Retenues intermédiaires
1 1 1 1 1 1
10001111 Résultat (8 chiffres)
Table de vérité

Année 2003-2004 Initiation à l'architecture des ordinateurs 22


Arithmétique binaire (4/4)

 Division entière

11010110 101 Dividende : 1 1 0 1 0 1 1 0


101 101010 Diviseur : 101
00110
Quotient : 101010
101
00111 Reste : 100
101
0100

Année 2003-2004 Initiation à l'architecture des ordinateurs 23


Plan du cours : 1ère Partie (2b/3)
 Introduction

 1ère Partie : Concepts de base


• Structure générale de l’ordinateur
• Représentation interne des données
• Entiers positifs
• Entiers négatifs
• Nombres fractionnaires
• Eléments de logique
 2ème Partie : Traitement des données : les processeurs
 3ème Partie : Stockage des informations : les mémoires
 4ème Partie : Transfert des informations : les bus
 Conclusion

Année 2003-2004 Initiation à l'architecture des ordinateurs 24


Représentation du signe (1/2)

 Nombres entiers signés


On réserve un digit binaire pour le signe, les autres bits
représentant la valeur absolue du nombre.
Par convention le bit de signe est le bit de plus fort poids (MSB :
Most Significant Bit) situé le plus à gauche du nombre binaire.
Il vaut 0 lorsque le nombre est positif et 1 lorsqu’il est négatif.

Exemple :

01001001 représente + 7310


11001001 représente - 7310

Année 2003-2004 Initiation à l'architecture des ordinateurs 25


Représentation du signe
(2/2)
 Représentation en complément
 Complément restreint (Complément à 1)
Il s’obtient par inversion des valeurs des bits constituant le nombre:

Nombre de départ : 01001001


Complément restreint : 10110110

 Complément vrai (Complément à 2)


Il s’obtient en ajoutant 1 au complément restreint :

Nombre de départ : 01001001


Complément restreint : 10110110
+ 1
Complément vrai : 10110111

Année 2003-2004 Initiation à l'architecture des ordinateurs 26


Soustraction avec le complément restreint (1/2)

La soustraction est obtenue par l’addition du complément


restreint du nombre à soustraire.

Exemple : Soustraire 2810 de 6310

6310 00111111
- +
2810 00011100 11100011

1 00100010 En cas de retenue, celle-ci


1 doit être ajoutée pour
obtenir le résultat final.
3510 00100011

Année 2003-2004 Initiation à l'architecture des ordinateurs 27


Soustraction avec le complément restreint (2/2)

Exemple : Soustraire 6310 de 2810

28 +00011100
- 63 10
00111111 11000000
10

- 3510 11011100 ( -3510 en complément


restreint)

Année 2003-2004 Initiation à l'architecture des ordinateurs 28


Soustraction avec le complément à 2 (1/2)

La soustraction est obtenue par l’addition du complément


à 2 du nombre à soustraire.

Exemple : Soustraire 2810 de 6310

6310 00111111
-
2810 00011100
+
+ 11100011
1
11100100 11100100

3510 00100011

Année 2003-2004 Initiation à l'architecture des ordinateurs 29


Soustraction avec le complément à 2 (2/2)

La soustraction est obtenue par l’addition du complément


à 2 du nombre à soustraire.

Exemple : Soustraire 6310 de 2810

2810 00011100
-
6310 00111111
+
+1 1 0 0 0 0 0 0
1
11000001 11000001
( -35 représenté
- 3510 11011101 en complément à
2)

Année 2003-2004 Initiation à l'architecture des ordinateurs 30


Plan du cours : 1ère Partie (2c/3)
 Introduction

 1ère Partie : Concepts de base


• Structure générale de l’ordinateur
• Représentation interne des données
• Entiers positifs
• Entiers négatifs
• Nombres fractionnaires
 2ème Partie : Traitement des données : les processeurs
 3ème Partie : Stockage des informations : les mémoires
 4ème Partie : Transfert des informations : les bus
 Conclusion

Année 2003-2004 Initiation à l'architecture des ordinateurs 31


Conversion: Décimal => Binaire
 La partie entière du nombre sera convertit comme il a été vu pour les
nombres entiers (restes successifs de la division par 2), et la partie
décimale par les parties entières successives du résultat de la
multiplication par 2 comme illustré sur l’exemple suivant :

0,640625 x 2 = 1, 28125 0,64062510 => 0,1010012

0,28125 x 2 = 0, 5625

0,5625 x 2 = 1,125

0,125 x 2 = 0, 25

0,25 x 2 = 0, 5

0,5 x 2 = 1, 0
Arrêt lorsque la partie décimale est nulle

Année 2003-2004 Initiation à l'architecture des ordinateurs 32


Conversion: Binaire => Décimal

 Addition des puissances de 2 correspondant aux bits de valeur 1

0,1010012 => 0,64062510

1 0 1 0 0 1
1 x 2-1 = 0,5 + x x x x x x
0 x 2-2 = 0 + 2-1 2-2 2-3 2-4 2-5 2-6
1 x 2-3 = 0,125 + (0,5) (0,25) (0,125) (0,0625) (0,03125) (0,015625)
0x2 = 0
-4
+
0 x 2-5 = 0 +
1 x 2-6 = 0,015625 0,5 + 0 + 0,125 + 0 + 0 + 0,015625 0,640625

0,640625

Année 2003-2004 Initiation à l'architecture des ordinateurs 33


Virgule Fixe

Il n’existe pas de virgule au niveau de la représentation dans


l’ordinateur : les nombres fractionnaires sont gérés comme des
entiers et c’est le programmeur qui doit gérer la virgule (qui
n’apparaît pas dans le stockage du nombre) et faire évoluer sa
place au cours des opérations (On parle de virgule virtuelle).
Cela pose de sérieux problèmes pour gérer les calculs avec le
maximum de précision possible car il faut sans cesse apprécier les
ordre de grandeur des résultats intermédiaires en gardant le
maximum de chiffres significatifs tout en évitant les débordements
de capacité.
C’est pourquoi on préfère en général utiliser l’arithmétique en
virgule flottante.

Année 2003-2004 Initiation à l'architecture des ordinateurs 34


Représentation en virgule flottante (1/4)

Dans la notation en virgule flottante, les nombres sont représentés


sous la forme suivante :
Nb = M x B E

Où B = Base ( 2, 10, 16)


M = Mantisse ou Caractéristique
(Nombre purement fractionnaire, généralement normalisée c’est-à-dire dont
le premier chiffre après la virgule est différent de 0 de façon à avoir le
maximum de chiffres significatifs)
E = Exposant

Exemple en décimal : 137,73 s’écrira 0,13773 x 10 +3


58579 s’écrira 0,58579 x 10 +5
0,0000471 s’écrira 0,47100 x 10 -4

Année 2003-2004 Initiation à l'architecture des ordinateurs 35


Représentation en virgule flottante (2/4)

La mantisse et l’exposant peuvent être négatifs :


• la mantisse est généralement un nombre signée (Signe + valeur absolue),
• l’exposant est décalé (ou biaisé), de façon a évité le bit de signe, en lui
ajoutant une valeur égale à la moitié de la plage des valeurs possibles.
Par exemple si l’exposant est codé sur 7 bits permettant de coder 128 valeurs, on lui
ajoutera 64 systématiquement de façon que les 64 premières valeurs correspondent à
un exposant <0 et les 64 suivantes à un exposant ≥0.
Plusieurs norme existe suivant les organismes et les constructeurs.
Par exemple en simple précision (codage sur 4 octets) :
Bit Bit
31 30 29 …………..……….24 23 22 21 …………………………………….. 1 0
• Norme
IEEE S 27 20 2-1 2 -23
Signe Exposant décalé (Base 2) Mantisse

• Norme 31 30 29 ……..…….. 25 24 23 22 …………………………………..…..….. 1 0


IBM S 26 20 2-1 2 -24
Signe Exposant décalé (Base 16) Mantisse

Année 2003-2004 Initiation à l'architecture des ordinateurs 36


Représentation en virgule flottante (3/4)

Exemple : représentation de 75,7510 suivant la norme IBM simple


précision (utilisant la base 16).

7510 => 4B16 2


75,7510 => 4B,C16 = > 0,4BC16 E16
0,7510 => 0,C16

7
Il faut ajouter 2 / 2 pour décaler l’exposant (soit 6410 ou 4016) ce qui
donne : 2Bit16 + 4016 => 4216 Bit
23 22 …..………………………………..…...….. ………..1 0
31 30 29 ………….. 25 24

0 1 0 0 0 0 1 0 0100 1011 1100 0000 0000 0000


0 4216 4BC00016
Signe Exposant décalé Mantisse

Année 2003-2004 Initiation à l'architecture des ordinateurs 37


Représentation en virgule flottante (4/4)

Le standard IEEE 754 définit 3 formats :


• Simple précision : Signe de la mantisse : 1 bits
(32 bits) Exposant : 8 bits (biaisé à 127)

Mantisse : 23 bits
• Double précision : Signe de la mantisse : 1 bits
(64 bits) Exposant : 11 bits (biaisé à 1023)

Mantisse : 52 bits
• Précision étendue sur 80 bits

Année 2003-2004 Initiation à l'architecture des ordinateurs 38


Décimaux codés en binaire (1/2)

Parfois au lieu d’utiliser une arithmétique binaire, certaines


machines, comme par exemple certaines calculatrices de poche,
utilisent une arithmétique décimale.
Dans ce cas, les opérations sont effectuées directement sur la
représentation décimale des nombres.
Chaque chiffre (de 0 à 9) composant le nombre est codé à l’aide
de bits.
Il existe différents codes :
• BCD (Binary coded decimal),
• Excédent-3,
• 2 dans 5,
• etc.

Année 2003-2004 Initiation à l'architecture des ordinateurs 39


Décimaux codés en binaire : BCD (2/2)

Le code BCD (Binary Coded Decimal) ou DCB (Décimal Codé Binaire) et


ses différentes déclinaison est le plus répandu.
En code DCB condensé, chaque chiffre décimal est codé sur 4 bits
selon la table :
23 22 21 20
Chiffre
Décimal 8 4 2 1 Exemple de conversions :
0 0 0 0 0
1 0 0 0 1 Décimal Binaire BCD
2 0 0 1 0
3 0 0 1 1 173 10101101 0001 0111 0011
4 0 1 0 0
5 0 1 0 1
6 0 1 1 0
7 0 1 1 1
8 1 0 0 0
9 1 0 0 1

Année 2003-2004 Initiation à l'architecture des ordinateurs 40


Données alphanumériques (1/2)

 Codes usuels :
 Baudot : 5 bits code télégraphique à 5 moments
 ASCII (American Standard Code for Information Interchange)
 standard : 7 bits
 étendu : 8 bits
 Codes basés sur le code ASCII
 Code ANSI (American National Standard Institute) utilisé par Windows
Utilisation d’un code page pour designer les extensions
 Norme Teletel Videotex
 EBCDIC (Extended Binary Coded Decimal Interchange Code) : 8 bits
similaire à ASCII, utilisé essentiellement par IBM.
 UNICODE (UNIversal CODE) ISO/IEC 10646
 UCS-2 (Universal Character Set 2) 16 bits
 UCS-4 (Universal Character Set 4) 32 bits

Année 2003-2004 Initiation à l'architecture des ordinateurs 41


Données alphanumériques (2/2)

Exemple : Code ASCII standard

Bits 7,6,5

000 001 010 011 100 101 110 111


Exemple : le code binaire correspondant à la lettre
0000 NUL DLE SP 0 @ P ‘ p
G majuscule est le suivant : 100 0111
0001 SOH DC1 ! 1 A Q a q
0010 STX DC2 «  2 B R b r
0011 ETX DC3 # 3 C S c s Code ASCII
0100 EOT DC4 $ 4 D T d t Caractère
0101 ENQ NAK % 5 E U e u alphanumérique Binaire Hexadécimale Décimale
Bits 0110 ACK SYN & 6 F V f v
4,3,2,1 0111 BEL ETB ‘ 7 G W g w G 100 0111 4 7 71
1000 BS CAN ( 8 H X h x
1001 HT EM ) 9 I Y i y
1010 LF SUB * : J Z j z
1011 VT ESC + ; K [ k {
1100 FF FS , < L \ l |
1101 CR GS - = M ] m }
1110 SO RS ./ > N ^ n ~
1111 SI US ? O _ o DEL

Année 2003-2004 Initiation à l'architecture des ordinateurs 42


Récapitulatif

Données

Non numériques Numériques

Tables de codage Nombres Nombres Nombres


entiers >0 entiers <0 fractionnaires
• BCD
• ASCII
• Conversion • Signe + valeur absolue • Virgule fixe
• EBCDIC directe en binaire
• Complément à 1 : C1 • Virgule flottante
• UniCode (Mantisse, base,
• Complément à 2 : C2
exposant)

Année 2003-2004 Initiation à l'architecture des ordinateurs 43


Plan du cours : 1ère Partie (3/3)
 Introduction

 1ère Partie : Concepts de base


• Structure générale de l’ordinateur
• Représentation interne des données
• Éléments de logique
 2ème Partie : Traitement des données : les processeurs
 3ème Partie : Stockage des informations : les mémoires
 4ème Partie : Transfert des informations : les bus
 Conclusion

Année 2003-2004 Initiation à l'architecture des ordinateurs 44


Logique combinatoire

 La logique combinatoire ne fait pas intervenir la notion de temps :


 elle traite des circuits combinatoires où les délais de propagation ne sont pas pris en
considération;
 les signaux de sortie ne dépendent que des signaux d’entrée;
 elle ne fait pas intervenir la notion de mémoire.

 La fonction logique d’un circuit combinatoire est définie par sa table de vérité,
vérité c’est à dire
le tableau de correspondance entre les états des variables d’entrée et l’état des variables
de sortie.
La table de vérité d’une fonction de n variables a autant de ligne que de combinaisons
possibles d’états d’entrée, pour une combinaison donnée la sortie prenant soit la valeur 0
soit la valeur 1.

 George Boole a défini une algèbre qui s’applique a ce type de logique. Il a montré que
toute fonction logique peut être réalisée grâce à un petit nombre de fonctions logiques
élémentaires appelées opérateurs logiques ou portes logiques (gates en anglais)

Année 2003-2004 Initiation à l'architecture des ordinateurs 45


Fonction d’une variable

a F s S = F (a)

Entrées: a
Sortie: s Fonctions réalisées
0 1
0 0 F0  0 Constante Nulle
0 1 F1  a Identité
1 0 F2  a Fonction NON (Not)
1 1 F3  1 Constante 1

Année 2003-2004 Initiation à l'architecture des ordinateurs 46


Fonctions logiques : Identité

Table de vérité
S=a
a S
Représentations
0 0
1 1
a S
Fonctionnement : Interrupteur
a = 0  Interrupteur ouvert
a = 1  Interrupteur fermé

S = 0  Lampe éteinte a 1 S
S = 1  Lampe allumée a
S
Lampe

Année 2003-2004 Initiation à l'architecture des ordinateurs 47


Fonctions logiques : Non (Not)

Table de vérité Représentations

S=ā a S
S = Non a 0 1 a S
S = Not a 1 0

a 1 S

Année 2003-2004 Initiation à l'architecture des ordinateurs 48


Fonctions possibles de deux variables
Entrées: a b - Sortie: s
Fonctions réalisées
00 01 10 11
0 0 0 0 F0  0 Constante Nulle
0 0 0 1 F1  a b Fonction ET (AND)
0 0 1 0 F2  a b
0 0 1 1 F3  a
0 1 0 0 F4  a b
0 1 0 1 F5  b
0 1 1 0 F6  a  b Fonction OU exclusif (XOR)
0 1 1 1 F7  a  b Fonction OU (OR)
1 0 0 0 F8  a  b  a b Fonction Non-OU (NOR)
1 0 0 1 F9  a  b
1 0 1 0 F10  b
1 0 1 1 F11  a  b
1 1 0 0 F12  a
1 1 0 1 F13  a  b
1 1 1 0 F14  a b  a  b Fonction Non-ET (NAND)
1 1 1 F15  1 Constante 1
Année 2003-2004 Initiation à l'architecture des ordinateurs 49
Fonctions logiques : ET (AND)

Table de vérité Représentations

S=ab a b S
a
0 0 0 S
S=ab b
0 1 0
1 0 0 a
& S
1 1 1 b

Fonctionnement : 2 Interrupteurs en série

a b
S
Lampe

Année 2003-2004 Initiation à l'architecture des ordinateurs 50


Fonctions logiques : OU (OR)

Table de vérité Représentations

S=a+b a b S
a
0 0 0 S
S=ab b
0 1 1
1 0 1 a
1 S
1 1 1 b
Fonctionnement : 2 Interrupteurs en parallèle

b S
Lampe

Année 2003-2004 Initiation à l'architecture des ordinateurs 51


Théorèmes fondamentaux de l’algèbre de Boole
 Théorème des constantes a 0a a x00
a 11 a x1  a
 Idempotence a a  a a xa a
 Complémentation a  a 1 a xa 0
 Commutativité abba a xbbxa
 Distributivité a  (b c)  (a  b) (a  c)
a (b  c)  (a b)  (a c)
 Associativité a  (b  c)  (a  b)  c  a  b  c
a (b c)  (a b) c  a b c
 Théorèmes de Morgan abab a bab
 Autres relations a a a  (a b)  a
a  (a b)  a  b a (a  b)  a
(a  b) (a  b)  a

Année 2003-2004 Initiation à l'architecture des ordinateurs 52


Fonctions logiques : OU Exclusif (XOR) (1/2)

Table de vérité Représentations

S= ab a b S
a
0 0 0 S
b
0 1 1
1 0 1 a
=1 S
1 1 0 b

La fonction XOR peut s’exprimer en fonction des fonctions


NON, ET et OU selon la méthode dite des minterms ou la
méthode dite des maxterms (voir page suivante)

Année 2003-2004 Initiation à l'architecture des ordinateurs 53


Fonctions logiques : OU Exclusif (XOR) (2/2)

 Méthode des minterms (somme logique de produits logiques)


la fonction logique est exprimée comme la somme logique des
minterms correspondant à chaque sortie valant 1 dans la table
de vérité :
S  ab  abab
 Méthode des maxterms (produit logique de sommes logiques)
la fonction logique est exprimée comme le produit logique des
maxterms correspondant à chaque sortie valant 0 dans la table
de vérité :

S  a  b  (a  b) (a  b)

Année 2003-2004 Initiation à l'architecture des ordinateurs 54


Fonctions logiques : NON ET (NAND)

Table de vérité
Représentations
S=ab a b S
S=ab 0 0 1 a
S
0 1 1
b
1 0 1
1 1 0
a
& S
b

Cet opérateur est dit « complet » car il permet de réaliser toutes les
autres fonctions.

Année 2003-2004 Initiation à l'architecture des ordinateurs 55


Fonctions logiques : NON OU (NOR)

Table de vérité Représentations

a b S
S=a+b a
0 0 1 S
S=ab b
0 1 0
1 0 0
a
1 1 0 1 S
b

Cet opérateur est dit « complet » car il permet de réaliser toutes les
autres fonctions.

Année 2003-2004 Initiation à l'architecture des ordinateurs 56


Opérateurs complets
Réalisations des fonctions de base (NON, ET, OU) à partir des opérateurs complets :

a a a a
1 0

a ab a a+b
b ab b a+b
1 0

a a
a a
1 0
a+b ab
b b b
b
1 0

Utilisation de NON ET Utilisation de NON OU

Année 2003-2004 Initiation à l'architecture des ordinateurs 57


Tables de Karnaugh (1/3)

abz
Soit une fonction définie par la table de vérité suivante :
0 0 0
Sa forme canonique est :
0 1 1
z(a, b)  a b  a b  a b
1 0 1
La table de Karnaugh 1 1 1
correspond à une
représentation de la table
de vérité qui permet de a
regrouper visuellement les a
mintermes de la fonction 0 1
pour la simplifier: b
Z(a,b) = a + b 0 1
Chaque case contient un minterme

b 1 1 1

Année 2003-2004 Initiation à l'architecture des ordinateurs 58


Tables de Karnaugh (2/3)

Forme canonique : z(a, b, c)  a b c  a b c  a b c  a b c

c
ac a
00 01 11 10 Exemple avec
b
3 variables
0 1

b 1 1 1 1

Forme simplifiée : z(a, b, c)  a c  b c

Année 2003-2004 Initiation à l'architecture des ordinateurs 59


Tables de Karnaugh (3/3)

Forme canonique : z(a, b, c)  a b c d  a b c d  a b c d  a b c d  a b c d  a b c d


a bcd a bcd a bcd a bcd a bcd

b
ab a
00 01 11 10
cd
Exemple avec
00 1 1 1 4 variables

01 1 1
d
11 1 1 1
c
10 1 1 1

Forme simplifiée : z(a, b, c)  b  a d  a c d


Année 2003-2004 Initiation à l'architecture des ordinateurs 60
Additionneur binaire (1/2)

Le demi-additionneur permet d’additionner 2 bits. Il calcule la somme et la


retenue, mais il ne tient pas compte de la retenue éventuelle provenant de
l’addition des bits de poids précédents.

S  ab  ab  ab
Table de vérité
R  ab
a
a b S R S
b
0 0 0 0
0 1 1 0
1 0 1 0 R
1 1 0 1
S = Somme a S
R = Retenue ½ ADD
b R

Année 2003-2004 Initiation à l'architecture des ordinateurs 61


Additionneur binaire (2/2)

Étage n d’un additionneur :

Retenue précédente
Rn-1 Sn
½ ADD
an Retenue propagée
½ ADD Rn
bn
Retenue générée

L’additionneur complet sera constitué d’autant d’étages en parallèle


que de bits constituant les nombres à additionner. En entrée les bits
de poids n des 2 opérandes seront connectés en an et bn, et la
retenue de l’étage précédent en Rn-1.

Année 2003-2004 Initiation à l'architecture des ordinateurs 62


Logique séquentielle

 A la différence des circuits combinatoires idéaux les circuits séquentiels tiennent


compte de la notion de temps. L’état des sorties dépend :
 des entrées,
 du séquencement des entrées,
 des sorties (contre-réaction), c’est à dire de l’état actuel des circuits
avant que les entrées ne soient modifiées,
 de l’état d’éléments « mémoire  »

 Deux types de logique séquentielle :


 Logique séquentielle asynchrone
 Logique séquentielle synchrone

 L’étude des circuits séquentiels repose sur la théorie des automates finis
(Finite state machines).

Année 2003-2004 Initiation à l'architecture des ordinateurs 63


Automates finis (1/2)

 Automate de Moore

E
Logique Etat de Logique
S
combinatoire l’Automate Q combinatoire

S (t+1) = f [ Q (t+1) ]
Q (t+1) = g [ E (t) , Q (t) ]

Année 2003-2004 Initiation à l'architecture des ordinateurs 64


Automates finis (2/2)

 Automate de Mealy

E S
Logique
combinatoire
Etat de
l’Automate Q

S (t+1) = f [ E (t) , Q (t) ]


Q (t+1) = f [ E (t) , Q (t) ]

Année 2003-2004 Initiation à l'architecture des ordinateurs 65


Bascules
 Les bascules (ou bistables) ont deux états stables :
elles peuvent donc mémoriser 1 bit ( un état correspond à 0 et l’autre à 1).

1 0 0 1

0 1 1 0

État n°0 État n°1

Année 2003-2004 Initiation à l'architecture des ordinateurs 66


Bascule R-S (Reset-Set) (1/4)

R Q
R S Q Q+
0 0 0 0 Q+ = Q
0 0 1 1 Q+ = Q
R S Q+
0 1 0 1 Set
0 0 Q
0 1 1 1 Set
Q 0 1 1
S 1 0 0 0 Reset
1 0 1 0 Reset
1 0 0
1 1 0 0 1 1 0
0
R Q 0 0 X Indéterminé 0 0 X
1 1 0 0
1
0 0 X Indéterminé

S Q

Année 2003-2004 Initiation à l'architecture des ordinateurs 67


Bascule R-S (Reset-Set) (2/4)

Principe de fonctionnement :
Au repos : S = R = 0 : la bascule mémorise l’information :
elle est alors soit dans l’état 0 : Q = 0 et Q = 1
soit dans l’état 1 : Q = 1 et Q = 0
Lorsque S est activée (S = 1, R restant à 0)
la bascule passe dans l ‘état 1 : Q = 1 et Q = 0
ou y reste si elle y était déjà.
Lorsque R est activée (R = 1, S restant à 0) :
la bascule passe dans l ‘état 1 : Q = 1 et Q = 0
ou y reste si elle y était déjà.
Si R et S sont tous les deux activés (entraînant Q = Q = 0), et qu’on les désactive
«simultanément» alors la bascule a autant de chance de prendre l’état 0 que l’état 1,
ce que l’on traduit par l’état «indéterminé» X. Cette combinaison est normalement
interdite.

Année 2003-2004 Initiation à l'architecture des ordinateurs 68


Bascule R-S (Reset-Set) (3/4)

La bascule R-S peut aussi être implémentée en utilisant des portes NAND de la façon
suivante :

S
S
Q
Ce schéma permet de comprendre
plus facilement celui de la page
suivante correspondant à la bascule
R-S Synchrone où S et R sont
contrôlés par l’horloge.
Q
R
R

Année 2003-2004 Initiation à l'architecture des ordinateurs 69


Bascule R-S synchrone (4/4)
Les entées R et S de la bascule ne sont prises en compte que lorsque l’horloge C
est active :

S Q
R S C Q+
0 0 0 Q
0 1 0 Q
C
1 0 0 Q
1 1 0 Q
0 0 1 Q
Q Valeurs prises
R 0 1 1 1
par Q quand C
1 0 1 0 passe de 1 à O.
S Q 1 1 1 X

C L’état de la bascule est mémorisée lorsque


le signal d’horloge passe de 1à 0, et ce
R Q jusqu’à ce que signal redevienne actif (1).

Année 2003-2004 Initiation à l'architecture des ordinateurs 70


Bascule J-K
La bascule J-K permet de résoudre le problème de
l’indétermination sur l’état de la bascule R-S en Jn Kn Qn Qn S R Q n+1
interdisant la combinaison R = S = 1.
0 0 0 1 0 0 0
0 0 1 0 0 0 1
0 1 0 1 0 0 0
0 1 1 0 0 1 0
J S Q Q
1 0 0 1 1 0 1
1 0 1 0 0 0 1
1 1 0 1 1 0 1
K R Q Q 1 1 1 0 0 1 0

Jn Kn Q n+1
0 0 Qn
Toutefois lorsque J=K=1 la bascule oscille 0 1 0
alternativement entre les états 0 et 1. 1 0 1
1 1 Qn
Année 2003-2004 Initiation à l'architecture des ordinateurs 71
Bascule J-K synchrone
Lorsque l’horloge C est active (1) le comportement est celui de la bascule J-K
asynchrone.
Lorsque l’horloge C devient inactive (passe de 1 à 0) l’état de la bascule est
mémorisé jusqu’à ce que l’horloge redevienne active.

R Q Q
K
C C
J S Q Q

Année 2003-2004 Initiation à l'architecture des ordinateurs 72


Bascule D
La donnée D est copiée dans la bascule lorsque l’horloge passe de 1 à 0.
Elle y est mémorisée jusqu’à ce que l’horloge redevienne active.

D S Q Q D Q

C C

R Q Q C Q

Année 2003-2004 Initiation à l'architecture des ordinateurs 73


Registre de mémorisation
Registre composé de 4 bascules D : la commande W (Write) autorise l’écriture des
signaux d’entrée En, et la commande R (Read) transfère le contenu des bascules
vers les sorties Sn.

E0 E1 E2 E3

D Q D Q D Q D Q

C Q C Q C Q C Q
W
R

S0 S1 S2 S3

Année 2003-2004 Initiation à l'architecture des ordinateurs 74