Stocker et récupérer des valeurs : les variables

Nous abordons ici les principes généraux du mécanisme de la mémoire et du stockage des valeurs dans un système à base de micro-processeur. Comme ces valeurs changent souvent, nous les appelons des "variables".


Les variables

Les variables sont des emplacements dans la mémoire du micro-contrôleur. Nous leur donnons un nom pour les créer, les stocker et les retrouvez (facilement).
Une variable contient la valeur que vous désirez mémoriser ou utiliser dans votre programme.
Pour que tout cela fonctionne correctement nous devons faire une ou des déclarations de variables au début du programme ou de la fonction.

Déclaration de variables

Voici trois exemples de déclarations de variables à partir de l'extrait de code suivant :


{
  ...
  // déclarations des variables
  int a = 42;
  char c = 'm';
  float root2 = sqrt(2.0);
  ...
}

La déclaration int a = 42 crée une variable nommée "a". La partie int indique au logiciel Arduino quel type de variables nous utilisons. Le type int peut stocker des nombres entiers allant de -32768 à 32767.
La déclaration attribue également une valeur initiale de 42 à "a". La valeur initiale est facultative, vous pouvez simplement déclarer "int a". Ainsi, au moment désiré, nous attribuons la valeur "42" à "a" avec la déclaration suivante : a = 42.

La déclaration char c = 'm' déclare une variable nommée c du type char qui est prévu pour stocker des caractères. La variable c contient "m" comme valeur.

Puis, float root2 = sqrt(2.0) déclare une variable nommée root2. Le type de la variable est un nombre flottant qui peut contenir des valeurs décimales (3,14 ; 1,732 ; 0,866...). Ici, root2 est initialisé avec une représentation à virgule de la racine carrée de deux : sqrt(2.0).

Remarque importante :
même si nous écrivons couramment 3,14 (trois virgule quatorze), la syntaxe de la programmation nous impose d'utiliser un point à la place de la virgule. Soit : 3.14 pour coder la valeur "trois et quatorze centièmes".

Maintenant que votre code a stocké les valeurs dans la mémoire, comment peut-il les récupérer et les utiliser ?
Une façon très simple, est de passer chaque variable comme paramètre d'une fonction. Voici trois exemples, où Serial.println(val) affiche la valeur de la variable contenue à l'intérieur des parenthèses.
Affichage des valeurs de variables dans le moniteur série avec la fonction Serial.println

Une chose qui est intéressante est que Serial.println(val) reconnaît chaque type de variable ; il affiche correctement la valeur dans la série du moniteur. De plus, le compilateur du logiciel Arduino exige que toutes les variables soient déclarées et typées.

L'exemple stocke_variable_locale

  • Utilisez la commande [Fichier], [Nouveau] pour créer un nouveau programme et l'enregistrer en tant que "stocke_variable_locale",
  • entrez ou copiez le code ci-dessous dans l'éditeur Arduino,
  • enregistrez le fichier, puis transférez-le vers votre carte,
  • ouvrez le moniteur série et vérifiez que les valeurs s'affichent correctement.

// La Robotique avec BOE shield bot
// stocke_variable_locale

void setup ()
{
  Serial.begin (9600);
  // déclarations des variables
  int a = 42;
  char c = 'm';
  float root2 = sqrt (2.0);

  // affiche la valeur des variables
  Serial.println(a);
  Serial.println(c);
  Serial.println(root2);
}

void loop ()
{
// Vide, aucun code à répéter
}

Le code ASCII

ASCII est l'acronyme de American Standard Code for Information Exchange.
Le codage ASCII est utilisé pour représenter les touches d'un ordinateur et les caractères à afficher sur un écran. Par exemple, la carte Arduino et le moniteur série utilisent tous les deux le code ASCII "109" pour la lettre m. La déclaration de variable char c = 'm' permet d'inscrire le numéro 109 dans la variable c qui est stocker dans la mémoire du micro-contrôleur. Lorsque la carte Arduino exécute l'instruction Serial.println(c), elle envoie 109 au moniteur série. Quand le moniteur série reçoit le code 109, il affiche automatiquement le caractère "m". Voir en annexe la table des caractères ASCII de 0 à 127.

Variable globale versus locale

Jusqu'à présent, nous avons déclaré les variables à l'intérieur d'un bloc fonctionnel (à l'intérieur des accolades de la fonction). Cela signifie que ce sont des variables locales. Seule la fonction qui a déclarée une variable peut la voir ou la modifier. En outre, une variable locale n'existe qu'au moment où la fonction appelante l'utilise. Après cela, l'emplacement mémoire qu'occupait notre variable locale retourne à la mémoire non allouée. Il en résulte qu'une autre fonction (comme loop) peut utiliser cette mémoire pour une variable locale différente.

Si votre programme doit permettre à plus d'une fonction d'accéder à la valeur d'une variable, vous pouvez utiliser des variables globales. Pour rendre une variable globale, il suffit de la déclarer en dehors de toute fonction et de préférence avant la fonction setup(). Ensuite, toutes les fonctions de votre programme seront en mesure de modifier ou d'extraire la valeur de la variable globale. L'exemple suivant déclare des variables globales et montre les différentes valeurs que leur assigne les fonctions.

L'exemple stocke_variable_globale

Dans cet exemple nous déclarons a, c et root2 comme des variables globales (au lieu de local). Maintenant qu'elles sont globales, les fonctions setup() et loop() peuvent y accéder toutes les deux.

  • Modifiez votre code afin qu'il corresponde à celui ci-dessous,
  • enregistrez le fichier sous stocke_variable_globale, puis transférez le vers la carte Arduino,
  • ouvrez le moniteur série et observez l'évolution des valeurs au fur et à mesure du déroulement du programme et de la fonction loop().

// La robotique avec le BOE Shield
// stocke_variable_globale

// déclaration des variables en global
int a;
int i;
char c;
float root2;

// initialisation    
void setup()
{
  Serial.begin(9600);
  i = 1;
  a = 42;
  c = 'm';
  root2 = sqrt(2.0);
  Serial.println("Affichage numero 1");
  Serial.println("Je suis dans la fonction setup");
  Serial.println(a);
  Serial.println(c);
  Serial.println(root2);
  Serial.println("Attente 3 secondes");
  delay(1000);
  Serial.print("* ");
  delay(1000);
  Serial.print("* ");
  delay(1000);
  Serial.println("*");
}

// boucle principale
void loop()
{
  Serial.println("je suis dans la fonction loop");
  Serial.println(a);
  Serial.println(c);
  Serial.println(root2);
  Serial.println("Attente 1 seconde");
  delay(1000);
}

La fonction loop() répète l'affichage des valeurs initialisées dans setup() contenues dans les variables globales déclarées tout au début du programme. Pour mieux visualiser les effets, le premier affichage affiche les valeurs initialisées dans la fonction setup() pendant 3 secondes ; par la suite la fonction loop() répète l'affichage toutes les une seconde.
Démonstration et affichage des valeurs de variables déclarées globales

Types de variables supplémentaires

Il y a beaucoup plus de types de données que les simples int, char, float et byte.
Découvrez les par vous-même :

  • Ouvrez la référence du langage Arduino et consultez la liste des types de données,
  • suivez le lien float pour en savoir plus sur ce type de données,
  • le type de données "long" sera utilisé dans un chapitre ultérieur ; ouvrez en même temps les deux sections "long" et "int". En quoi sont-ils semblables ? En quoi sont-ils différents ?

Retourner au début de l'article

◄ Page précédente : Le premier programme : afficher bonjour

Page suivante : Résoudre des problèmes mathématiques ►

acces aux guides