Séance du 25 Octobre 2013

Arduino leçon 2 : la boucle for ()

Nous allons voir la fonction for() pour allumer successivement plusieurs leds.
Nous aborderons en même temps les tableaux (en anglais array[]).

Exemple de programme rudimentaire

Nous allons écrire un programme pour allumer successivement 4 LEDs.
Les anodes sont reliées aux pins 2, 9, 3, 5 d'Arduino, les cathodes à la masse via une résistance.
Je fais exprès de vous donner des numéros qui ne sont ni consécutifs ni croissants.

fonctions à utiliser

dans le setup :
- on déclare les 4 broches en sortie.
dans la boucle :
- on allume la première,
- on attend 1 seconde,
- on éteint la première et on allume la deuxième,
- et on continue jusqu'à la dernière.

le programme chenille_1

void setup {
pinMode(2, OUTPUT);
pinMode(3, OUTPUT);
pinMode(9, OUTPUT);
pinMode(5, OUTPUT);
}

void loop {
digitalWrite(2, HIGH);
delay (1000);
digitalWrite(2, LOW);
digitalWrite(9, HIGH);
delay (1000);
digitalWrite(9, LOW);
digitalWrite(5, HIGH);
delay (1000);
digitalWrite(5, LOW);
digitalWrite(3, HIGH);
delay (1000);
digitalWrite(3, LOW);
}

1ère amélioration : utilisation d'un tableau

Imaginez qu'au lieu de 4 diodes on en utilise 54 pour utiliser toutes les broches d'Arduino.
La programme serait d'une longueur pénible.

On va étudier une méthode plus efficace. On définit un tableau qui contiendra les numéros des pins utilisées.
On le parcourera avec une boucle for().

La boucle for

On peut considérer "for" comme une fonction recevant 3 paramètres, même si ce n'est pas la vérité puisque ses paramètres sont séparés par des points-virgules alors que ceux d'une vraie fonction le sont par des virgules simples.

for ( paramètre1 ; paramètre 2 ; paramètre 3) {
traitement de la boucle;
}
paramètre 1 est l'état de départ
paramètre 2 est la condition pour continuer à boucler
paramètre 3 est ce qu'on fait à chaque appel de la boucle.

Les tableaux

Les tableaux sont des ensembles de variables de même catégorie (des int, des longs...)
leur déclaration réserve leur place en mémoire
on peut leur donner une valeur en les déclarant ou plus tard.
exemples :
int truc[4] ; // réserve la place en mémoire pour 4 int.
int machin[] = {14, 26, 9} ; // réserve 3 places en mémoire et y loge 3 valeurs.

Les comparaisons

Les comparaisons de 2 valeurs s'écrivent ainsi
< plus petit
<= plus petit ou égal
> plus grand
>= plus grand ou égal
== égal
!= différent de

ne pas confondre la comparaison '==' avec la copie d'une valeur '='.
a=5 // on met '5' dans la variable a
a==5 // on regarde si a vaut 5

// déclarations
int tablo[] = {2, 9, 3, 5, 2}; // noter l'élément ajouté à la fin
int i ;

void setup() {
for ( i=0 ; i<4 ; i=i+1) {
pinMode(tablo[i], OUTPUT);
}

Regardez bien comme on va chercher les éléments du tableau.
- tablo[0] vaut 2
- tablo[1] vaut 9
- tablo[2] vaut 3
- tablo[3] vaut 5
- tablo[4] vaut 2
- tablo[5] provoquerait une erreur car le tableau contient 5 valeurs numérotées de 0 à 4 .

void loop() {
for ( i=0 ; i<5 ; i=i+1) {
digitalWrite(tablo[i], LOW);
digitalWrite(tablo[i+1], HIGH); // c'est pour que cette instruction fonctionne quand i vaut 4 que le tableau comporte 5 valeurs.
delay (1000);
}
}

Le programme chenille_2

// déclarations
int tablo[] = { 2, 9, 5, 3, 2 } ; // notez l'élément ajouté à la fin
int i ;

void setup {
for ( i=0 ; i<4 ; i++) {
pinMode(tablo[i], OUTPUT);
}
}

void loop {
for ( i=0 ; i<4 ; i++) {
digitalWrite(tablo[i], LOW);
digitalWrite(tablo[i+1], HIGH);
digitalWrite(9, HIGH);
delay (1000);
}
}

Ce programme fait exactement la même chose que le premier mais prend beaucoup moins de place en mémoire.
Il a encore un gros inconvénient : les délais à l'intérieur de la boucle.

Amélioration du programme

On va donc améliorer le programme en utilisant la fonction millis().
Cette fonction renvoie une valeur qui est un grand nombre, trop grand pour tenir dans un octet. On demande à Arduino de réserver 4 octets de mémoire pour ce nombre. C'est l'expression "unsigned long" qui l'indique. Ça permet de stocker un nombre pouvant aller jusqu'à 4,3 milliards. (2 puissance 32)
Pour info, ce nombre renvoyé par la fonction est le temps écoulé depuis le lancement du programme, en millisecondes.
Ce n'est pas un intervalle de temps très précis. On ne peut pas l'utiliser pour une horloge.

programme chenille_3

On déclare des variables et une fonction :
Dans le setup(), on note l'heure du prochain changement.
Dans la boucle, on regarde si 1000ms se sont écoulées depuis le dernier changement de led.
si OUI, on appelle changeLed() avant de continuer
si NON, on continue à boucler

unsigned long tpsProchain;
// pour stocker l'heure du prochain changement
int numPhase=1;
// pour se rappeler de la led allumée
void changeLed();
// on déclare une fonction qu'on écrira après
void setup() {
for ( i=0 ; i<9 ; i=i+1) {
pinMode(tablo[i], OUTPUT);
}
tpsProchain = millis() + 1000;
}
void loop() {
if (tpsProchain <= millis() {
changeLed();
}
}
void changeLed() {
digitalWrite(tablo[numPhase], HIGH);
digitalWrite(tablo[numPhase-1], LOW);
tempsProchain = tempsProchain + 1000;
numPhase = numPhase + 1 ;
if (numPhase==5) {
numPhase=1;
}
}

Modulo

Pour ceux qui se rappellent ce que signifie ce terme en mathématiques,
'a modulo b' s'écrit en langage Arduino 'a % b' ;
Vous pouvez essayer de l'utiliser à la place des 3 dernières lignes du programme.
Si vous n'y arrivez pas en moins de 10 mn, laissez tomber.

haut de la page

Page Précédente : entrées-sorties numériques Page Suivante : le moniteur série