Main

Référence : Langage Arduino : [ Mini | Standard | Etendue | Maxi ] Librairies : [ Vue d'ensemble | Synthèse ] Infos : [ Comparaison | Changements ]

Utilisation des Variables


Déclaration des variables

Une variable est un emplacement (dans la mémoire du microcontrôleur) que l'on va utiliser pour stocker une donnée. Une variable a un nom, contient une valeur et a un type précis (qui correspond à sa taille et aux caractéristiques des données qu'elle peut contenir - nombre entier, à virgule, caractère...). Par exemple, cette instruction (appelée déclaration) :

int broche = 13;

crée une variable :

  • dont le nom est broche,
  • dont la valeur est 13,
  • dont le type est int (un int contient une valeur entière et occupe 2 octets (=2x8bits=16bits) en mémoire)

Ensuite, dans le programme, vous pouvez utiliser cette variable en utilisant son nom : lorsqu'elle sera appelée, sa valeur sera lue et sera utilisée. Par exemple, dans cette instruction :

pinMode(broche, OUTPUT);

la valeur de la variable broche (=13) va être passée à l'instruction pinMode(). A noter que dans ce cas précis, vous n'êtes pas nécessairement obligé d'utiliser une variable, cette instruction fonctionnerait très bien également sous la forme :

pinMode(13, OUTPUT);

Attribution de valeur à une variable

L'avantage d'une variable dans ce cas est que vous ne devrez fixer le numéro actuel de la broche utilisée qu'une seule fois, au début du programme, mais vous pourrez l'utiliser de nombreuses fois ensuite. Ainsi, si vous décidez plus tard d'utiliser la broche 12 au lieu de la broche 13, vous n'aurez besoin de changer que la valeur de la variable broche en début de programme et tout le reste de votre code pourra rester inchangé (sans variable, vous seriez obligé de modifier chaque instruction utilisant le numéro de la broche...).

De fait, vous pouvez utiliser un nom de variable descriptif qui donne une signification claire à la variable (par exemple, un programme utilisant une LED RGB pourra avoir des variables de broches appelées brocheRouge, brocheVerte et brocheBleue).

Une variable a d'autres avantages par rapport à une valeur comme un nombre. Le plus important est que vous pouvez changer la valeur d'une variable en lui attribuant une valeur (ce qui se fait à l'aide du signe égal unique = [2]). Par exemple :

broche = 12;

mettra la valeur 12 dans la variable broche. Noter que nous n'avons pas spécifié ici le type de la variable : en effet, le type n'est pas modifié par l'attribution d'une valeur. Ceci étant, le nom de la variable reste associé en permanence avec le type utilisé lors de sa déclaration; seule sa valeur change [1]. Noter également que vous devez avoir déclaré une variable avant de pouvoir lui attribuer une valeur. Si vous écrivez l'instruction précédente dans votre programme sans avoir utilisé au préalable la première instruction de déclaration, vous aurez un message d'erreur du genre : "error : broche was not declared in this scope" ("erreur : 'broche' n'est pas déclaré dans ce périmètre").

Egalité entre variables

Quand vous écrivez une égalité entre deux variables, vous faites en réalité une copie de sa valeur et cette copie est stockée dans l'emplacement mémoire de l'autre variable. Changer l'une par la suite n'aura pas d'effet sur l'autre. Par exemple, après

int broche = 13;
int broche2 = broche;
broche = 12; 

seulement la variable broche a la valeur 12; la variable broche2 a toujours la valeur 13.

Portée des variables

Maintenant, vous pourriez demandez ce que le mot "scope" (= portée, périmètre) dans ce message d'erreur signifie ? Il se réfère à la partie de votre programme dans laquelle la variable est utilisée. La portée d'une variable est déterminée par l'endroit où vous la déclarez. Par exemple, si vous voulez qu'il soit possible d'utiliser une variable n'importe où dans votre programme, vous devrez la déclarer au début de votre programme, à l'extérieur d'une fonction. On dit qu'une telle variable est globale; voici un exemple :


// déclaration des variables globales
int broche = 13; // déclaration d'une variable appelée broche, de type int et valant 13

void setup()
{
  pinMode(broche, OUTPUT); 
}

void loop()
{
  digitalWrite(broche, HIGH);
} 

Comme vous pouvez le voir, la variable broche est utilisée à la fois dans les fonctions setup() et loop(). Ces deux fonctions utilisent la même variable, et donc changer la valeur de la variable dans l'une des fonctions la changera également dans l'autre fonction et inversement. Ainsi :


// déclaration des variables globales
int broche = 13; // déclaration d'une variable appelée broche, de type int et valant 13

void setup()
{
  broche = 12; // attribution de la valeur 12 à la variable broche
  pinMode(broche, OUTPUT); 
}

void loop()
{
  digitalWrite(broche, HIGH);
} 

Ici, la fonction digitalWrite() appelée dans la fonction loop sera exécutée avec la valeur 12, car c'est la valeur qui a été attribuée à la variable broche dans la fonction setup.

Si vous avez besoin d'utiliser une variable seulement dans une fonction donnée, vous pouvez la déclarer dans cette fonction, et dans ce cas sa portée sera limitée à cette fonction (cette variable ne sera pas accessible depuis les autres fonctions).


void setup()
{
  int broche = 13;
  pinMode(broche, OUTPUT);
  digitalWrite(broche, HIGH);
} 

Dans ce cas, la variable broche ne pourra être utilisée uniquement dans la fonction setup(). Si vous essayez quelque chose comme çà :

[@

void loop() {

  digitalWrite(broche, LOW); // incorrect => la variable broche ne sera pas accessible dans cette fonction

}

vous obtiendrez le même message que précédemment : "error: 'broche' was not declared in this scope" ("erreur : 'broche' n'est pas déclaré dans ce périmètre"). Et ce, bien que vous ayez déclaré la variable quelque part dans une fonction de votre programme, car vous essayez de l'utiliser en dehors de sa portée.

Pourquoi, vous demanderez-vous, ne pas rendre toutes les variables globales ? Après tout, si je ne sais pas où je vais avoir besoin d'une variable, pourquoi limiter sa portée à une seule fonction ? La réponse est que cela rend plus facile à analyser ce qui se passe dans cette fonction. Si une variable est globale, sa valeur peut être modifiée n'importe où dans le code, ce qui revient à dire que vous avez besoin de comprendre la totalité du programme pour savoir ce qui va arriver à la variable. Par exemple, si votre variable a une valeur qui vous ne comprenez pas, il est beaucoup plus facile d'analyser d'où vient cette valeur si la variable a une portée limitée.

[1] Dans plusieurs langage, tel que le langage Python, les types de données sont associés avec les valeurs, pas les variables, et vous pouvez attribuer des valeurs de n'importe quel type à une variable. Ceci s'appelle le typage dynamique.

[2] le signe égal unique = est à distinguer du signe égal double== qui sert à tester si une égalité est VRAIE

Voir également

Commentaires utilisateurs

  • Contrairement à la remarque faite ici sur l'intérêt des variables locales, pour éviter tout problème lié à la portée des variables, il est préférable lorsque l'on débute en programmation de déclarer toutes les variables utilisées avant la fonction setup() en utilisant des noms uniques pour chacune d'elles, dans l'entête du programme. Ces variables seront ainsi globales et accessibles depuis n'importe quelle fonction.
  • D'une manière générale, il est préférable de nommer toutes les broches de la carte Arduino utilisées sous forme de variables que l'on utilisera ainsi ensuite dans le programme (plutôt que les numéros de broches eux-mêmes). De cette façon, la maintenance des programmes sera grandement simplifiée et toute modification dans l'utilisation des broches ne nécessitera qu'une modification de la valeur attribuée à la variable de broche en début de programme. Vos programmes seront ainsi également beaucoup plus facilement transposables d'une carte Arduino à l'autre.

Page d'accueil de la référence Arduino en français

Corrections, suggestions et nouvelle documentation peuvent être postées sur le Forum Arduino ou à l'adresse suivante : support_at_mon-club-elec_point_fr

Le texte original de la référence Arduino est sous licence Creative Commons Attribution-ShareAlike 3.0 . Les exemples de code dans la référence sont dans le domaine public.

La présente traduction française commentée a été réalisée par Xavier HINAULT (2010-2012) (www.mon-club-elec.fr) et est sous licence Creative Commons Attribution-ShareAlike 3.0.

Traduction de la page originale : http://arduino.cc/en/Tutorial/Variables