AdO - 2 - Concepts

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

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

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)

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

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

 Introduction

• Eléments de logique
 Conclusion

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]

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

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

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

• Entiers positifs
• Entiers négatifs
• Nombres fractionnaires
 Conclusion

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


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

 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

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

Conversion: Décimal => Hexadécimal
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

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

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)

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

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)

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

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

 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

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

• Eléments de logique
 Conclusion

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

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

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

Soustraction avec le complément restreint (2/2)
28 +00011100
- 63 10
00111111 11000000
10
- 3510 11011100 ( -3510 en complément

restreint)

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

à 2 du nombre à soustraire.
6310 00111111
-
2810 00011100
+
+ 11100011
1
11100100 11100100
3510 00100011

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

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

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

 Conclusion

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

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

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.

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

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

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

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

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.

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

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

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

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)

 Introduction

• Éléments de logique
 Conclusion

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)

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

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

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

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
Fonctions logiques : ET (AND)
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

Fonctions logiques : OU (OR)
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

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

Fonctions logiques : OU Exclusif (XOR) (1/2)
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)

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)

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.

Fonctions logiques : NON OU (NOR)
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.

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

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

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

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

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

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.

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

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

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

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

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

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.

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

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

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

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

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

AdO - 2 - Concepts

Transféré par

Informations du document

Titre original

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

AdO - 2 - Concepts

Transféré par

Droits d'auteur :

Formats disponibles

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

 1ère Partie : Concepts de base

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

Résultat des Instructions et Données

Unité de Calcul Unité de

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

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

A+B Registres de sortie de L’UAL

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

Code Opération Opérandes

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

1. Charger la prochaine instruction à exécuter :

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

1. Charger la prochaine instruction à exécuter :

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

3. Modifier le compteur ordinal pour qu’il pointe

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

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

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

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

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

 1ère Partie : Concepts de base

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

 Représentation usuelle des nombres

 Représentation des nombres en informatique :

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

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

24 16 10 210 1 024 400

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

 1ère Partie : Concepts de base

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

 Restes successifs de la division par 2

Arrêt lorsque le quotient est nul

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

 Restes successifs de la division par 2

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

 Division par les puissances de 2

128 < 173 <256 17310 => 101011012

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

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

101011012 => 17310

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

1577510 => 3D9F16

Arrêt lorsque le quotient est nul

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

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

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

Bit de poids le plus faible

Binaire 1101 1100 1111 0111 1011 0010 1010 1110

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

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

Binaire 0011 1111 1011 0000 1110 1100 1001

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

Retenue (Dépassement de capacité)

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

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

1011 Opérande 1 (4 chiffres)

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

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

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

 1ère Partie : Concepts de base

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

 Nombres entiers signés