Maintenant que nous avons passé en revue les types de données, on va pouvoir déclarer nos premières variables. On va également voir l’importance de la portée des variables dans nos programmes Arduino.

Déclarer une variable

Pour déclarer une variable dans un programme, rien de plus simple. Chaque variable est déclarée selon son type de donnée. Une variable peut être initialisée à la création ou non. On peut également déclarer plusieurs variables du même type en même temps. Par exemple :

int variableA; // Déclaration d'une variable de type Int nommée variableA.

variableA = 0; // Initialisation de la variableA à 0.

int variableB, variableC ; // Déclaration de 2 variables en même temps.

float variableD = 0.0 ; // Déclaration et initialisation à 0.0 d'une variable de type float.

La portée d’une variable

Les variables utilisées dans un langage C que Arduino utilise possèdent tous une portée dans le programme selon l’endroit où ces dernières sont déclarées. Les variables ne peuvent être utilisées que par des instructions qui se trouvent à l’intérieur de la fonction où ces variables ont été déclarées. On distingue 3 emplacements dans le code où une variable peut être déclarée :

• À l’intérieur d’une fonction ou d’un bloc de code. On les appelle les variables locales. Elles n’ont pour portée que le bloc ou la fonction où elles ont été déclarées.
• Dans les définitions des paramètres d’une fonction. Ces variables sont appelées ici des paramètres.
• En dehors de toute fonction ou bloc de programme. Ces variables sont des variables globales. Elles peuvent être utilisées dans l’ensemble du code.

Les variables locales

Les variables déclarées à l’intérieur d’une fonction ou d’un bloc sont des variables locales. Ils ne peuvent être utilisés que par les instructions qui se trouvent à l’intérieur de cette fonction ou d’un bloc de code. Voici un exemple :

Void setup () {
 
}
 
Void loop () {
   int i , j ;
   int z ; // Déclaration d'une variable locale
   i = 0;
   j = 0; // Initialisation des variables
   z = 12;
}

Void fonctionQuelconque() {
	// Ici les variables i, j et z sont inconnues. Si on en recrées de nouvelles, elles n'auront de portée que sur la fonctionQuelconque().
}

Les variables en tant que paramètre d’une fonction

Les variables peuvent être des paramètres d’une fonction. Prenons l’exemple d’une fonction d’addition de deux nombres entiers que l’on va appeler dans la boucle principale :

Void setup () {
 
}

Int Addition(int nbrA, int nbrB) {		// Déclaration d'une fonction Int nommée Addition avec 2 paramètres de type int nbrA et nbrB.
	
	int result = nbrA + nbrB ;		// Initialisation d'une variable locale result qui contient le résultat du calcul nbrA + nbrB.
	
return	result ;
}
 
Void loop () {
	
	int nombre = Addition(9,4); // Déclaration d'une variable locale à la fonction loop() contenant le résultat de la fonction Addition avec comme paramètres nbrA = 9 et nbrB = 4.

}

Les variables globales

Les variables globales sont définies en dehors de toutes les fonctions, généralement en haut du programme. Les variables globales conserveront leur valeur tout au long de la durée de vie de votre programme.  Une variable globale peut être accédée par n’importe quelle fonction. Elle est disponible pour toute l’utilisation de votre programme après sa déclaration, peu importe la fonction où elle est appelée. Une variable globale peut également être une variable partagée qui servira à plusieurs fonctions.

L’exemple suivant utilise des variables globales et locales ainsi que des variables paramètres de fonction :

int nombre = 0;	// Initialisation d'une variable globale.

Void setup () {
 
}

Int Addition(int nbrA, int nbrB) {		// Déclaration d'une fonction Int nommée Addition avec 2 paramètres de type int nbrA et nbrB.
	
	int result = nbrA + nbrB ;		// Initialisation d'une variable locale result qui contient le résultat du calcul nbrA + nbrB.
	
return	result ;
}

 
Void loop () {
	
	nombre = Addition(9,4); // On place le résultat de la fonction Addition avec comme paramètres nbrA = 9 et nbrB = 4 dans la variable globale. Celle-ci est maintenant égale à 13.
	
	nombre = Addition(nombre,12); // On réadditionne le nombre avec 12. nombre vaut maintenant 25.

}

Les constantes

Les constantes sont des valeurs qui ne changeront pas pendant l’exécution du programme. Ce sont des valeurs fixes stockées dans la mémoire de donnée de l’Arduino. Ces valeurs ne surchargent pas le programme et leur stockage est optimisé par le compilateur de l’IDE Arduino. Donc si vous avez une constante à déclarer, ne la déclarez pas en variable ;-).

Il existe 3 moyens différents de déclarer des valeurs constantes :

• Avec le mot-clé const. C’est la manière la plus recommandée pour déclarer une constante dans un programme.
• Avec le #define. La constante sera ici prise en charge par le préprocesseur.
• Avec le mot-clé enum. Ici enum est très pratique pour déclarer des constantes de noms et non de valeurs.

Déclaration avec le mot-clé const

Une déclaration de ce type se définit par le mot-clé const, par le type de donnée, le nom de la constante et sa valeur. Il s’agit de la forme la plus robuste. Le compilateur connaît le type de la constante et bloquera cette donnée. Elle sera donc invariable, peu importe le comportement de votre programme. C’est la forme a utiliser en priorité.

const float pi = 3.14 ;

Déclaration avec #define

Un #define ne fait pas partie du langage Arduino. #define est ce qu’on appelle une fonction préprocesseur ou une macro. C’est une fonction qui va être appelée par le compilateur avant que ce dernier effectue son travail de compilation.

#define pi 3.14 

Comme vous pouvez le voir dans l’exemple, le type de donnée n’est même pas à être spécifié. Du fait que ce n’est pas du code C, la syntaxe n’accepte pas le point-virgule ni le signe « = ».

En fait, avant la compilation, la macro #define va remplacer toutes les pi par la valeur 3.14. Le compilateur fait ensuite son travail. La donnée n’est pas verrouillée, car elle n’existera pas dans le programme. Le programme ne verra que des 3.14 partout. Dans certains cas, cela peut poser problème. À proscrire si possible (préférez const !).

Déclaration avec le mot-clé enum

Ce type de déclaration est une arme puissante ! Mouhouhaha ! 🙂 En fait il s’agit de déclarer des constantes dont on ne veut pas forcément connaître la valeur. Pratique pour ne disposer que de noms au lieu de valeurs numériques ! On s’en sert pour exprimer un état. C’est souvent utilisé dans les protocoles de communication. Ici, on va prendre un exemple simple : l’état d’un feu tricolore.

Voici la déclaration d’un enum anonyme :

enum { VERT, ORANGE, ROUGE } ;

byte etatFeu = VERT ;

On peut définir 3 constantes : VERT, ORANGE et ROUGE. Les valeurs n’ont pas d’importance, c’est le compilateur qui va assigner des valeurs aux noms et « réfléchir » avec ces valeurs. Généralement le compilateur va assigner des valeurs dans l’ordre croissant en commençant de 0. Ici VERT vaut 0, ORANGE vaut 1, ROUGE vaut 2. Mais ne vous fiez pas à ces valeurs. Avec plusieurs enum on s’y perd vite. Vous pouvez bien entendu décider des valeurs à la place du compilateur, mais c’est vivement déconseillé ! (ne venez pas pleurer si votre programme plante ^-^).

enum { VERT, ORANGE = 8, ROUGE } ;

Vu que le compilateur incrémente toujours la valeur précédente de 1, ici VERT vaut 0, ORANGE vaut 8 et ROUGE vaut 9.

enum { VERT, ORANGE = 8, ROUGE = 8 } ;

Ceci est également possible. Le compilateur ne vous dira rien à la compilation. Faites donc attention avec les valeurs et si vous pouvez, ne les utilisez pas. Laissez faire le compilateur comme bon lui semble et préférez le passage par noms.

On peut également faire en sorte que l’enum ne soit plus anonyme. On peut le nommer pour qu’il soit plus explicite :

enum CouleurFeu { VERT, ORANGE, ROUGE} ;

On pourra ensuite déclarer des variables du type de l’enum :

enum CouleurFeu etatFeu ;

Attention, cette déclaration occupe deux fois plus d’espace mémoire que de déclarer juste un byte pour etatFeu (comme plus haut). Cette déclaration occupera 2 fois plus de place (2 octets).