ISSLg - Cours d'électronique
Les systèmes de numération
Navigation> electronique/automatisme/codage/numeration

Un système de numération permet de représenter des nombres.

Le système décimal
C'est le système que nous utilisons dans notre vie de tous les jours. Il repose sur l'usage de dix symboles :
              0 1 2 3 4 5 6 7 8 9
Avec un symbole décimal nous pouvons représenter un nombre allant de 0 à 9.

Pour représenter des nombres plus grands, nous utilisons une suite de symboles pour spécifier les unités, les dizaines, les centaines, les milliers... c'est à dire des puissances de 10 :
Ex : 5236 = 5000 + 200 + 30 + 6
                = 5 * 1000 + 2 * 100 + 3 * 10 + 6 * 1
                = 5 * 103 + 2* 102 + 3 * 101 + 6 * 100

Pour spécifier que ce nombre est en base 10, il faut le noter de la manière suivante :
       (5236)10 

Dans ce site et les logiciels téléchargeable sur ce site, si la base n'est pas spécifiée, c'est que le nombre est en base 10.


Le système de base n
Ce principe de numération peut être appliquer à n'importe quel jeu de symboles.
Par exemple, si nous utilisons les n premiers symboles : 0, 1 ... n-1 ; nous pouvons représenter n'importe quel nombre comme suit :
      (dcba)n = d * n3 + c * n2 + b * n1 + a * n0
      ou a, b, c & d sont des symboles de la base : 0, 1 ... n-1


Le système binaire
Nous avons vu que les signaux logiques pouvaient avoir deux états 0 et 1.
Il est donc possible de représenter des nombres supérieurs à 1 en utilisant un système de base 2 :
      (dcba)2 = d * 23 + c * 22 + b * 21 + a * 20
      ou a, b, c & d sont des symboles de la base : 0 ou 1
           a, b, c & d sont également appelés "bits"

Exemple :
      (1010)2 = (1)2 * 23 + (0)2 * 22 + (1)2 * 21 + (0)2 * 20
      (1010)2 = 1 * 8 + 0 * 4 + 1 * 2 + 0 * 1
      (1010)2 = 10

Dans ce site et les logiciels téléchargeables sur ce site, par simplification d'écriture, nous ferons précéder les nombres binaires par les caractères "0b".
Exemple :
      (1010)2 = 0b1010 = 10

Avec des nombres binaires de x bits, nous pouvons représenter 2x nombres allant de 0 à 2x-1
Exemple :
   0b0000 = 0    ..     0b1111 = 24-1 = 15
   0b00000000 = 0    ..     0b11111111 = 28-1 = 255

Le bit le plus à droite est le bit de poids faible ou LSB (Least Significant Bit) : 0b01101101
Le bit le plus à gauche est le bit de poids forts ou MSB (Most Significant Bit) : 0b01101101

Exercices


Le système hexadécimal
Si les nombres sont physiquement électriquement codés en base 2, leur lecture devient difficilement lisible par l'Homme  dès que l'on aborde des nombres au-delà de quelques centaines (suite interminables de 0 et de 1). C'est pourquoi, les nombres binaires sont également souvent notés en base 16, c'est le système hexadécimal, chaque paquet de 4 bits est ainsi représenté par un seul caractère.
Les chiffres ne suffisent pas pour représenter ces 16 états, aussi ils sont complétés par les premières lettres de l'alphabet. Le jeux de symbole en base 16 est ainsi :
       0 1 2 3 4 5 6 7 8 9 A B C D E F

La représentation de nombres supérieurs à 16 se fait en utilisant un système de base 16 :
      (dcba)16 = d * 163 + c * 162 + b * 161 + a * 160
      ou a, b, c & d sont des symboles de la base : de 0 à F

Exemple :
      (1A7C)16 = (1)16 * 163 + (A)16 * 162 + (7)16 * 161 + (C)16 * 160
      (1A7C)16 = 1 * 163 + 10 * 162 + 7 * 161 + 12 * 160
      (1A7C)16 = 1 * 4096 + 10 * 256 + 7 * 16 + 12 * 1
      (1A7C)16 = 6780

Dans ce site et les logiciels téléchargeables sur ce site, par simplification d'écriture, nous ferons précéder les nombres hexadecimaux par les caractères "0x" ou encore "$".
Exemple :
       (1A7C)16 = 0x1A7C = $1A7C = 6780

Exercices


Tableau d'équivalence
DécimalHexadécimalBinaire
0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
...
31
32
...
63
64
...
127
128
...
255
256		0x00
0x01
0x02
0x03
0x04
0x05
0x06
0x07
0x08
0x09
0x0A
0x0B
0x0C
0x0D
0x0E
0x0F
0x10
0x11
0x12
0x13
0x14
0x15
0x16
0x17
0x18
0x19
0x1A
...
0x1F
0x20
...
0x3F
0x40
...
0x7F
0x80
...
0xFF
0x100		0b00000000
0b00000001
0b00000010
0b00000011
0b00000100
0b00000101
0b00000110
0b00000111
0b00001000
0b00001001
0b00001010
0b00001011
0b00001100
0b00001101
0b00001110
0b00001111
0b00010000
0b00010001
0b00010010
0b00010011
0b00010100
0b00010101
0b00010110
0b00010111
0b00011000
0b00011001
0b00011010
...
0b00011111
0b00100000
...
0b00111111
0b01000000
...
0b01111111
0b10000000
...
0b11111111
0b100000000


Conversion hexadécimal en binaire
Elle se fait tout simplement en remplacant les symboles hexadecimaux par le paquet de 4 bits correspondant :
HexadécimalBinaire
0
1
2
3
4
5
6
7
8
9
A
B
C
D
E
F
0000
0001
0010
0011
0100
0101
0110
0111
1000
1001
1010
1011
1100
1101
1110
1111

Exemple :
       0x7C = 0b01111100

Conversion binaire en hexadécimal
Il faut en premier regrouper les bits par 4 en commençant par la droite (les LSB).
Ensuite, ajouter des 0 devant le dernier paquets (les MSB) pour faire un paquet de 4 bits si le nombre de bits n'est pas un multiple de 4.
Finalement, remplacer les paquets de 4 bits par les symboles hexadecimaux correspondants.

Exemple :
      0b1010110011 = 0b1010110011 = 0b001010110011 = 0x2B3


Conversion décimal en base n
Il faut faire une division entière du nombre décimal par n (la base). Le reste de cette division représente le LSB de la représentation de ce nombre dans cette base. En répétant l'opération sur le résultat de la division, il est possible d'obtenir tous les caratères de représentation dans la base n.

En effet :
1ère division :
      (dcba)n = d * n3 + c * n2 + b * n1 + a * n0
      (dcba)n div n = d * n2 + c * n1 + b * n0         reste = a

2ème division :
      ((dcba)n div n) div n = d * n1 + c * n0           reste = b

3ème division :
      (((dcba)n div n) div n) div n = d * n0             reste = c

4ème division :
      ((((dcba)n div n) div n) div n) div n = 0         reste = d


Conversion décimal en binaire
Diviser le nombre décimal par 2, le reste représente le bit[0], c-à-d le LSB.
Diviser le quotient de la division précédente par 2, le reste représente le bit[1].
Et ainsi de suite, jusqu'à ce que le quotient soit nul.

Exemple :
      137 div 2 = 68         reste = 1      (bit[0])
       68 div 2 = 34          reste = 0      (bit[1])  
       34 div 2 = 17          reste = 0      (bit[2])
       17 div 2 = 8            reste = 1      (bit[3])
       8 div 2 = 4              reste = 0      (bit[4])
       4 div 2 = 2              reste = 0      (bit[5])
       2 div 2 = 1              reste = 0      (bit[6])  
       1 div 2 = 0              reste = 1      (bit[7])

=> 137 = 0b10001001

Exercices

Idée de programmation de ce genre de conversion :
procedure DecToBin (ndec:byte ; var bit[0..7]);
   begin
   for i:=0 to 7 do
      begin
      bit[i] := ndec mod 2;
      ndec := ndec div 2;
      end;
   end;


Conversion décimal en hexadécimal
Diviser le nombre décimal par 16, le reste représente le hexa[0], c-à-d les LSB.
Diviser le quotient de la division précédente par 16, le reste représente le hexa[1].
Et ainsi de suite, jusqu'à ce que le quotient soit nul.

Exemple :
      27678 div 16 = 1729      reste = 14 = 0xE      (hexa[0])
      1729 div 16 = 108          reste = 1   = 0x1      (hexa[1])
      108 div 16 = 6                reste = 12 = 0xC      (hexa[2])
      6 div 16 = 0                    reste = 6   = 0x6      (hexa[3])

=> 27678 = 0x6C1E

Exercices

Idée de programmation de ce genre de conversion :
procedure DecToHexa (ndec:byte ; var hexa[0..4]);
   begin
   for i:=0 to 4 do
      begin
      hexa[i] := ndec mod 16;
      ndec := ndec div 16;
      end;
   end;

Auteur : Philippot Marc - 12/09/2010