Au menu de ce troisième chapitre : les variables sur Arduino. Tu vas voir que les variables sont très utiles car elles permettent de conserver des informations.
Types de variables
Il existe différents types de variables pour différents types de données, en voici quelques-uns. Pour en savoir plus sur les variables sur Arduino, clique ici.
- char : pour stocker des caractères (taille : un byte).
- byte : pour stocker un chiffre compris entre 0 et 255.
- int : pour stocker un chiffre compris entre 2-15 et 215-1, c’est-à-dire, entre -32,768 et 32,767 (taille : 2 bytes (16 bits)).
- unsigned int : n’a pas de signe donc peut stocker des valeurs comprises entre 0 et 216-1, c’est-à-dire entre 0 et 65,535 (taille : 2 bytes).
- long : pour des valeurs comprises entre -2,147,483,648 et 2,147,483,647 (taille : 32 bits (4 bytes)).
- unsigned long.
- float : pour nombres décimaux compris entre -3.4028235E+38 et +3.4028235E+38 (taille : 32 bits (4 bytes)).
- double : pour nombres décimaux aussi (taille : 8 bytes (64 bits)).
Quand tu choisis un type de donnée, tu dois choisir parmi ceux correspondant à tes besoins, celui qui occupe le moins d’espace possible. En effet, ces données vont occuper la mémoire de ta carte contrôleur et il peut arriver que le programme demande plus de mémoire que possible.
Mais, comment introduire une variable dans le code ? C’est très simple, il te suffit d’indiquer le type et le nom de la variable. Tu peux également lui donner une valeur initiale. Voici tout de suite un exemple :
|
1 2 3 4 5 |
char miCaracter='a'; //nous déclarons une variable de type char, appelée miCaracter et nous lui donnons la valeur a comme valeur initiale byte unNumero = 189; // variable de type byte avec 189 pour valeur initiale int unEntero; //variable de type int sans valeur initiale unsigned int numeroPositivo = 2343; //entier positif avec valeur initiale float numDecimal = 12.212; //nombre décimal avec valeur initiale de 12,212 |
Un autre type de variable très important est le type String qui sert à stocker des chaînes de caractères. Il est incontournable pour envoyer du texte via port série. Il permet de créer des chaînes à partir de chiffres, d’autres variables, ou en réunissant des chaînes. Voici quelques exemples (tirés de cette page) :
|
1 2 3 4 5 |
String stringOne = "Hello String"; // using a constant String String stringOne = String('a'); // converting a constant char into a String String stringTwo = String("This is a string"); // converting a constant string into a String object String stringOne = String(stringTwo + " with more");// concatenating two strings String stringOne = String(13); // using a constant integer |
Il existe un autre type de variable important : array. Il s’agit du regroupement organisé de données d’un type donné. Nous n’allons pas nous attarder sur ce type de variable aujourd’hui. Chaque chose en son temps ! Voici un exemple avec la somme de deux entiers et l’envoi du résultat par port série :
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
int a = 5; //variable a contient un entier, valeur initiale : 5 int b = 6; //variable b contient un entier, valeur initiale : 6 int c = a + b; //variable c contient un entier, valeur initiale : 11. void setup() { // initialisation Serial Serial.begin(9600); // débit en bauds : 9600 Serial.print("a + b equals "); Serial.println(String(c)); } void loop() { } |
Ici, nous avons tout écrit dans la fonction setup car nous voulons que l’action se produise une seule fois. À ton avis, qu’allons-nous imprimer via le port série ?
- a + b equals c
- 5 + 6 equals 11
- a + b equals 11
Il ne te reste plus qu’à vérifier si tu as vu juste !
Domaine des variables
Procédons pas à pas avec des exemples…
Domaine global
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
int a= 5; void setup() { // initialisation Serial Serial.begin(9600); // débit en bauds : 9600 Serial.println(String(a)); Serial.println("fin setup"); } void loop() { a = a + 1; Serial.println(String(a)); delay(1000); } |
La variable a est une variable globale car il est possible de l’appeler à partir de n’importe quel endroit, c’est-à-dire qu’il est possible d’accéder à son contenu à partir de la fonction setup et de la fonction loop.
Voici ce que tu obtiendras via le port série :
Domaine local
Il s’agit de variables qui existent seulement dans le domaine dans lequel elles ont été déclarées. Pour faire court, un domaine est délimité par des accolades. Si tu utilises la variable en dehors de son domaine, tu obtiendras une erreur de compilation. Puisque la variable locale existe uniquement dans son domaine, il est possible d’utiliser le même nom pour deux variables différentes situées dans deux domaines différents. Voici quelques exemples pour mieux comprendre :
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
void setup() { int a= 5; //la variable<em> a</em> existe uniquement au sein de la fonction setup // initialisation Serial Serial.begin(9600); // débit en bauds : 9600 Serial.println(String(a)); Serial.println("fin setup"); } void loop() { //en compilant tu obtiendras une erreur de compilation car <em>a</em> n'existe pas dans loop a = a + 1; Serial.println(String(a)); delay(1000); } |
En compilant ce programme, tu obtiendras une erreur de programmation car la variable int a est locale et elle existe uniquement à l’intérieur de la fonction setup. C’est pourquoi tu ne peux pas l’utiliser dans la fonction loop.
Que va-t-il se passer avec ce programme ?
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
void setup() { int a = 5; //la variable <em>a</em> existe uniquement à l'intérieur de la fonction <em>setup</em> // initialiser Serial Serial.begin(9600); // débit en bauds : 9600 Serial.println(String(a)); Serial.println("fin setup"); } void loop() { int a = 0; a = a + 1; Serial.println(String(a)); delay(1000); } |
Est-il possible de compiler ? Oui, car a a été déclarée dans loop et dans setup. Que va-t-il s’imprimer via le port série ?
|
1 2 3 4 5 |
5 fin setup 1 1 1 |
Tu ne t’attendais pas à ça, n’est-ce pas ? Tu pensais voir s’afficher 1 2 3 4… ? C’est normal. Mais pourquoi ce n’est pas comme ça ? La variable a de loop se créée et se détruit à chaque itération. Elle revient donc toujours à la valeur 0 à laquelle on ajoute 1… C’est pourquoi elle vaut toujours 1 dans loop.
Et les programmes suivants ? Essaie donc de deviner, fais-les toi-même pour en vérifier le résultat.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 |
int a = 0; void setup() { int a = 5; //la variable<em> a</em> existe uniquement dans la fonction setup // initialisation Serial Serial.begin(9600); // débit en bauds : 9600 Serial.println(String(a)); Serial.println("fin setup"); } void loop() { a = a + 1; Serial.println(String(a)); delay(1000); } |
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 |
int a = 0; void setup() { int a = 5; a = a + 1; // initialisation Serial Serial.begin(9600); // débit en bauds : 9600 Serial.println(String(a)); Serial.println("fin setup"); } void loop() { a = a + 1; Serial.println(String(a)); delay(1000); } |
Et si tu écrivais dans les commentaires la réponse (avant de la vérifier) ? Ne sois pas timide ! 
