LOCODUINO
Aide
Forum de discussion
Dépôt GIT Locoduino
Flux RSS
>>
vendredi 14 juin 2024
Visiteurs connectés : 12
Rubriques Accueil Atelier Matériel Programmation Bibliothèques Projets Plan du site
Répéter des instructions : les boucles
Le 12 décembre 2014.
Par : Jean-Luc
DIFFICULTÉ :
Nous allons ajouter une nouvelle corde à notre arc avec les boucles. Une boucle permet
d’exécuter de manière répétitive une ou plusieurs instructions. Un premier usage auquel
nous pouvons penser est de lire plusieurs capteurs de même nature pour effectuer en
conséquence plusieurs actions de même nature. Par exemple supposons que vous vouliez
gérer 5 ou 6 ILS avec un Arduino, il est plus concis et plus clair de le faire avec une boucle
que de répliquer les instructions pour chacun des ILS.
<
SOMMAIRE
La boucle while ( ... ) { ... }
La boucle do { ... } while (condition);
La boucle for ( ... ; ... ; ... ) { ... }
Le langage permettant de programmer l’Arduino offre 3 types de boucles qui ont chacune
un usage.
La boucle while ( ... ) { ... }
La boucle permet de répéter des instructions tant qu’une condition est vraie. Si vous ne
savez pas ce qu’est une condition dans le langage de l’Arduino, faites un tour dans l’article
« Instructions conditionnelles : le if ... else », vous y trouverez toutes les explications
nécessaires.
La syntaxe de la boucle while est la suivante :
while (condition) {
// à remplacer par les instructions qui seront
// exécutées tant que la condition est vraie
}
La boucle suivante est celle utilisée pour mettre en œuvre des boucle infinies, celles qui
répètent les instructions sans jamais s’arrêter :
while (true) {
// instructions exécutées à l'infini
}
Si la boucle n’est pas infinie, la condition est soit issue de l’extérieur de l’Arduino, soit
remise à jour par les instructions que la boucle répète. Sinon elle ne peut pas changer. Ainsi
si l’on veut compter combien de temps, en dizaines de millisecondes, la broche 4, configurée
en entrée numérique, de l’Arduino est HIGH [1], on pourra écrire :
void loop() {
unsigned long dureePression = 0; // variable pour compter la durée
while (digitalRead(4) == HIGH) {
dureePression++;
delay(10);
}
[Link](dureePression);
}
Si le signal sur la broche 4 n’est pas HIGH Au moment du digitalRead, les deux instructions
qui sont dans la boucle ne seront pas exécutées et dureePression restera à 0. Si le signal est
HIGH au moment de l’exécution du digitalRead, dureePression sera incrémenté puis après
10ms le signal sera de nouveau testé et ainsi de suite. On voit également que la durée sera
comptée de manière optimiste. Pour une durée inférieure à 10ms on retrouvera 1 dans
dureePression, pour une durée comprise entre 10ms et 20ms, on retrouvera 2, etc.
Incrémenter consiste à ajouter quelque chose à une variable, généralement 1.
Décrémenter est l’action inverse. Pour incrémenter dans le langage Arduino, on
peut écrire dureePression = dureePression + 1; ou dureePression++;. -- est
l’opérateur de décrémentation.
La boucle do { ... } while (condition);
On a vu dans la boucle while (...) { ... } que si la condition était fausse, les instructions
de la boucle ne sont pas exécutées. Parfois, il est nécessaire de faire des calculs pour
déterminer la condition. Avec la boucle while (...) { ... } que nous venons de voir, il
faudrait calculer une première fois la condition avant la boucle puis une seconde fois,
répétitivement, dans la condition de la boucle. Pour éviter la duplication du code de calcul
de la condition, il existe un autre type de boucle.
Dans la boucle do { ... } while ( ... ); la condition est testée à la fin de la boucle au lieu
d’être testée au début. Les instructions de la boucle sont donc exécutées au moins une fois.
La syntaxe est la suivante :
do {
// instructions de la boucle
} while (condition);
Notez le point-virgule obligatoire à la fin du while...
La boucle for ( ... ; ... ; ... ) { ... }
La boucle for ( ... ; ... ; ... ) { ... } permet de répéter une séquence d’instructions
avec une séquence d’initialisation exécutée avant la boucle, une condition de continuation
et une séquence exécutée à la fin des instructions de la boucle.
La syntaxe est la suivante :
for ( initialisation ; condition ; incrementation ) {
// instructions de la boucle
}
Habituellement, l’initialisation consiste à mettre une variable, que l’on appelle compteur de
boucle à 0 ; la condition consiste à tester cette variable par rapport à une valeur où la
boucle doit s’arrêter ; l’incrémentation consiste à incrémenter cette variable. On trouve
donc le plus souvent cette boucle sous cette forme par exemple :
for ( int i = 0 ; i < 10 ; i++ ) {
[Link](i);
}
Dans l’ordre d’exécution,, la variable i est déclarée et initialisée à 0. Puis, de manière
répétitive, i est comparé à 10 et si il est strictement inférieur, [Link](i); est exécuté
puis i est incrémenté. Si i est supérieur ou égal à 10, l’exécution du programme continue
après la boucle.
La condition étant évaluée avant l’exécution les instructions de la boucle, ces dernières ne
sont jamais exécutées si la condition est fausse dès la première évaluation de la condition.
Vous rencontrerez parfois des boucles for où l’initialisation, la condition et l’incrémentation
sont vides, comme ceci :
for (;;) {
// instructions de la boucle
}
Cette syntaxe particulière permet, comme le while (true) { ... } que nous avons vu plus
haut de mettre en œuvre des boucles infinies.
C’est très exactement de cette manière que le logiciel de base de l’Arduino appelle la
fonction loop() répétitivement.
Si ce n’est pas déjà fait, lisez également « La programmation, qu’est ce que c’est », « Types,
constantes et variables », « Instructions conditionnelles : le if ... else » et « Calculer avec
l’Arduino (1) »
[1] Il peut s’agir d’un capteur de présence et cette durée peut renseigner sur la vitesse d’un
train par exemple
7 Messages
Répéter des instructions : les boucles 19 février 2017 20:56, par peter
bonjour , ton article est super mais je n’ai as trouver ce que je rechercher :
il me faudrait une boucle qui se répète a l’infini mais qui peut être interrompu a
n’importe quel moment...
je suis sur une lampe qui diffuse de la lumiere avec des led et une télécommande .
quand j’appuie sur la touche 1 ,ça fait du bleu,2 du rouge...ect .Le problème surviens
lorsque je veut qu’il fasse toute les couleurs les une après les autre a l’infini,il ne fait
plus les couleurs une par une si j’appuie sur la touche 1,2...ect.
Répondre
Répéter des instructions : les boucles 19 février 2017 21:19, par Jean-Luc
Bonsoir,
pour sortir d’une boucle quelle qu’elle soit, il faut utiliser l’instruction break.
Répondre
Sortir d’une boucle 13 mars 2017 11:04, par bartolo
Je sais allumer éteindre une led, j’ai même fait un feux tricolore jaune,
rouge , vert et jaune mais je ne sais pas ou mètre la fonction pour l’arrêter, il
y a pleins d’explications sympa merci
Mais serait ’il possible d’avoir un prog qui allume une led 2 fois ou plus et
qui s’arrête
Merci pour un nul de 71 ans
Répondre
Sortir d’une boucle 13 mars 2017 11:56, par Dominique
Comme vous insistez, je vous renvoie vers la presse spécialisée pour
débutants :
[Link]
Débutez ici, par exemple
Si vous n’arrivez pas à faire cela par vous même, alors ce n’est pas la
peine de continuer.
Un petit effort ne fait pas de mal, même à 71 ans, à moins que ce soit
une blague !
Répondre
Répéter des instructions : les boucles 20 février 2017 15:35, par Dominique
Bonjour,
Dans un programme Arduino, la moindre faute d’orthographe ou de syntaxe a
pour conséquence une erreur de compilation qui stoppe le développement.
Jean-Luc est gentil de vous donner la bonne réponse ! Avec plus de 20 fautes dans
6 lignes et demi, le compilateur vous aurait répondu "ERREUR". A vous de
corriger !
Alors, si vous êtes capable de faire 0 faute dans vos programmes, pourquoi ne pas
en faire autant sur ce site : c’est une question de respect.
Vous seriez étranger, on comprendrait mais là, ce n’est pas le cas.
Désolé de l’avertissement.
Répondre
Répéter des instructions : les boucles 17 août 2020 17:46, par grace
salut. Svp je veux que tout mon programme s’arrete lorsqu’une condition n’est pas
respecter . Que dois je faire svp
Répondre
Répéter des instructions : les boucles 18 août 2020 18:00, par msport
if (!condition)
{ while(1);
}
Répondre
Réagissez à « Répéter des instructions : les boucles »
Aide : Enrichissement typographiques dans les commentaires
Qui êtes-vous ?
Votre nom
Votre adresse email
Votre message
Titre (obligatoire) Répéter des instructions : les boucles
Texte de votre message (obligatoire)
Pour créer des paragraphes, laissez simplement des lignes vides.
Lien hypertexte
(Si votre message se réfère à un article publié sur le Web, ou à une page fournissant
plus d’informations, vous pouvez indiquer ci-après le titre de la page et son adresse.)
Titre
Lien hypertexte https://
Prévisualiser
Rubrique « Programmation »
Le monde des objets (1)
Le monde des objets (2)
Le monde des objets (3)
Le monde des objets (4)
Les pointeurs (1)
Les pointeurs (2)
Les Timers (I)
Les Timers (II)
Les Timers (III)
Les Timers (IV)
Les Timers (V)
Bien utiliser l’IDE d’Arduino (1)
Bien utiliser l’IDE d’Arduino (2)
Piloter son Arduino avec son navigateur web et [Link] (1)
Piloter son Arduino avec son navigateur web et [Link] (2)
Piloter son Arduino avec son navigateur web et [Link] (3)
Piloter son Arduino avec son navigateur web et [Link] (4)
Démarrer en Processing (1)
L’assembleur (9)
Comment gérer le temps dans un programme ?
L’assembleur (8)
Processing pour nos trains
L’assembleur (7)
L’assembleur (6)
Arduino : toute première fois !
TCOs en Processing (1)
L’assembleur (5)
L’assembleur (4)
L’assembleur (3)
L’assembleur (2)
L’assembleur (1)
TCOs en Processing (2)
Calculer avec l’Arduino (1)
La programmation, qu’est ce que c’est
Types, constantes et variables
Installation de l’IDE Arduino
Répéter des instructions : les boucles
Les interruptions (1)
Instructions conditionnelles : le if ... else
Instructions conditionnelles : le switch ... case
Comment concevoir rationnellement votre système
Comment gérer l’aléatoire ?
Trucs, astuces et choses à ne pas faire !
Calculer avec l’Arduino (2)
Les structures
Systèmes de numération
Les fonctions
Trois façons de déclarer des constantes
Transcription d’un programme simple en programmation objet
Ces tableaux qui peuvent nous simplifier le développement Arduino
Les chaînes de caractères
Les derniers articles
L’assembleur (9)
27 septembre 2021
Christian
L’assembleur (8)
21 mars 2021
Christian
L’assembleur (7)
14 mars 2021
Christian
L’assembleur (6)
7 mars 2021
Christian
L’assembleur (5)
1er mars 2021
Christian
L’assembleur (4)
21 février 2021
Christian
L’assembleur (3)
14 février 2021
Christian
L’assembleur (2)
31 janvier 2021
Christian
L’assembleur (1)
24 janvier 2021
Christian
TCOs en Processing (2)
14 octobre 2018
Pierre59
Les articles les plus lus
Les Timers (I)
Les interruptions (1)
Instructions conditionnelles : le if ... else
Ces tableaux qui peuvent nous simplifier le développement Arduino
Comment gérer le temps dans un programme ?
Calculer avec l’Arduino (1)
Instructions conditionnelles : le switch ... case
Calculer avec l’Arduino (2)
Les chaînes de caractères
Bien utiliser l’IDE d’Arduino (1)
A propos de LOCODUINO
LOCODUINO a pour objectif de montrer tout ce que l’on peut faire en DIY avec un Arduino
en modélisme ferroviaire. LOCODUINO c’est d’abord un site communautaire où vous
trouverez des articles consacrés à l’emploi de l’Arduino en modélisme ferroviaire mais
aussi des articles pédagogiques sur les connaissances de base nécessaires : de l’électronique
simple et de la programmation. [En savoir plus] [Mentions légales]
