DC02 Analyser les systèmes numériques

Représentation
des nombres et des caractères
dans les systèmes numériques

CONTENU
1. LA NUMERATION .............................................................................................................................................................2
1.1. PRINCIPE DES SYSTEMES DE NUMERATION ......................................................................................................................2
1.2. NUMERATION DECIMAL ...................................................................................................................................................2
1.3. NUMERATION BINAIRE ....................................................................................................................................................2
1.4. NUMERATION HEXADECIMALE ........................................................................................................................................2
1.5. CHANGEMENTS DE BASE .................................................................................................................................................3
1.5.1. Base B=>Décimal ..................................................................................................................................................3
1.5.2. Décimal=>Binaire .................................................................................................................................................3
1.5.3. Décimal=>Hexadécimal ........................................................................................................................................3
1.5.4. Binaire=>Hexadécimal ..........................................................................................................................................3
1.5.5. Hexadécimal=>Binaire ..........................................................................................................................................3
2. LE CODAGE DANS LES SYSTEMES NUMERIQUES .................................................................................................3
2.1. CODES PONDERES ............................................................................................................................................................3
2.1.1. Code Binaire ...........................................................................................................................................................3
2.1.2. Décimal codé binaire (DCB) ..................................................................................................................................4
2.1.3. Code Complément à 1.............................................................................................................................................4
2.1.4. Code Complément à 2.............................................................................................................................................4
2.2. CODES NON-PONDERES....................................................................................................................................................5
2.2.1. Code Gray ou binaire réfléchi ................................................................................................................................5
2.2.2. Les Codes p parmi n ...............................................................................................................................................5
3. REPRESENTATION DES NOMBRES DANS LES SYSTEMES NUMERIQUES ......................................................6
3.1. LES NOMBRES ENTIERS ....................................................................................................................................................6
3.2. JUSTIFICATION A DROITE OU A GAUCHE .........................................................................................................................6
3.3. REPRESENTATION DES NOMBRES ENTIERS RELATIFS .......................................................................................................6
3.3.1. Nombres signés .......................................................................................................................................................6
3.3.2. Représentation en complément à 2 .........................................................................................................................7
3.4. REPRESENTATION DES NOMBRES REELS ..........................................................................................................................7
3.4.1. Représentation en virgule fixe ................................................................................................................................7
3.4.2. Principe de la représentation en virgule flottante ..................................................................................................7
3.4.3. Représentation en virgule flottante Simple précision (32 bits) ...............................................................................8
3.4.4. Représentation en virgule flottante Double précision (64 bits) ..............................................................................9
3.5. SYNTHESE .......................................................................................................................................................................9
4. CODAGE DES CARACTERES ALPHANUMERIQUES .............................................................................................10
4.1. CODE ASCII ..................................................................................................................................................................10
4.2. CODE UNICODE .............................................................................................................................................................10

Les neurosciences nous montrent que l'être humain possède une intuition fondamentale pour la numération
héritée de son évolution qui rend tout individu capable de faire des mathématiques élaborées. En effet, la
quantité est une notion essentielle à la survie : elle sert à évaluer la nourriture ou la taille d'un groupe social.
Si le système décimal est le plus fréquemment rencontré, car il a toujours été naturel de compter sur ses doigts,
les Sumériens utilisaient la base 60 (système sexagésimal : on compte les unités sur les doigts d’une main de 0 à
10 en deux fois et on retient les 5 dizaines sur l’autre main – le cerveau ne pouvant retenir qu’un chiffre à la fois
dans un calcul-, quand les deux mains sont pleines, on arrive à 60). Nous utilisons toujours ce système pour
exprimer la mesure des angles plan et du temps.
 CI 2 Comportement des systèmes numériques
1. LA NUMERATION
1.1. Principe des systèmes de numération
Quel que soit le système de numération (base B), tout nombre X se représente par X  an , an 1,..., a1, a0 B
n
et peut se calculer dans la base décimale comme : X   ai .B i (formule polynomiale)
i 0
où :
Bn, Bn–1, …, B1, B0 sont les poids,
n, n-1,…2, 1, 0 sont les rangs,
an, an–1, …, a1 et a0 sont les coefficients ou les chiffres.

Ce principe d’écriture des nombres est appelé "numération positionnelle", dans lequel c’est la position du symbole
graphique qui donne sa valeur. Les systèmes de numération ainsi constitués sont dits pondérés.

En base B, avec n rangs, on a Bn combinaisons. On peut donc compter de 0 à B n – 1.

1.2. Numération décimal

Base : 10
Dix symboles : 0, 1, 2, 3, 4, 5, 6, 7, 8 et 9

Exemple : 7239 = 7.103 + 2.102 + 3.101 + 9.100

Chiffre poids rang

Rappelons que ces chiffres nous sont parvenus par le monde arabo-musulman, où on écrit de la droite vers la gauche. La
lecture occidentale de gauche à droite n'est pas possible sans avoir une vision d'ensemble préalable du nombre.
Ex : 3677, on lit 3, puis trente-six, puis trois cent soixante-sept avant de comprendre que c'est en fait trois mille six cent
soixante-dix-sept ! Cette lecture est d'autant plus difficile que le nombre est grand…

1.3. Numération binaire

Le système binaire est réellement utilisé depuis le XIXème siècle, et les travaux du mathématicien anglais George Boole
(1815–1864). Les informations stockées ou circulant dans un système numérique sont toujours physiquement binaires (porté
par deux niveaux de tension 0 et 5 V par exemple).

Base : 2 Conversion en base 10 :

Deux symboles : 0 et 1 
X  an , an1 ,..., a1a0 2  an .2 n  an1.2 n1 ,..., a1.21  a0 .20 
10

Un code à n chiffres en base 2 distingue 2n états ou combinaisons.

Un état binaire est appelé bit (BInary digiT). Un bit prend les valeurs 0 ou 1.
an sera nommé comme bit le plus significatif (MSB = Most Significant Bit)
a0 sera nommé comme bit le moins significatif (LSB = Low Significant Bit)
Les puissances successives de 2 (1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024, 2048, 4096 …) sont appelées poids
binaires.

1.4. Numération hexadécimale

Ce système de numération est très utilisé dans les systèmes pour contracter la lecture et l’écriture des données binaires.

Base : 16 Conversion en base 10 :

Seize symboles : 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E, F. X  an , an1 ,..., a1a0 16  an .16 n  an1.16 n1 ,..., a1.161  a0 .160 10

Un quartet évolue de 0 à 15 (en base 10) soit de 0 à F en hexadécimal. L’assemblage de 2 quartets forme un mot qui varie de
0 à 255 en décimal et de 0 à FF en hexadécimal.
Pour indiquer la base 16, on peut la noter en indice suivant la manière générale, mais dans la pratique, on peut utiliser le
caractère $ (dollar) devant le nombre, ou la lettre H derrière ou alors 16# devant le nombre.
Exemple : X  F 416  $F 4  F 4H  16$F 4
Denis Guérin Page 2 sur 10 TSI Eiffel Dijon
 CI 2 Comportement des systèmes numériques
1.5. Changements de base
Base B=>Décimal
Pour toute base B vers la base 10, on applique la formule polynomiale.

 
n
X   ai .B i  an .B n  an1.B n1 ,..., a1.B1  a0 .B 0 10
i 0

Décimal=>Binaire
On divise successivement par 2 le nombre décimal. Les restes correspondent aux bits consécutifs dans l’ordre inverse. C’est
terminé au premier dividende nul (que l’on ne compte pas).

Exemple de transcodage décimal, binaire: 4410 => base 2

44 2
0 22 2
0 11 2
1 5 2
1 2 2
0 1
Sens de lecture des restes (44)10 => (101100)2

Décimal=>Hexadécimal
Même chose, mais on divise par 16. Cette stratégie peut servir pour aller plus vite dans la conversion décimal/binaire d'un
grand nombre.
Ex : (251)10
251 16
11($B) 15 16
15($F) 0

(251)10= $FB

Binaire=>Hexadécimal
On regroupe les bits 4 par 4 (en quartets).
Chaque quartet peut alors être converti directement en hexadécimal (max. : 1111 = $ F).
Ex : 1111 1011 = $FB

Hexadécimal=>Binaire
Chaque symbole (chiffre ou lettre) en hexadécimal est converti dans le quartet binaire correspondant.
Ex : $F0A8=(1111 0000 1010 1000)2=(1111000010101000)2

2. CODAGE DANS LES SYSTEMES NUMERIQUES

2.1. Codes pondérés
Code Binaire
On se sert donc logiquement de la numération en base 2, cf chapitre 1.3.

Notations
donnée de 8 bits : « octet », parfois abusivement « byte » ; symbole o (minuscule),
donnée de 16 bits : « word » ou « mot » ou « Seizet »,
donnée de 32 bits : « dword » ou « double mot » ou « trente-deuzet »,
donnée de 64 bits : « qword » ou « quadruple mot ».

Différence entre octet et byte

Si l'on veut explicitement désigner une quantité de huit bits, on utilise le mot octet ; tandis que si l'on veut exprimer
l'unité d'adressage indépendamment du nombre de bits, on utilisera le mot byte. Le byte a souvent une taille d'un
octet (8 bits), mais il peut aussi avoir une taille différente (en général entre 7 et 9 bits).

Denis Guérin Page 3 sur 10 TSI Eiffel Dijon

 CI 2 Comportement des systèmes numériques
Préfixe
La normalisation des préfixes binaires de 1998 par la CEI Les préfixes kilo, méga, giga, téra, etc., correspondent
Commission électrotechnique internationale spécifie les préfixes aux mêmes multiplicateurs que dans tous les autres
suivants pour représenter les puissances de 2 : domaines.
kibi pour « kilo binaire »
mébi pour « méga binaire » Appliqué à l'informatique, cela donne :
gibi pour « giga binaire » 1 kilooctet (ko) = 103 octets
tébi pour « téra binaire »
1 mégaoctet (Mo) = 106 octets
Concernant les multiples de l'octet, cela donne : 1 gigaoctet (Go) = 109 octets
1 kibioctet (Kio) = 210 octets = 1 024 octets 1 téraoctet (To) = 1012 octets
1 mébioctet (Mio) = 220 octets = 1 048 576 octets 1 pétaoctet (Po) = 1015 octets
1 gibioctet (Gio) = 230 octets = 1 024 Mio 1 exaoctet (Eo) = 1018 octets
1 tébioctet (Tio) = 240 octets 1 zettaoctet (Zo) = 1021 octets
1 pébioctet (Pio) = 250 octets
1 exbioctet (Eio) = 260 octets
1 zébioctet (Zio) = 270 octets
1 yobioctet (Yio) = 280 octets

Décimal codé binaire (DCB)

Ce codage permet une lecture décimale directe à partir d'un nombre binaire, il est surtout utilisé pour l'affichage.
Le principe est de coder chaque chiffre décimal, de 0 à 9, par quatre bits, les dernières combinaisons de 1010 à 1111 n'étant
pas utilisées.
Exemple : 58710 => (0101 1000 0111)BCD
Remarque :
Le code DCB est un code pondéré à condition de propager la retenue en base 10 entre deux quartets.
Dans le cas d'un affichage sept segments, pour lequel il est très utilisé, il faut prévoir un décodage BCD/7 segments.

Code Complément à 1
Le code Complément à 1 ou Complément Restreint (CR) d’un nombre est obtenu en complémentant chaque bit un à un.
On a donc : X + CR(X) = 2n −1

Exemple : CR(22) = CR(10110) = (01001) =9=25 −1−22

Code Complément à 2
Le code Complément à 2 ou Complément Vrai (CV) correspond au calcul de 2n−|X|, où n est la longueur de la représentation
(ou taille du registre) et |X| la valeur absolue du nombre à coder.
Ainsi −1 s'écrit comme 256-1=255=(11111111)c2, pour les nombres sur 8 bits.
Ceci est à l'origine du nom de cette opération : "complément à 2 puissance n", tronqué en "complément à 2".

Conversion Binaire=>Binaire Complément à deux

• Les nombres positifs sont représentés comme attendu,
• les nombres négatifs sont obtenus de la manière suivante :
On calcule le complément à un,
On ajoute 1 au résultat (les dépassements sont ignorés).

Exemple : (−4)
On prend le nombre positif 4 : 00000100
On inverse les bits : 11111011
On ajoute 1 : 11111100
(−4)10 =(11111100)c2

Denis Guérin Page 4 sur 10 TSI Eiffel Dijon

 CI 2 Comportement des systèmes numériques
2.2. Codes non-pondérés
Code Gray ou binaire réfléchi
Ce code supprime les aléas découlant du changement simultané de plusieurs variables pour deux combinaisons adjacentes
du code binaire pur. On l'emploi par exemple dans les codeurs absolus.
Le code Gray ou binaire réfléchi ne doit donc pas entraîner le changement de plus d'une variable entre deux combinaisons
successives, il est construit par symétrie en 2n d'où le nom de réfléchi.

Gray Exemple d’utilisation du code Gray dans un codeur de position absolu

d c b a
0 0 0 0 0
1 0 0 0 1
2 0 0 1 1
3 0 0 1 0
4 0 1 1 0
5 0 1 1 1
6 0 1 0 1
7 0 1 0 0
8 1 1 0 0
9 1 1 0 1
10 1 1 1 1
11 1 1 1 0
12 1 0 1 0
13 1 0 1 1
14 1 0 0 1
15 1 0 0 0

Remarque :
• C’est un code ADJASCENT qui pour 2n positions est CYCLIQUE (pour passer de la position 15 à la position 0, il n’y a
qu’un seul changement d’état).
• Le code étant non pondéré (il ne permet pas de faire du calcul), on n’affecte pas de poids aux colonnes mais un rang
ou un symbole (d c b a).

Les Codes p parmi n

Définition : les codes p parmi n sont des codes à n bits dont p bits sont à 1 et (n-p) bits à 0.

Intérêts :
• Code auto-correcteur : en effet la lecture du code peut être associée à la vérification du nombre de 0 et de 1 dans
l’information ce qui permet un contrôle de la validité du message.
• Code personnel : le nombre de possibilités permet de personnaliser son code. Ainsi le code 2 parmi 5 procure 3628800
arrangements différents.

Exemple : Le code 3 parmi 5

Le code présenté permet 10 combinaisons.
Ce codage comporte trois « 1 » et deux « 0 ».
Le code postal utilise un code trois parmi 5. Le tri automatique des plis postaux
nécessite la codification numérique du bureau distributeur. Le code numérique est lu
automatiquement ou par un opérateur. Il est traduit ensuite en un code à barres qui
est matérialisé sous la forme de bâtonnets fluorescents déposés sur le pli postal.

Denis Guérin Page 5 sur 10 TSI Eiffel Dijon

 CI 2 Comportement des systèmes numériques

3. REPRESENTATION DES NOMBRES DANS LES SYSTEMES NUMERIQUES

3.1. Les nombres entiers
Il suffit de convertir l’entier naturel en binaire pour connaître la place prise dans la mémoire d'une machine numérique.
Les limites du codage des nombres entiers naturels sont donc dues à la longueur du mot binaire nécessaire pour coder un
nombre :
sur 8 bits, il n’est pas possible de coder au-delà de 255,
sur 16 bits, au-delà de 65535, …

C’est pourquoi il faudra généralement prendre soin lors de l’écriture d’un programme à la définition correcte du type des
variables, afin d’optimiser la place prise en mémoire par les données (taille du registre).

Dans un PC travaillant sur 32 bits, un nombre est stocké sur 4 octets.

On peut donc représenter les nombres de 0 à $FF FF FF FF soit 232 - 1 = 4 294 967 295 en décimal.

Les PC récents travaillent en 64 bits. Le nombre maximal est donc 2 64 – 1.

3.2. Justification à Droite ou à Gauche

Dans les registres d’un microcontrôleur, les données sont justifiées (ou ajustées) à droite ou à gauche.

Exemple :
Microcontrôleur ATMEL ATMEGA (Carte ARDUINO UNO)
Le convertisseur analogique-numérique (ADC) intégré dans l’ATMEGA est d’une résolution sur 10 bits.
Il utilise 4 registres 8 bits dont :
• Le Registre ADMUX (ADC Multiplexer Selection Register) dont le bit 5 est nommé ADLAR : ADC Left Adjust Result
Ajustement à gauche à 1 ou à droite à 0 du résultat dans les registres ADCL et ADCH.
• 2 Registres ADCH et ADCL (ADC Data Register) pour stocker Le résultat de la conversion.
ADCH : registre 1 octet des adresses hautes.
ADCL : registre 1 octet des adresses basses.

ADLAR ADCH à l’adresse $05 ADCL à l’adresse $04

0 - - - - - - ADC9 ADC8 ADC7 ADC6 ADC5 ADC4 ADC3 ADC2 ADC1 ADC0
1 ADC9 ADC8 ADC7 ADC6 ADC5 ADC4 ADC3 ADC2 ADC1 ADC0 - - - - - -

3.3. Représentation des nombres entiers relatifs

Nombres signés
La notation est utilisée sur des écritures de nombres de longueur donnée (nombres écrits couramment sur 8, 16, 32 ou 64
bits). Dans une telle écriture, on utilise le MSB (bit le plus à gauche) du nombre pour contenir la représentation de son signe
(positif ou négatif, le zéro étant considéré comme positif).
Pour le MSB 0 indique une valeur positive
1 indique une valeur négative

Il faut donc connaître dès le départ le format de codage (Registre n bits), et si les nombres sont signés ou non.

Exemple :
0 0 0 0 0 0 1 0 =(+2)10
1 0 0 0 0 0 1 0 =(-2)10

Inconvénients :
• Le nombre zéro (0) possède deux représentations : 00000000 et 10000000
• Cette représentation impose de modifier l'algorithme d'addition ; si un des nombres est négatif, l'addition
binaire usuelle donne un résultat incorrect.

Denis Guérin Page 6 sur 10 TSI Eiffel Dijon

 CI 2 Comportement des systèmes numériques
Représentation en complément à 2
Principe : Cf chapitre 2.1.4

Il est obtenu par − X = CV(X) = CR(X) +1. 127 0 1 1 1 1 1 1 1

2 0 0 0 0 0 0 1 0
Le signe est le bit de poids fort (par convention, 0 pour une valeur positive et 1 pour une valeur 1 0 0 0 0 0 0 0 1
négative). 0 0 0 0 0 0 0 0 0
Le résultat de l'addition usuelle de nombres représentés en complément à deux est le codage -1 1 1 1 1 1 1 1 1
-2 1 1 1 1 1 1 1 0
en complément à deux du résultat de l'addition des nombres. Ainsi les calculs peuvent
-127 1 0 0 0 0 0 0 1
s'enchaîner naturellement
-128 1 0 0 0 0 0 0 0

Limites :
Sur n bits, on peut représenter les nombres entiers de -2n-1 à 2n-1 -1.
Si un calcul amène à sortir de ces limites, on dit qu'il y a "dépassement de capacité" (overflow).
Lors de l'exécution d'un programme, le dépassement de capacité n'est pas forcément détecté par le processeur, ce qui
conduit évidemment à un traitement faux. C'est le programmeur qui doit être vigilant.

3.4. Représentation des nombres réels

Représentation en virgule fixe
Rappel : un nombre réel se compose de deux parties distinctes :
- une partie entière, située à gauche de la virgule ;
- une partie décimale, située après celle-ci.

Ce codage peut s’écrire sous la forme d’un doublet : [partie entière en binaire, partie décimale en binaire]

Remarque : de par le fait que le processeur ne sait pas représenter le symbole "virgule", il faut, pour que les réels soient
correctement interprétés, que l'emplacement de la virgule soit défini une fois pour toute et ne varie plus, quels que soient
les nombres à représenter.

Principe :
• Pour le codage de la partie entière, nous le coderons comme à l’accoutumé en binaire sur n bits. La valeur de la
partie entière sera donc comprise entre :
0 et 2n-1 pour des valeurs positives,
-2n-1 jusqu'à 2n-1-1 pour des valeurs positives ou négatives ou alors en complément à 2.

• Pour le codage de la partie décimale, chaque bit situé après la virgule correspond à des puissances négatives de 2.

Exemple :
(11001,011 )2= 1.24 + 1.23 + 0.22 + 0.21 + 1.20 , 0.2-1 + 1.2-2 + 1.2-3 = (25,375)10 2-1=0,5
2-2=0,25
2-3=0,125
2-4=0,0625

Principe de la représentation en virgule flottante

Pour pallier les inconvénients de la représentation en virgule fixe, on utilise une autre représentation similaire à la notation
scientifique des calculatrices, sauf qu’elle est en base 2 et non en base 10.

Base 10 : Base 2 :
 1
signe
.Mantisse.10  Exposant
 1signe.Mantisse.2 Exposant

Exemple  11.5,54785.102  554,785 Exemple  11.10010.2110  1,1001.26  1100100  198

Denis Guérin Page 7 sur 10 TSI Eiffel Dijon

 CI 2 Comportement des systèmes numériques
Chaque nombre réel peut alors s’écrire sous la forme d’un triplet (signe, mantisse, exposant). Noter que l’on ne stocke que
la partie décimale de la Mantisse, la partie entière 1 étant implicite.
L'avantage de cette représentation par rapport à la virgule fixe ou à l'entier, est que la virgule flottante est capable, à nombre
de bits égal, de gérer un intervalle de nombres réels beaucoup plus important.
en virgule fixe en virgule flottante
format 7 chiffres décimaux et 2 après la virgule avec sept chiffres décimaux,
99999,99 1,234567
12345,67 123456,7 = 1,234567 × 105
123,45 0,00001234567 = 1,234567 × 10-5
0,01 1234567000000000 = 1,234567 × 1015
…

La vitesse des opérations en virgule flottante, communément appelée FLOPS dans les mesures de performances, est une
caractéristique importante des machines, en particulier dans les logiciels qui effectuent des calculs mathématiques à grande
échelle.

La norme IEEE 754 distingue la représentation binaire simple précision sur 32 bits, et la double précision sur 64 bits.

Représentation en virgule flottante Simple précision (32 bits)

Encodage Signe Exposant mantisse Valeur d’un nombre Précision Chiffres significatifs
32 bits 1 bit 8 bits 23 bits  1 signe
.Mantisse.2 ( E 127)
24 bits Environ 7

L’exposant étant une grandeur signée, le code complément à deux rend les calculs difficiles et on préfère décaler l’exposant
du nombre à coder.

En simple précision, on dispose de 8 bits, on décale alors l’exposant de 127

valeurs (28-1 -1). L'exposant d'un nombre normalisé va donc de -126 à +127.
L'exposant -127 (qui est décalé vers la valeur 0) est réservé pour zéro, tandis
que l'exposant 128 (décalé vers 255) est réservé pour coder les infinis et les
NaN (résultat invalide d’un calcul en virgule flottante).

Exemple : Traduire en binaire format flottant simple précision le nombre X  6,625

Format attendu :  1signe.Mantisse.2( E 127)
Signe 1 (négatif)
Mantisse Convertir la valeur absolue en binaire : X  6,625  110,10102
Former la mantisse : 1, mantisse 110,10102  1,101010.22
Etendre la partie fractionnaire à 23 bits M  101 0100 0000 0000 0000 0000

Exposant n  E + 127  2 +127 = 129 = (1000 0001)2

résultat
1.Mantisse.2(2127)  1.101 0100 0000 0000 0000 0000.2(129)

Signe I-------Exposant------------I----------------------------------Mantisse----------------------------------I
Soit en hexadécimal X  $C0 D4 00 00

Limites de la représentation en virgule flottante simple précision :

- le plus petit nombre positif est 0 0000 0001 0000 0000 0000 0000 0000 000 = 2-126= 1,175494351.10-38
- le plus grand nombre positif est 0 1111 1110 1111 1111 1111 1111 1111 111 = (2-2-23) .2127= 3,402823466.1038

Denis Guérin Page 8 sur 10 TSI Eiffel Dijon

 CI 2 Comportement des systèmes numériques
Représentation en virgule flottante Double précision (64 bits)
On utilise la même méthode que pour le codage en simple précision, sauf
que l’exposant est codé sur 11 bits et la mantisse sur 52 bits.

Encodage Signe Exposant mantisse Valeur d’un nombre Précision Chiffres significatifs
64 bits 1 bit 11 bits 52 bits  1signe
.Mantisse.2 ( E 1023)
53 bits Environ 16

Limites de la représentation en virgule flottante simple précision :

- le plus petit nombre est ±2−1022 ≈ ±2,2250738585072014×10−308;
- le plus grand nombre est ±(21024 − 2971) ≈±1,7976931348623157×10308.

Codage au format Qn
Le code est obtenu en multipliant la valeur à coder par 2 n et en ne conservant que la partie entière, et codé ensuite en
binaire.
Exemple : Traduisons en binaire format Q14 le nombre : x = - 6,732
Intéressons nous tout d’abord à la valeur absolue : 6,732
En multipliant cette valeur par 214, nous obtenons : 110297,088
Sa partie entière vaut : 110297
Soit en binaire naturel : 11010111011011001
si l’on désire coder les nombres négatifs en complément à 2 :
En binaire sur 20 bits : 1110 0101 0001 0010 0111
Et en hexadécimal : E5127

3.5. Synthèse
Pour programmer un microcontrôleur, il existe plusieurs sortes de données.
Par exemple, pour précharger un compteur (Timer), on utilisera une variable de type entier « int »
Pour calculer la moyenne d'une série de données fournies par un capteur, il faut utiliser un nombre réel « float ».
S'il s'agit de tester une condition, un simple booléen peut suffire « boolean ».

Les différents formats de nombre sur la carte Arduino

Type Taille en mémoire Type de données signe Valeurs min/max
Valeurs binaires
boolean 1 octet (8 bits) Valeur binaire 1/0 non signée 0/1

Valeurs numériques entières signées

int 2 octet (16 bits) Valeur entière signée -32 768 / +32 767j

long 4 octet (32 bits) Valeur entière signée -2 147 483 648 / +2 147 483 647
Valeurs numériques entières non signées
byte 1 octet (8 bits) Valeur entière non signée 0 / +255

unsigned int 2 octet (16 bits) Valeur entière non signée 0 / +65535

word 2 octet (16 bits) Valeur entière non signée 0 / +65535

unsigned long 4 octet (32 bits) Valeur entière non signée 0/ +4 294 967 295
Valeurs numériques à virgule
float 4 octet (32 bits) Valeur à virgule signée -3.4028235.1038 / +3.40282351038
double
(identique à 4 octet (32 bits) Valeur à virgule signée -3.40282351038/ +3.40282351038
float)

Denis Guérin Page 9 sur 10 TSI Eiffel Dijon

 CI 2 Comportement des systèmes numériques
4. CODAGE DES CARACTERES ALPHANUMERIQUES
4.1. code ASCII
Chaque caractère possède son équivalent en code
numérique : c'est le code ASCII (American Standard
Code for Information Interchange).
Le code ASCII de base représentait les caractères sur 7
bits (c'est-à-dire 128 caractères possibles, de 0 à 127).
• Les codes 0 à 31 ne sont pas des caractères. On les
appelle caractères de contrôle car ils permettent de
faire des actions telles que : retour à la ligne (CR), bip
sonore (BEL), etc.
• Les codes 65 à 90 représentent les majuscules,
• les codes 97 à 122 représentent les minuscules.

Exemple :
En écrivant GRAY en ASCII nous obtenons :

Le code ASCII a été mis au point pour la langue anglaise, il ne contient donc pas de caractères accentués, ni de caractères
spécifiques à une langue. Pour coder ce type de caractère, le code ASCII a donc été étendu à 8 bits (un octet) pour pouvoir
coder plus de caractères (on parle d'ailleurs de code ASCII étendu ANSI). Le code ASCII étendu n'est pas unique et dépend
fortement de la plateforme utilisée ce qui fait qu’un message rédigé en $ par son émetteur peut être reçu en € par son
récepteur.

4.2. Code Unicode

C’est un système de codage des caractères sur 32 bits mis au point à partir de 1991. Le système
Unicode permet de représenter n'importe quel caractère par un code sur 32 bits, indépendamment de
tout système d'exploitation ou langage de programmation.
Il regroupe ainsi la quasi-totalité des alphabets existants (arabe, arménien, cyrillique, grec, hébreu, latin,
...) et est en partie compatible avec le code ASCII.

crédits :
Wikipédia
TSI Cannes

Denis Guérin Page 10 sur 10 TSI Eiffel Dijon