Utilisation des tableaux: exemple arduino smoothing

Dans cet exemple arduino nous allons nous intéresser à ce type de variable particulier qu’est le tableau (array en anglais). Vous verrez rapidement que grâce aux tableaux (qui contiennent en réalité plusieurs variables) vous pourrez rendre la programmation de vos boucles bien plus performante.

Qu’est ce qu’un tableau?

Comme je l’ai dis dans l’introduction, un tableau est en réalité une variables contenant plusieurs variables. Prenons un exemple concret. Je fais de la domotique et j’ai quatre capteurs qui relèvent la température de mon salon, salle à manger, cuisine et chambre. Sans tableaux, si je souhaite lire ces températures, je déclarerai  quatre variables (probablement temperatureSalon, temperatureSalleAManger, temperatureCuisine, temperatureChambre) que je viendrez lire les une à la suite des autre.

Avec un tableau, il suffit de déclarer une seule variable avec, entre deux crochets, le nombre d’éléments que l’on souhaite stocker. Les températures étant de format integer, nous déclarerons donc:

int temperature[4];

Nous venons donc de déclarer un tableau qui sera composé dans quatre integer, et  cela dans une seule variable!

Dans quels cas utiliser un tableau?

Manier un tableau sous un arduino n’a rien de réellement compliqué. Maintenant que vous avez déclaré votre tableau, il faut le remplir, nous allons donc faire cela case par case (on parle d’index). Un tableau de quatre valeurs commence à l’index 0 et fini à l’index 3!

Dans le programme nous allons donc taper:

temperature[0] = capteurSalon;

temperature[1] = capteurSalleAMagner;

temperature[2] = capteurCuisine;

temperature[3] = capteurChambre;

Dans le programme, il ne nous reste plus qu’à faire une boucle (FOR par exemple) qui va de 0 à 3 pour afficher toutes nos températures (petit rappel sur les boucles FOR à ce lien).

for (int indexTableau = 0 ; indexTableau <= 3; indexTableau += 1) {
Serial.println(temperature[indexTableau ]);
}

Les tableaux et l’exemple arduino Smoothing.

Dans Arduino IDE 1.6.7, l’exemple smoothing se trouve dans Fichier / Exemples / 03.Analog / Smoothing.

Et voici le programme en question:

/*

Smoothing

Reads repeatedly from an analog input, calculating a running average
and printing it to the computer. Keeps ten readings in an array and
continually averages them.

The circuit:
* Analog sensor (potentiometer will do) attached to analog input 0

Created 22 April 2007
By David A. Mellis <dam@mellis.org>
modified 9 Apr 2012
by Tom Igoe
http://www.arduino.cc/en/Tutorial/Smoothing

This example code is in the public domain.


*/


// Define the number of samples to keep track of. The higher the number,
// the more the readings will be smoothed, but the slower the output will
// respond to the input. Using a constant rather than a normal variable lets
// use this value to determine the size of the readings array.
const int numReadings = 10;

int readings[numReadings]; // the readings from the analog input
int readIndex = 0; // the index of the current reading
int total = 0; // the running total
int average = 0; // the average

int inputPin = A0;

void setup() {
// initialize serial communication with computer:
Serial.begin(9600);
// initialize all the readings to 0:
for (int thisReading = 0; thisReading < numReadings; thisReading++) {
readings[thisReading] = 0;
}
}

void loop() {
// subtract the last reading:
total = total - readings[readIndex];
// read from the sensor:
readings[readIndex] = analogRead(inputPin);
// add the reading to the total:
total = total + readings[readIndex];
// advance to the next position in the array:
readIndex = readIndex + 1;

// if we're at the end of the array...
if (readIndex >= numReadings) {
// ...wrap around to the beginning:
readIndex = 0;
}

// calculate the average:
average = total / numReadings;
// send it to the computer as ASCII digits
Serial.println(average);
delay(1); // delay in between reads for stability
}

Ligne 1 à 21: On commence comme d’habitude par un gros pavé de commentaires.

Ligne 28: On déclare dans un integer constant nommé numReading  la taille du tableau. Ici 10.

Ligne 30: On déclare notre tableau d’intéger reading d’un longueur égale à numReading (donc 10).

Ligne 31: readIndex nous servira à evoluer de 0 à 9 pour lire chaque valeur du tableau.

Ligne 32: total contiendra la somme de toutes les valeurs du tableau.

Ligne 33: average sera la valeur moyenne du tableau (total / numReading).

Ligne 37 à 44: Fonction setup qui initialise une communication serie à 9600 et initialise la tableau (on y revient tout de suite…)

Ligne 40 à 43: Essayez de comprendre par vous même ce passage (même si les commentaires devraient vous mettre la puce à l’oreille). Cette boucle FOR sert à initialiser les valeurs du tableau à 0.

Ligne 46 à 67: Fonction principale loop().

Ligne 48: On retire de total la valeur actuellement indexée du tableau (afin de faire de la place pour la nouvelle).

Ligne 50: On vient stocker la valeur du potentiomètre dans l’index en cours du tableau.

Ligne 52: On ajout la valeur au total.

Ligne 54: On augmente l’index de 1 afin de passage à la « case suivante » du tableau.

Ligne 57 à 60: Si l’index dépace 9, alors on le remet à 0. Rappelez vous que le tableau évolue de reading[0] à reading[9].

Ligne 63: On calcul la valeur moyenne du tableau reading[].

Ligne 65: On envoit la moyenne au moniteur série.

Liens internes:

Tutoriel sur les boucles FOR.

IPA04 – les tableaux et les boucles.

Liens externes:

Article wikipedia.

Les tableaux, site officiel arduino.