Accueil > Architecture matérielle > Chapitre 1
Un ordinateur est une machine de traitement de l'information.
Il est normalement capable d'acquérir et de conserver des informations, d'effectuer des traitements et de restituer le résultat.
Quelque soit la nature de l'information, l'ordinateur doit être capable de les traiter.
Il faut donc qu'elle soit sous une forme que la machine peut compendre.
Un ordinateur n'utilise que des informations sous forme numérique.
Comme il est constitué d'éléments électronique et électriques, il ne connait que 2 états:
- le courant passe
- le courant ne passe pas
C'est donc le système binaire qui sera utilisé par l'ordinateur.
Le système binaire ou base 2 est composé d'un alphabet à 2 caractères {0,1}.
Sa simplicité est très grand avantage. Le caractère élémentaire s'appelle le bit.
Soit A = (an, an-1, ...,a1, a2)b un nombre écrit en base b.
On obtient la valeur de A dans la base 10 grâce à sa notation en numération pondérée
A sera la somme de ses facteurs multipliés par un poids variant selon leur position:
A = anbn + an-1bn-1 + a2b2 + a1b1 + a0b0
Exemple:
(149)10 = 1 x 100 + 4 x 10 + 9 x 1
(149)10 = 1 x 102 + 4 x 101 + 9 x 101
Exercice #1:
(10011)2 = (?)10
(10011)2 = 1 x 24 + 0 x 23 + 0 x 22 + 1 x 21 + 1 x 20
(10011)2 = 16 + 0 + 2 + 1
(10011)2 = (19)10
Exercice #2:
(24)3 = (?)10
(24)3 = 2 x 31 + 2 x 30
(24)3 = 6 + 2
(24)3 = (8)10
Exercice #3:
(11001)2 = (?)10
(11001)2 = 1 x 24 + 1 x 23 + 0 x 22 + 0 x 21 + 1 x 20
(11001)2 = 16 + 8 + 0 + 0 + 1
(11001)2 = (25)10
Exercice #4:
(111)2 = (?)10
(111)2 = 1 x 22 + 1 x 21 + 1 x 20
(111)2 = 4 + 2 + 1
(111)2 = (7)10
Exercice #5:
(1010)2 = (?)10
(1010)2 = 1 x 23 + 0 x 22 + 1 x 21 + 0 x 20
(1010)2 = 8 + 0 + 2 + 0
(1010)2 = (10)10
NB : Un nombre binaire se terminant par un :
- 0 est paire
- 1 est impaire
Pour les nombres à virgule, on utilise le même procédé mais les exposants seront négatifs après la virgule.
Si A = (an, a0, a-1 ,a-2)b
Alors A = (anbn + a0b0 + a-1b-1 + a-2b-2 + ... + a-nb-n)b
Exemple:
A = (10111,101)2 = 24 + 03 + 22 + 21 + 20 + 2-1 + 2-2 + 2-3
A = (10111,101)2 = 16 + 0 + 4 + 2 + 1 + 0,5 + 0 + 0,125
A = (10111,101)2 = (23,625)10
Le but de la transformation est de trouver les caractères an à a0 dans la base b.
On cherche la plus grande puissance de b contenue dans le nombre à convertir.
- le résultat est le caractère recherché
- le reste devient le nombre à convertir
- s'il n'est pas nul, on répete l'opération sinon c'est terminé.
Exemple:
- (85)10 en binaire
85 | = | 1 | x | 64 | + | 21 |
85 | = | 1 | x | 26 | + | 21 |
21 | = | 1 | x | 16 | + | 5 |
21 | = | 1 | x | 24 | + | 5 |
5 | = | 1 | x | 4 | + | 1 |
5 | = | 1 | x | 22 | + | 1 |
1 | = | 1 | x | 1 | + | 0 |
1 | = | 1 | x | 20 | + | 0 |
85 = 1 x 26 + 0 x 25 + 1 x 24 + 0 x 23 + 1 x 22 + 0 x 21 + 1 x 20
85 = (1010101)2
Pour vérifier si le résultat est bon, il suffit d'additionner les éléments en bleu le nombre décimal
Exercice #6:
(49)10 = (?)2
49 | = | 32 | + | 17 |
49 | = | 25 | + | 17 |
17 | = | 16 | + | 1 |
17 | = | 24 | + | 1 |
1 | = | 1 | + | 0 |
1 | = | 20 | + | 0 |
(49)10 = (110001)2
Exercice #7:
(111)10 = (?)2
111 | = | 64 | + | 47 |
111 | = | 26 | + | 47 |
47 | = | 32 | + | 15 |
47 | = | 25 | + | 15 |
15 | = | 8 | + | 3 |
15 | = | 24 | + | 3 |
3 | = | 2 | + | 1 |
3 | = | 21 | + | 1 |
1 | = | 1 | + | 0 |
1 | = | 20 | + | 0 |
(111)10 = (1100011)2
Exercice #8:
(28)10 = (?)2
28 | = | 16 | + | 12 |
28 | = | 24 | + | 12 |
12 | = | 8 | + | 4 |
12 | = | 23 | + | 4 |
4 | = | 4 | + | 0 |
4 | = | 22 | + | 0 |
(28)10 = (11100)2
Exercice #9:
(11011)2 = (?)10
(110111)2 = 1 x 25 + 1 x 24 + 0 x 23 + 1 x 22 + 1 x 21 + 1 x 20
(110111)2 = 32 + 16 + 0+ 0 + 4 + 2 + 1
(110111)2 = (55)10
Vérification :
55 | = | 25 | + | 23 |
55 | = | 32 | + | 23 |
23 | = | 24 | + | 7 |
23 | = | 16 | + | 7 |
7 | = | 22 | + | 3 |
7 | = | 4 | + | 3 |
3 | = | 21 | + | 1 |
3 | = | 2 | + | 1 |
1 | = | 20 | + | 0 |
1 | = | 1 | + | 0 |
(55)10 = (110111)2
Exercice #10:
(1101)2 = (?)10
(1101)2 = 1 x 23 + 1 x 22 + 0 x 21 + 1 x 20
(1101)2 = 8 + 4 + 0 + 1
(1101)2 = (13)10
Vérification :
13 | = | 23 | + | 5 |
55 | = | 8 | + | 5 |
5 | = | 22 | + | 1 |
5 | = | 4 | + | 1 |
1 | = | 20 | + | 0 |
1 | = | 1 | + | 0 |
(13)10 = (1101)2
Exercice #11:
(1100010)2 = (?)10
(1100010)2 = 1 x 26+ 1 x 25 + 0 x 24 + 0 x 23 + 0 x 22 + 1 x 21 + 0 x 20
(1100010)2 = 64 + 32 + 0 + 0 + 0 + 0 + 2 + 0
(1100010)2 = (98)10
Vérification :
98 | = | 26 | + | 34 |
98 | = | 64 | + | 34 |
34 | = | 25 | + | 2 |
34 | = | 32 | + | 2 |
2 | = | 21 | + | 0 |
2 | = | 2 | + | 0 |
(13)10 = (1101)2
Exercice #12:
(101)10 = (?)2
101 | = | 26 | + | 37 |
101 | = | 64 | + | 37 |
37 | = | 25 | + | 5 |
37 | = | 32 | + | 5 |
5 | = | 22 | + | 1 |
5 | = | 4 | + | 1 |
1 | = | 20 | + | 0 |
1 | = | 1 | + | 0 |
(101)10 = (1100101)2
Vérification :
(1100101)2 = 1 x 26+ 1 x 25 + 0 x 24 + 1 x 23 + 0 x 22 + 0 x 21 + 1 x 20
(1100101)2 = 64 + 32 + 0 + 0 + 4 + 0 + 1
(1100101)2 = (101)10
Exercice #13:
(249)10 = (?)2
249 | = | 27 | + | 121 |
249 | = | 128 | + | 121 |
121 | = | 26 | + | 121 |
121 | = | 64 | + | 57 |
57 | = | 25 | + | 25 |
57 | = | 32 | + | 25 |
25 | = | 24 | + | 9 |
25 | = | 16 | + | 9 |
9 | = | 23 | + | 1 |
9 | = | 8 | + | 1 |
1 | = | 20 | + | 0 |
1 | = | 1 | + | 0 |
(249)10 = (11111001)2
Vérification :
(11111001)2 = 1 x 27 + 1 x 26+ 1 x 25 + 1 x 24 + 1 x 23 + 0 x 22 + 0 x 21 + 1 x 20
(11111001)2 = 128 + 64 + 32 + 16 + 8 + 0 + 0 + 1
(11111001)2 = (249)10
Exercice #14:
(78)10 = (?)2
78 | = | 26 | + | 14 |
78 | = | 64 | + | 14 |
14 | = | 23 | + | 6 |
14 | = | 8 | + | 6 |
6 | = | 22 | + | 2 |
6 | = | 4 | + | 2 |
2 | = | 21 | + | 0 |
2 | = | 2 | + | 0 |
(78)10 = (1001110)2
Vérification :
(1001110)2 = 1 x 26+ 0 x 25 + 0 x 24 + 1 x 23 + 0 x 22 + 1 x 21 + 0 x 20
(1001110)2 = 64 + 0 + 8 + 0 + 2 + 0
(1001110)2 = (78)10
Exercice #15:
(63)10 = (?)2
<
63 | = | 25 | + | 31 |
63 | = | 32 | + | 31 |
31 | = | 24 | + | 15 |
31 | = | 16 | + | 15 |
15 | = | 23 | + | 7 |
15 | = | 8 | + | 7 |
7 | = | 22 | + | 3 |
7 | = | 4 | + | 3 |
3 | = | 21 | + | 1 |
3 | = | 2 | + | 1 |
1 | = | 20 | + | 0 |
1 | = | 1 | + | 0 |
(63)10 = (111111)2
Vérification :
(111111)2 = 1 x 25 + 1 x 24 + 1 x 23 + 1 x 22 + 1 x 21 + 1 x 20
(111111)2 = 64 + 32 + 8 + 4 + 2 + 1
(111111)2 = (63)10
Un nombre A peut s'écrire : A = anbn + ... + a1b1 + a0b0
Si on effectue la divisio entière de A par b on a :
Image division
On obtient donc à chaque étape un digit. On réitère le procédé jusqu'à obtenir un résultat nul.
Exemple : (37)10 = (?)2
37 | | | 2 | ||||||||||
1 | 18 | | | 2 | |||||||||
0 | 9 | | | 2 | |||||||||
1 | 4 | | | 2 | |||||||||
0 | 2 | | | 2 | |||||||||
0 | 1 | | | 2 | |||||||||
1 | 0 |
Il faut lire les restes de cette division de BAS en HAUT, ce qui donne :
(37)10 = (100101)2
Il y a 3 bases à utiliser :
Cette dernière utilise un alphabet de 16 caractères :
Héxadécimal | A | B | C | D | E | F |
Décimal | 10 | 11 | 12 | 13 | 14 | 15 |
Binaire | 1010 | 1011 | 1100 | 1101 | 1110 | 1111 |
Explications :
A = (10)10
10 | = | 23 | + | 2 |
10 | = | 8 | + | 2 |
2 | = | 21 | + | 0 |
2 | = | 2 | + | 0 |
A = (10)10 = (1010)2
E = (14)10
14 | = | 23 | + | 6 |
14 | = | 8 | + | 4 |
6 | = | 22 | + | 0 |
6 | = | 4 | + | 0 |
2 | = | 20 | + | 0 |
2 | = | 2 | + | 0 |
E = (14)10 = (1110)2
On convertit un nombre héxadécimal en binaire en remplacant chaque digit par sa conversion en binaire sur 4 bits, en partant de la droite.
Exemple : (A12)16 = (1010|0001|0010)2
On convertit un nombre binaire en hexadécimal en regroupant les bits par 4 en partant de la droite, puis en convertissant chaque groupe héxadécimal.
Exemple : (1|1101|1110)2 = (1DE)16
Les opérations en binaire s'effectuent selon les mêmes méthodes qu'en décimal. Pour les additions et les soustractions, il suffit de réaliser l'opération chiffre par chiffre, en allant des bits de poids faible (les plus à droite) aux bits de poids fort (les plus à gauche), en propageant l'éventuelle retenue issue du rang précédent.
La table de l'addition est :
A | B | Somme | Retenue |
---|---|---|---|
0 | 0 | 0 | 0 |
0 | 1 | 1 | 0 |
1 | 0 | 1 | 0 |
1 | 1 | 0 | 1 |
La table de soustraction est :
A | B | Soustraction | Retenue |
---|---|---|---|
0 | 0 | 0 | 0 |
0 | 1 | 1 | 1 |
1 | 0 | 1 | 0 |
1 | 1 | 0 | 0 |
Si un nombre binaire est constitué de n "1" consécutifs en partant de la droite, alors sa valeur décimale sera de 2n - 1.
Exemples :
(111)2 = 23 - 1 = 8 - 1 = 7
(1111111)2 = 27 - 1 = 127
(31)10 = 32 - 1 = 25 - 1 = (11111)2
Dans un nombre signé en binaire, c'est le bit de poid fort qui représente le signe. Il vaudra 0 pour un nombre positif, 1 pour un nombre négatif.
Le premier zéro d'un nombre positif deviendra alors significatif. Le nombre de bits d'un nombre devra être fixé.
Si un nombre signé est positif, sa conversion de et vers le décimal se déroulera de la même façon que vue précèdement.
Par contre, la valeur négative nécessite une réprésentation spécifique.
Il y a 2 types de réprésentations.
Il faut inverser complétement bits à bits la valeur du nombre positif.
Exemple sur 4 bits :
(6)10 = (0110)2
(-6)10 = (1001)C1
(1101)C1 inversion (0010)2 = 2 donc (1101)C1 = -2
Attention : en C1, s'il y a une retenue au dernier rang d'une addition, il faut additionner au résultat.
Exemple :
0111 = 7
1001 = - 6
__________
1000 > 0001 = 1
Pour calculer la valeur d'un nombre négatif en complément à 2 (C2), il faut prendre la binaire de la valeur absolue du nombre, l'inverse bit à bit (= complémenter) et y ajouter 1.
Exemple :
(-6)10 = ? (6)10 = (0110)2
inversion : 1001
ajout de 1 : 1
____
(-6)10 = (1010)2
En C2, l'addition, même s'il y a une retenue, se fera en une seule étape.
Exemple :
0111
1010
____
0001
Pour résumé :
C1 :
C2 :
C'est le C2 qui est utilisé en langage de programmation.
Pour que les machines puissent échanger de l'information, il a fallut définir un type de codage commun : une norme.
Il existe maintenant 2 normes principales définissant le codage des données alphanumériques :
Les nombres entiers : binaires et C2.
Les nombres réels : ils sont représentés en virgule flottante : le nombre de chiffres après la virgule n'est que fixé.
La norme utilisée pour représenter les nombres flottants est la norme IEEE 754. Elle définit 3 précisions :