Année 2003-2004Initiation à l'architecture des ordinateurs1 Plan du cours : 1 ère Partie (1/3)...

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

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

Introduction

11èreère Partie : Concepts de base Partie : Concepts de base• Structure générale de l’ordinateurStructure 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


Machine de Von Neumann (1/4)

Unité de Calcul Arithmétique et Logique

(U A L)

Unité deContrôle

(U C)

Mémoire

Instructions et DonnéesRésultat des Opérations

Périphériques

(Clavier,Terminal, Imprimante, etc...)


A + B

A + B

A

B

A B

Registres de travail

Registres d’entrée de L’UAL

Registres de sortie de L’UAL

U A L

Chemin des données (2/4)


Structure d’une instruction (3/4)

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)

OpérandesCode Opération


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

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

de Paolo Zanelle et Yves Ligier chez Dunod

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.



Introduction

11èreère Partie : Concepts de base Partie : Concepts de base• Structure générale de l’ordinateur• Représentation interne des donnéesReprésentation interne des données• Eléments de logique



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

décimal

Octal

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

24 16 10

25 32 20

26 64 40

27 128 80

28 256 100

29 512 200

210 1024 400

211 2048 800

212 4096 1000

2n Décimal Hexadécimal

210 1 024 400

220 1 048 576 100 000

230 1 073 741 824 40 000 000

240 1 099 511 627 776 10 000 000 000


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

Introduction

11èreère Partie : Concepts de base Partie : Concepts de base• Structure générale de l’ordinateur• Représentation interne des donnéesReprésentation interne des données

• Entiers positifsEntiers positifs• Entiers négatifs• Nombres fractionnaires



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

Restes successifs de la division par 2

173 / 2 = 86 reste 1

86 / 2 = 43 reste 0

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

17310 => 101011012

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

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

17310 => 101011012


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

Addition des puissances de 2 correspondant aux bits de valeur 1

101011012 => 17310

1 x 20 = 1

0 x 21 = 0

1 x 22 = 4

1 x 23 = 8

0 x 24 = 0

1 x 25 = 32

0 x 26 = 0

1 x 27 = 128

173

+

+

+

+

+

+

+

1 0 1 0 1 1 0 1x x x x x x x x27 26 25 24 23 22 21 20

(128) (64) (32) (16) (8) (4) (2) (1)

128 0 32 0 8 4 0 1 + + + + + + + 173


Conversion: Décimal => Hexadécimal


15775 / 16 = 985 reste 15 F

985 / 16 = 61 reste 9 9

61 / 16 = 3 reste 13 D

3 / 16 = 0 reste 3 3

1577510 => 3D9F16

Arrêt lorsque le quotient est nul


Conversion: Hexadécimal => Décimal

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

E5B716 => 5880710

On multiplie les chiffres hexadécimaux par les puissances de 16 correspondantes :

Exemple:


Conversion: Binaire => Hexadécimal

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)

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 faibleLSB (Less significant Bit)

Exemple :


Conversion: Hexadécimal => Binaire

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

Hexadécimal 3 F B 0 E C 9

(3) (15) (11) (0) (14) (12) (9)

Binaire 0011 1111 1011 0000 1110 1100 1001

Exemple :


Arithmétique binaire (1/4)

Addition

A B ADD Retenue

0 0 0 0

0 1 1 0

1 0 1 0

1 1 0 1

1 1 1 1

1 0 1 1 0 1 Opérande 1

1 1 0 1 0 1 Opérande 2

1 1 0 0 0 1 0 Résultat

+

Retenue (Dépassement de capacité) (Overflow)

Retenues intermédiaires

Table de vérité



Soustraction

A B A-B Retenue

0 0 0 0

0 1 1 1

1 0 1 0

1 1 0 0

Table de vérité

1 1 0 1 1 0 0 1 Opérande 1

1 0 1 0 1 1 1 0 Opérande 2

1 1 1 1

0 0 1 0 1 0 1 1 Résultat




Multiplication

A B A x B

0 0 0

0 1 0

1 0 0

1 1 1

Table de vérité

1 0 1 1 Opérande 1 (4 chiffres)

1 1 0 1 Opérande 2 (4 chiffres)

1 0 1 1 1 0 1 1 . . 1 0 1 1 . 1 1 1

1 0 0 0 1 1 1 1 Résultat (8 chiffres)

x




Division entière

1 0 1 0 1 0

1 1 0 1 0 1 1 0 1 0 11 0 1 0 0 1 1 0 1 0 1 0 0 1 1 1 1 0 1 0 1 0 0

Dividende : 1 1 0 1 0 1 1 0

Diviseur : 1 0 1

Quotient : 1 0 1 0 1 0

Reste : 1 0 0


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

Introduction


• Entiers positifs• Entiers négatifsEntiers négatifs• Nombres fractionnaires

• Eléments de logique



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)

6310 0 0 1 1 1 1 1 1

2810 0 0 0 1 1 1 0 0 1 1 1 0 0 0 1 1

1 0 0 1 0 0 0 1 0 1

3510 0 0 1 0 0 0 1 1

- +

La soustraction est obtenue par l’addition du complément restreint du nombre à soustraire.

Exemple : Soustraire 2810 de 6310

En cas de retenue, celle-ci doit être ajoutée pour obtenir le résultat final.


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


2810 0 0 0 1 1 1 0 0 6310 0 0 1 1 1 1 1 1 1 1 0 0 0 0 0 0

- 3510 1 1 0 1 1 1 0 0 ( -3510 en complément

restreint)

- +


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

La soustraction est obtenue par l’addition du complément à 2 du nombre à soustraire.


6310 0 0 1 1 1 1 1 1

2810 0 0 0 1 1 1 0 0

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

3510 0 0 1 0 0 0 1 1

-

+

+


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

La soustraction est obtenue par l’addition du complément à 2 du nombre à soustraire.


2810 0 0 0 1 1 1 0 0

6310 0 0 1 1 1 1 1 1

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

- 3510 1 1 0 1 1 1 0 1

-

++

( -35 représenté en complément à 2 )


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

Introduction


• Entiers positifs• Entiers négatifs• Nombres fractionnairesNombres fractionnaires



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,64062510 => 0,1010012

Arrêt lorsque la partie décimale est nulle

0,640625 x 2 = 1, 28125

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


Conversion: Binaire => Décimal

Addition des puissances de 2 correspondant aux bits de valeur 1

0,1010012 => 0,64062510

1 x 2-1 = 0,5

0 x 2-2 = 0

1 x 2-3 = 0,125

0 x 2-4 = 0

0 x 2-5 = 0

1 x 2-6 = 0,015625

0,640625

+

+

+

+

+

1 0 1 0 0 1x x x x x x

2-1 2-2 2-3 2-4 2-5 2-6

(0,5) (0,25) (0,125) (0,0625) (0,03125) (0,015625)

0,5 0 0,125 0 0 0,015625 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) :

• Norme IEEE

• Norme IBM

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

S 26 20 2-1 2 -24

Signe Exposant décalé (Base 16) Mantisse

Bit Bit

31 30 29 …………..……….24 23 22 21 …………………………………….. 1 0

S 27 20 2-1 2-23

Signe Exposant décalé (Base 2) Mantisse



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

précision (utilisant la base 16).

7510 => 4B16

0,7510 => 0,C16

Il faut ajouter 27 / 2 pour décaler l’exposant (soit 6410 ou 4016) ce qui

donne : 216 + 4016 => 4216

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

2

Bit Bit

31 30 29 ………….. 25 2423 22 …..………………………………..…...….. ………..1 0

0 1 0 0 0 0 1 0 0100 1011 1100 0000 0000 00000 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.


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 :

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

ChiffreDécimal

23 22 21 20

8 4 2 1

0 0 0 0 0

1 0 0 0 1

2 0 0 1 0

3 0 0 1 1

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

Exemple de conversions :

Décimal Binaire BCD

173 10101101 0001 0111 0011


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)

000 001 010 011 100 101 110 111

0000 NUL DLE SP 0 @ P ‘ p

0001 SOH DC1 ! 1 A Q a q

0010 STX DC2 « 2 B R b r

0011 ETX DC3 # 3 C S c s

0100 EOT DC4 $ 4 D T d t

0101 ENQ NAK % 5 E U e u

0110 ACK SYN & 6 F V f v

0111 BEL ETB ‘ 7 G W g w

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

Bits 7,6,5

Bits4,3,2,1

Exemple : Code ASCII standard

Exemple : le code binaire correspondant à la lettre

G majuscule est le suivant : 100 0111

Caractère

alphanumérique

Code ASCII

Binaire Hexadécimale Décimale

G 100 0111 4 7 71


Récapitulatif

Données

Non numériques Numériques

Tables de codage

• BCD

• ASCII

• EBCDIC

• UniCode

Nombres entiers >0

Nombres entiers <0

Nombres fractionnaires

• Conversion directe en binaire

• Signe + valeur absolue

• Complément à 1 : C1

• Complément à 2 : C2

• Virgule fixe

• Virgule flottante (Mantisse, base, exposant)



Introduction

11èreère Partie : Concepts de base Partie : Concepts de base• Structure générale de l’ordinateur• Représentation interne des données• Éléments de logiqueÉléments de logique



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 logiquefonction logique d’un circuit combinatoire est définie par sa table de véritétable de 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 BooleGeorge 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 logiquesopérateurs logiques ou portes logiquesportes logiques (gatesgates en anglais)


Fonction d’une variable

Entrées: a Sortie: s Fonctions réalisées

0 1

0 0 Constante Nulle

0 1 Identité

1 0 Fonction NON (Not)

1 1 Constante 11 F3a F2a F10 F0

Fa s S = F (a)


Fonctions logiques : Identité

Représentations

Table de vérité

a S

0 0

1 1

Fonctionnement : Interrupteur

a = 0 Interrupteur ouvert a = 1 Interrupteur fermé

S = 0 Lampe éteinteS = 1 Lampe allumée

S = a

aS

Lampe

Sa

1 Sa


Fonctions logiques : Non (Not)

1

ReprésentationsTable de vérité

a S

0 1

1 0

S = ā

S = Non a

S = Not a

S

S

a

a


Fonctions possibles de deux variables

Entrées: a b - Sortie: s Fonctions réalisées

0 0 0 1 1 0 1 1

0 0 0 0 Constante Nulle

0 0 0 1 Fonction ET (AND)0 0 1 00 0 1 10 1 0 00 1 0 10 1 1 0 Fonction OU exclusif (XOR)0 1 1 1 Fonction OU (OR)1 0 0 0 Fonction Non-OU (NOR)1 0 0 11 0 1 01 0 1 11 1 0 01 1 0 11 1 1 0 Fonction Non-ET (NAND)

1 1 1 Constante 1

b a F7b a F6

b F5b a F4

a F3b a F2

b a F10 F0

b a b a F8 b a F9

b a F13a F12

b a F11

b F10

b a b a F14 1 F15


Fonctions logiques : ET (AND)

S = a b

S = a b

Table de vérité

a b S

0 0 0

0 1 0

1 0 0

1 1 1

Représentations

&

Fonctionnement : 2 Interrupteurs en série

aS

Lampe

b

ab

ab

S

S


Fonctions logiques : OU (OR)

S = a + b

S = a b

Table de vérité

a b S

0 0 0

0 1 1

1 0 1

1 1 1

Représentations

Fonctionnement : 2 Interrupteurs en parallèle

ab

ab

S

S1

a

SLampe

b


Théorèmes fondamentaux de l’algèbre de Boole

Théorème des constantes

Idempotence Complémentation Commutativité Distributivité

Associativité

Théorèmes de Morgan Autres relations

a )b (a b) (a

a b) (a a b a b) a( a

a b) (a a a a

b a b a b a b a

c b a c b) (a c) (b ac b a c b) (a c) (b a

c) (a b) (a c) (b ac) (a b) (a c) (b a

a x b b x a a b b a0 a x a 1 a a

a a x a a a aa 1 x a 1 1 a0 0 x a a0 a


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

S = a b

Table de vérité

a b S

0 0 0

0 1 1

1 0 1

1 1 0

Représentations

ab

ab

S

S

=1

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)


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

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

b a b a b a S

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

)b a( b) (a ba S


Fonctions logiques : NON ET (NAND)

S = a b

S = a b

Table de vérité

a b S

0 0 1

0 1 1

1 0 1

1 1 0

Représentations

ab

S

ab S&

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


Fonctions logiques : NON OU (NOR)

S = a + b

S = a b

Table de vérité

a b S

0 0 1

0 1 0

1 0 0

1 1 0

Représentations

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

ab

S

ab S1


Opérateurs complets

a

a

a

a

aa

aa

a a

b b

bb

b b

1

1

1

1

0

0

0

ab

ab

aba+b

a+b

a+b

0

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

Utilisation de NON ET Utilisation de NON OU


Tables de Karnaugh (1/3)

a b z0 0 0

0 1 1

1 0 1

1 1 1

Soit une fonction définie par la table de vérité suivante :

Sa forme canonique est :

b a b a b a b)z(a,

La table de Karnaugh correspond à une représentation de la table de vérité qui permet de regrouper visuellement les mintermes de la fonction pour la simplifier:

Z(a,b) = a + b

0 1

0 1

1 1 1

aaa

b

b

Chaque case contient un minterme



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

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

1111

10

10110100

a c a

c

b

b Exemple avec 3 variables



d c b a d c b a d c b a d c b a d c b a

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

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

11110

11111

1101

11100

10110100a b a

b

c d

d

c

Exemple avec 4 variables


Additionneur binaire (1/2)

Table de vérité

a b S R

0 0 0 00 1 1 01 0 1 0

1 1 0 1

S = SommeR = Retenue

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.

b a R

b a b a b a S

a

bS

R

½ ADDb

a

R

S


Additionneur binaire (2/2)

Retenue propagée

½ ADD

½ ADD

Retenue précédente

Rn-1

Rn

Sn

an

bn Retenue générée

Étage n d’un additionneur :

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


Etat de l’Automate Q


SE

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

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


Automates finis (2/2)

Automate de Mealy


Etat de l’Automate Q

SE

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

1

0

0

État n°1

0

0

1

1

État n°0


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

R S Q Q+

0 0 0 0 Q+ = Q

0 0 1 1 Q+ = Q

0 1 0 1 Set

0 1 1 1 Set

1 0 0 0 Reset

1 0 1 0 Reset

1

0

1

00

0

X

0

Indéterminé 1

0

1

01

0

X

0

Indéterminé

R S Q+

0 0 Q

0 1 1

1 0 0

1

0

1

0

0

X

S

Q

Q

R

Q

Q

S

R



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 :


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.

S

R

Q

Q

R

S


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 :

R S C Q+

0 0 0 Q

0 1 0 Q

1 0 0 Q

1 1 0 Q

0 0 1 Q

0 1 1 1

1 0 1 0

1 1 1 X

R

Q

Q

S

C

Valeurs prises par Q quand C passe de 1 à O.

R

Q

Q

S

C

L’état de la bascule est mémorisée lorsque le signal d’horloge passe de 1à 0, et ce 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 interdisant la combinaison R = S = 1.

J

R

Q

Q

S

K

Q

Q

Jn Kn Qn Qn S R Q n+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

1 0 0 1 1 0 1

1 0 1 0 0 0 1

1 1 0 1 1 0 1

1 1 1 0 0 1 0

Jn Kn Q n+1

0 0 Qn

0 1 0

1 0 1

1 1 Qn

Toutefois lorsque J=K=1 la bascule oscille alternativement entre les états 0 et 1.


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.

S

Q

Q

R

C

K

J

C

Q

Q


Bascule D

R

Q

Q

S

C

D

C

Q

Q

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.

C

Q

Q

D


Registre de mémorisation

C

Q

Q

D

C

Q

Q

D

C

Q

Q

D

C

Q

Q

D

S0 S1 S2 S3

E0 E1 E2 E3

RW

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.

Année 2003-2004Initiation à l'architecture des ordinateurs1 Plan du cours : 1 ère Partie (1/3)...

Documents

Transcript of Année 2003-2004Initiation à l'architecture des ordinateurs1 Plan du cours : 1 ère Partie (1/3)...