Bonjour à tous!

Comme nous l'avons vu précedement l'Arduino est capable d'éxecuter un programme(écrit en C,C++,ASM) une fois que ce dernier aura été compilé en langage machine.

Sans rentrer dans les détails de la compilation pour le moment,nous essairons d'aborder une notion essentielle de l'informatique : la representation binaire d'une information.

Les systemes informatiques(microcontrolleur,consoles,ordinateurs,calculateur...) sont tous soumis à la même problématique,comment effectuer des opérations complexe alors qu'il ne manipule que des 0 et 1?

En effet la conception de ces systémes dans leur forme la plus simple est avant tout un assemblage de transistors

Le transistor est un semi-conducteur, pour schematiser il est capable quand on applique une tension électrique en entrée de prendre 2 états : fermé ou ouvert.

En assemblant plusieurs transistors ensemble sur un circuit,on peut créer une porte logique par exemple :

2 transistors recoivent une tension,ils changent leur état indépendamments et on chosit le comportement voulu en sortie en comparant l'état des 2 transistors:

• si le transistor1 == 0 ET le transistor2 == 0 alors fait ça.
• si le transistor1 == 0 ET le transistor2 == 1 alors fait ça.
• si le transistor1 == 1 ET le transistor2 == 0 alors fait ça.
• si le transistor1 == 1 ET le transistor2 == 1 alors fait ça.
• si le transistor1 == 0 OU le transistor2 == 0 alors fait ça.
• si le transistor1 == 0 OU le transistor2 == 1 alors fait ça.
• si le transistor1 == 1 OU le transistor2 == 0 alors fait ça.
• si le transistor1 == 1 OU le transistor2 == 1 alors fait ça.

Remarque:

Notez la similitude entre le fonctionnement électronique d'un composant et le simple "IF" de nombreux langages de programmation :

• if (x==42 && y=="H") then

Dans les langages haut niveau,nous pouvons écrire x==42 ou autre valeur ,au moment de la compilation la valeur sera convertie dans son équivalent binaire c'est à dire une suite de 0/1.

Le bit est la plus petite unité de notre systéme binaire et ne peut prendre que deux valeurs 0 ou 1.

un seul  bit permet uniquement de coder  2 valeurs,il a donc fallu trouver un moyen d'agencer plusieurs bits  ensemble pour pouvoir traiter des valeurs differentes de 0 et 1(ici ce n'est pas la valeur numerique qui importe mais vraiment l'état indiqué par le bit : ouvert/fermé,oui/non...)

En traitant 2 bits ensemble,on augmente le nombre de valeurs que l'on peut représenter :

1. Premierbit == 0 Secondbit==0
2. Premierbit == 1 Secondbit ==0
3. Premierbit == 0 Secondbit ==1
4. Premierbit == 1 Secondbit ==1

Pour savoir combien de valeurs sont disponibles pour un nombre de bits traités ensemble,il faut mettre la base de notre systéme à la puissance du nombre de bits utilisés :

• Un seul bit == 2^1 == 2 valeurs
• Deux bits == 2^2 == 4 valeurs
• Trois bits == 2^3 == 8 valeurs
• Quatre bits == 2^4 == 16 valeurs
• Huit bits == 2^8 == 256 valeur

Les composants informatiques comme le processeur ne traitent donc que des suites de 0/1 mais avec une vitesse trés elevée,l'agencement de ces suites lui permet de traiter correctement la représentation selon un contexte défini par le compilateur.Un processeur utilise un regroupement des bits et le plus petit  regroupement de bits addressable définira le Byte.Même si ce n'est plus répandu de nos jours(à part certains automates) des systémes ont été développés en 4bits par exemple,dans un tel systéme le Byte vaudra 4 bits.

Le regroupement par bits s'est normalisé dans sa grande majorité vers un groupement en 8 bits le fameux Octet.Dans ce cas la  1Byte==1Octet==8bits.

le processeur 8bit pourra acceder à 1Octet de données par opération et peut traiter des données sur 16 ou 32 bits(multiples de 8).

Nous allons dans un premier temps laisser de côté les notions plus complexe que sont le traitement du langage machine par le processeur et les registres,pour voir ce que l'on peut représenter avec un Octet.

Les valeurs entiéres:

      char

            unsigned char (valeurs décimales positives)

                   0 à 255      (2^8(-1)

exemple : 00000000 == 0          00000110 == 6          11111010 == 250

                00000001 == 1          00000111 == 7          11111011 == 251

                00000010 == 2          00001000 == 8          11111100 == 252

                00000011 == 3          00001001 == 9          11111101 == 253

                00000100 == 4          00001010 == 10        11111110 == 254

                00000101 == 5          00001011 == 11        11111111 == 255

            signed char (valeurs positives et négatives un bit de l'octet est utilisé pour définir le signe)

                 -128 à +127      (2^7(-1))

                                    00000000 == 0

             00000001 == 1                     11111111 == -1

             00000010 == 2                     11111110 == -2

             00000011 == 3                     11111101 == -3

             00000100 == 4                     11111100 == -4

             00000101 == 5                     11111011 == -5

             01111111 == 127                 10000000 == -128
             

Les booléns :

      bool 

            true ou false

par convention il est admis que 0 == faux et que toute autre valeur entiere == vrai.

Il suffirait d'un seul bit pour définir un booléen(valeur à coder 0 ou 1) mais le processeur ne pourra adresser que un Byte minimum,notre booléen fera donc un Octet.

Nous en resterons là pour le moment,notez que le type char destiné à afficher un caractére est en fait un sous-type du int(type representant des valeurs décimales sur 16 bits ou 32bits selon le type de processeur),pour interpreter un caractere il sera converti dans sa valeur décimale et afficher à partir d'une table de caracteres comme la table ASCII par exemple.