Boucles Arduino. Boucles FOR et WHILE dans Arduino Boucles imbriquées dans Arduino

• pendant que(condition) ()

• faire() pendant que(condition);

• pour (variable de nombre; condition; augmenter la variable de nombre) ()

Chaque langage de programmation possède un ensemble d'instructions de contrôle qui permettent d'exécuter le même code de manière répétée (une boucle), la sélection d'un morceau de code approprié (conditions) et des instructions pour quitter le morceau de code en cours.

L'IDE Arduino emprunte la plupart des contrôles nécessaires au C/C++. Leur syntaxe est identique à celle du C. Ci-dessous, nous décrirons brièvement leur syntaxe.

si déclaration

L'instruction if vous permet d'exécuter un fragment spécifique d'un programme en fonction du résultat de la vérification d'une certaine condition. Si la condition est remplie, alors le code du programme sera exécuté, mais si la condition n'est pas remplie, le code du programme sera ignoré. La syntaxe de la commande if est la suivante :

Si(condition) ( instruction1; instruction2; )

La condition peut être n'importe quelle comparaison d'une variable ou d'une valeur renvoyée par une fonction. Le critère principal pour une condition if est que la réponse doit toujours être vraie ou fausse. Exemples de conditions pour une instruction if :

Si(a!=2) ( ) si(x<10) { } if(znak==’B’) { }

À l’intérieur des parenthèses écrites à l’intérieur de la condition, vous pouvez exécuter le code.

Les personnes qui commencent à apprendre la programmation commettent souvent l'erreur d'assimiler la valeur d'une variable spécifiée à l'aide d'un seul signe "=". Une telle notation indique clairement l'attribution d'une valeur variable et, par conséquent, la condition sera toujours « vraie », c'est-à-dire satisfaite. Tester qu'une variable est égale à une certaine valeur est toujours indiqué par un double signe égal (==).

Vous pouvez utiliser l'état de la fonction comme condition, par exemple :

Si(init()) ( Serial.print("ok"); )

L'exemple ci-dessus serait exécuté comme suit : Dans la première étape, la fonction init() est appelée. Cette fonction renvoie une valeur qui sera interprétée comme « vrai » ou « faux ». En fonction du résultat de la comparaison, un texte « ok » sera envoyé ou rien ne sera envoyé.

Si… sinon déclaration

Une instruction if étendue est l’instruction if….else. Il garantit qu'un morceau de code est exécuté lorsqu'une condition est vraie (vrai) et qu'un deuxième morceau de code est exécuté lorsque la condition n'est pas remplie (faux). La syntaxe de l'instruction f if….else est la suivante :

Si (condition) ( // commande A ) else ( // commande B )

Les commandes "A" ne seront exécutées que lorsque la condition est remplie, la commande "B" sera exécutée lorsque la condition n'est pas remplie. L'exécution simultanée des commandes « A » et « B » n'est pas possible. L'exemple suivant montre comment utiliser la syntaxe if...else :

If (init()) ( Serial.print("ok"); ) else ( Serial.print("error"); )

De cette manière, vous pouvez vérifier la bonne exécution de la fonction et en informer l'utilisateur.

Une pratique courante consiste à nier la condition. Cela est dû au fait qu'une fonction exécutée correctement renvoie la valeur 0 et qu'une fonction exécutée incorrectement pour une raison quelconque renvoie une valeur non nulle.

L’explication de cette « complication de la vie » est simple. Si la fonction est exécutée correctement, c'est la seule information dont nous avons besoin. En cas d'erreur, il est parfois utile de comprendre ce qui n'a pas fonctionné et pourquoi la fonction n'a pas été exécutée correctement. Et ici, des nombres autres que zéro viennent à la rescousse, c'est-à-dire à l'aide de codes numériques, nous pouvons déterminer le type d'erreur. Par exemple, 1 - un problème de lecture d'une valeur, 2 - il n'y a pas d'espace en mémoire ou sur le disque, etc.

Le dernier exemple modifié montre comment appeler une fonction qui renvoie zéro lorsqu'elle est exécutée correctement :

If (!init()) ( Serial.print("ok"); ) else ( Serial.print("error"); )

Instruction de changement de cas

L'instruction if vous permet de tester une seule condition. Parfois, il est nécessaire d'effectuer l'une des actions en fonction de la valeur renvoyée ou lue. L’opérateur à choix multiples Switch est idéal pour cela. La syntaxe de la commande switch est présentée ci-dessous :

Switch (var) ( cas 1 : //instruction pour var=1 break ; cas 2 : //instruction pour var=2 break ; par défaut : //instruction par défaut (si var est différent de 1 et 2) )

En fonction de la valeur de la variable var, des instructions dans des blocs spécifiques sont exécutées. L'étiquette du cas indique le début d'un bloc pour la valeur spécifiée. Par exemple, cas 1 : signifie que ce bloc sera exécuté pour la valeur de var égale à un.

Chaque bloc doit être terminé par une commande break. Il interrompt la poursuite de l'exécution de l'instruction switch. Si la commande break est ignorée, les instructions seront exécutées dans les blocs suivants avant la commande break. L'étiquette par défaut est facultative, tout comme le reste dans une instruction if. Les instructions situées dans le bloc par défaut ne sont exécutées que lorsque la valeur de la variable var ne correspond à aucun modèle.

Il arrive souvent que les mêmes instructions doivent être exécutées pour une valeur parmi plusieurs. Ceci peut être réalisé comme suit :

Switch (x) ( cas 1 : //instruction pour x=1 pause ; cas 2 : cas 3 : cas 5 : //instruction pour x=2 ou 3 ou 4 pause ; cas 4 : //instruction pour x=4 pause ; cas 6 : // instruction pour x=6 break; default : // instruction par défaut (si x est différent de 1,2,3,4,5,6) )

En fonction de la valeur de la variable x, le bloc d'instructions correspondant sera exécuté. Répétition du cas 2 : cas 3 : cas 5 : informe le compilateur que si la variable x a la valeur 2 ou 3 ou 5, alors le même morceau de code sera exécuté.

pour déclaration

L'instruction for est utilisée pour exécuter le même code encore et encore. Il est souvent nécessaire d'exécuter les mêmes instructions, en modifiant uniquement la valeur d'une variable. Une boucle for est idéale pour cela. La syntaxe de la commande est la suivante :

Int je; pour(i=0;i<10;i++) { // инструкции для выполнения в цикле }

Le premier paramètre donné dans une instruction for est la valeur initiale de la variable. Un autre élément vérifie la condition de poursuite de l'exécution de la boucle. La boucle s'exécute tant que la condition est remplie. Le dernier élément est le changement de la valeur de la variable. Le plus souvent, nous augmentons ou diminuons sa valeur (si nécessaire). Dans cet exemple, les instructions contenues dans la boucle seront exécutées à i=0...9.

Souvent une variable utilisée dans une boucle y est déclarée :

Pour(int i=0;i<10;i++) { // инструкции для выполнения в цикле }

Une variable utilisée pour compter les étapes suivantes de la boucle peut être utilisée pour appeler une fonction avec les paramètres appropriés.

For(int i=10;i>0;i—) ( Serial.print(i); // les numéros 10,9,8,7,6,5,4,3,2,1 seront envoyés)

tandis que l'instruction

La boucle for est idéale là où nous voulons faire un décompte. Dans une situation où nous devons effectuer certaines actions à la suite d'un événement qui n'est pas nécessairement prévisible (par exemple, nous attendons qu'un bouton soit enfoncé), nous pouvons alors utiliser l'instruction while, qui exécute le bloc d'instructions comme tant que la condition est remplie. La syntaxe de l'instruction while est la suivante :

While(condition) ( // bloc d'instructions à exécuter)

Il est important que la vérification de l'état ait lieu au début du cycle. Il peut arriver que les instructions contenues dans la boucle while ne soient jamais exécutées. Il est également possible de créer une boucle infinie. Regardons deux exemples :

Int x=2 ; while(x>5) ( Serial.print(x); ) —————————————- int y=5; while(y>0) ( Serial.print(y); )

Le premier bloc d'instructions situé à l'intérieur de while ne sera jamais exécuté. La variable x a une valeur de deux et elle ne deviendra pas supérieure à 5. Dans le deuxième exemple nous avons affaire à une boucle infinie. La variable « y » a une valeur de 5, c'est à dire supérieure à zéro. Il n'y a aucun changement dans la variable "y" à l'intérieur de la boucle, donc la boucle ne se terminera jamais.

C'est une erreur courante lorsque nous oublions de modifier un paramètre qui provoque la fin de la boucle. Vous trouverez ci-dessous deux exemples corrects d’utilisation d’une boucle while :

Int x=0 ; pendant que(x<10) { //блок инструкций x++; } —————————————- while(true) { if(условие) break; // блок инструкций }

Dans le premier exemple, nous avons pris soin de changer la valeur de la variable vérifiée dans la condition. En conséquence, le cycle finira par prendre fin. Dans le deuxième exemple, une boucle infinie a été créée intentionnellement. Cette boucle est équivalente à la fonction loop() de l'IDE Arduino. De plus, un contrôle de condition a été introduit à l'intérieur de la boucle, après quoi la boucle se termine par la commande break.

faire… tandis que la déclaration

Une variante de la boucle while est la boucle do...while. Outre la syntaxe, elle diffère par l'endroit où la condition est vérifiée. Dans le cas de do... while, la condition est vérifiée après l'exécution du bloc d'instructions. Cela signifie que le bloc d’instructions présent dans le corps de la boucle sera exécuté au moins une fois. Vous trouverez ci-dessous la syntaxe de la commande do... while :

Do ( // bloc d'instructions ) while (condition)

Tout ce qui est écrit sur l'opérateur while s'applique également à do... while. Vous trouverez ci-dessous un exemple d'utilisation d'une boucle do...while :

Int x=10 ; do ( // bloc d'instructions x—; ) while(x>0); —————————————- do ( // bloc d'instructions if (condition) break; ) while(true);

instruction de pause

L'instruction break vous permet de quitter la boucle (do... while, for, while) et de quitter l'option switch. Dans l'exemple suivant, considérons l'exécution de la commande break :

Pour(i=0;i<10;i++) { if(i==5) break; Serial.print(i); }

La boucle doit être exécutée pour les nombres 0 à 9, mais pour le nombre 5, une condition est remplie qui déclenche l'instruction break. Cela quittera la boucle. De ce fait, seuls les chiffres 0,1,2,3,4 seront envoyés sur le port série (Serial.print).

Continuer l'opérateur

L'opérateur continue entraîne l'arrêt de l'exécution des instructions de boucle (do... while, for, while) pour la valeur actuelle et passe à l'étape de boucle suivante. L'exemple suivant montre comment fonctionne l'instruction continue :

Pour(i=0;i<10;i++) { if(i==5) continue; Serial.print(i); }

Comme il n'est pas difficile de le remarquer, la boucle sera exécutée pour les valeurs de 0 à 9. Pour la valeur 5, la commande continue sera exécutée, de sorte que les instructions après cette commande ne seront pas exécutées. En conséquence, les nombres 0,1,2,3,4,6,7,8,9 seront envoyés au port série (Serial.print).

déclaration de retour

L'instruction return termine l'exécution de la fonction appelée et renvoie une valeur d'un type spécifique. Vous pouvez spécifier un nombre, un symbole ou une variable d'un type spécifique comme paramètre de commande. Il est important que la valeur de retour corresponde au type de la fonction déclarée. L'exemple suivant montre comment utiliser l'instruction return :

Int checkSensor())( if (analogRead(0) > 400) ( // la lecture de l'entrée analogique renvoie 1; // Pour les valeurs supérieures à 400, 1 est renvoyé else( return 0; // pour les autres, 0 est revenu) )

Comme vous pouvez le voir, vous pouvez utiliser plusieurs instructions return dans une seule fonction, mais une seule d'entre elles fonctionnera toujours. Il est acceptable d'utiliser l'opérateur de retour sans paramètres. Cela vous permet de terminer prématurément une fonction qui ne renvoie aucune valeur.

Void nom_fonction() ( instruction1; if(x==0) return; instruction2; instruction3; )

Dans l'exemple ci-dessus, instruction1 s'exécutera chaque fois que la fonction est appelée. L'exécution de l'instruction2 et de l'instruction3 dépend du résultat de la commande if. Si la condition est vraie (true), la commande return sera exécutée et la fonction se terminera.

Dans le cas où la condition n'est pas remplie, la commande de retour n'est pas non plus exécutée, mais les instructions instruction2 et instruction3 sont exécutées, puis la fonction termine son travail.

aller à la déclaration

Pour des raisons idéologiques, il est nécessaire de sauter cette description... L'instruction goto est une commande qui ne doit pas être utilisée en programmation normale. Cela entraîne une complexité du code et constitue une mauvaise habitude de programmation. Nous vous déconseillons fortement d'utiliser cette commande dans vos programmes. Puisque goto est inclus dans la documentation officielle sur le site arduino.cc, en voici une brève description. syntaxe de la commande goto :

…. allez marquer; // va à la ligne intitulée 'metka' ..... .... …. metka: // label avec lequel le programme continuera à fonctionner...

La commande permet d'aller à l'endroit désigné, c'est à dire à un endroit du programme.

Boucles utilisant des instructions pour Et alors que sont l’une des constructions les plus importantes du langage C++ qui sous-tend Arduino. On les retrouve dans absolument tous les sketchs, même si vous ne le savez pas. Dans cet article, nous examinerons de plus près les boucles, découvrirons quelle est la différence entre for et while, comment vous pouvez simplifier l'écriture d'un programme avec leur aide et quelles erreurs doivent être évitées.

Si vous êtes encore un programmeur novice et que vous souhaitez comprendre ce qu'est une boucle et pourquoi elle est nécessaire, consultez la section suivante de cet article avec une description détaillée.

L'opérateur WHILE est utilisé en C++ et Arduino pour répéter les mêmes commandes un nombre arbitraire de fois. Comparée à la boucle FOR, la boucle WHILE semble plus simple ; elle est généralement utilisée lorsque nous n'avons pas besoin de compter le nombre d'itérations dans une variable, mais simplement de répéter le code jusqu'à ce que quelque chose change ou qu'un événement se produise.

Syntaxe WHILE

alors que(<условие или список условий>)
{
<программный блок, который будет повторяться>
}

Toute construction de langage qui renvoie une valeur booléenne peut être utilisée comme conditions. Les conditions peuvent être des opérations de comparaison, des fonctions, des constantes, des variables. Comme pour toute autre opération logique dans Arduino, toute valeur autre que zéro sera perçue comme vraie, zéro – fausse.

// Une boucle sans fin while(true)( Serial.println("Waiting..."); ) // Une boucle qui s'exécute jusqu'à ce que la valeur de la fonction checkSignal() change while(!checkSignal())( Serial.println ("En attendant..."); )

Notez que l'instruction while peut être utilisée sans bloquer le bloc avec des accolades, auquel cas la première commande rencontrée après la boucle sera répétée. Il est fortement déconseillé de l'utiliser sans accolades, car dans ce cas, il est très facile de se tromper. Exemple:

While(true) Serial.print("En attente d'interruption"); retard (1000);

Dans ce cas, l'inscription sera affichée dans une boucle sans fin sans pause, car la commande delay(1000) ne sera pas répétée. Vous pouvez passer beaucoup de temps à détecter de telles erreurs - il est beaucoup plus facile d'utiliser une accolade.

Exemple d'utilisation d'une boucle while

Le plus souvent, while est utilisé pour attendre un événement. Par exemple, la préparation de l'objet Serial au travail.

Série.begin(9600); while (!Serial) ( ; // Certaines cartes Arduino nécessitent d'attendre que le port série soit libre)

Un exemple d'attente d'un personnage provenant d'appareils externes via UART :

While(Serial.available())( int byteInput = Seria.read(); // Quelques autres actions)

Dans ce cas, nous lirons les valeurs tant que Serial.available() renvoie une valeur non nulle. Une fois que toutes les données du tampon sont épuisées, la boucle s'arrêtera.

Boucle FOR dans Arduino

Dans la boucle FOR, nous avons la possibilité non seulement de définir des conditions aux limites, mais aussi de définir immédiatement une variable pour le compteur et d'indiquer comment ses valeurs changeront à chaque itération.

Syntaxe de la boucle FOR

Ici, la conception sera un peu plus compliquée :
pour (<начальное значение счетчика>;<условие продолжения выполнения цикла>;<изменение значения счетчика на каждом шаге>){
<список_команд>
}

L'exemple le plus simple :

Pour(int i=5;i<10;i++){ // Конструкция «3 в одном» pinMode(i, OUTPUT); }

Nous avons immédiatement créé une variable, l'avons initialisée et indiqué qu'à la fin de chaque cycle, la valeur du compteur devait être augmentée de un. Et c'est tout - vous pouvez maintenant utiliser la variable à l'intérieur de la boucle.

Le pas variable peut être différent. Voici des exemples :

• pour (int je = 0; je<10; i=i+2) // Шаг 2
• pour (int je = 0; je<10; i+=2) // Аналогичен предыдущему
• for(int i=10; i>0; i–) // Revenir en arrière – de 10 à 1

faire une boucle while

Dans certains cas, nous devons organiser la boucle de manière à ce que les instructions du bloc soient exécutées au moins une fois, puis la vérification est effectuée. Pour de tels algorithmes, vous pouvez utiliser la construction do while. Exemple:

Faire ( Serial.println("Working"); ) while (checkSomething());

Cette version de la boucle ne présente aucune difficulté - nous avons simplement déplacé le bloc avec les conditions vers le bas, donc tout le contenu entre accolades après l'opérateur do sera exécuté avant la première vérification.

Continuer et interrompre les instructions

Il existe des situations où vous devez interrompre de manière urgente l'exécution d'une boucle à l'intérieur d'un bloc de boucle, sans attendre de passer au bloc de vérification de condition. Pour ce faire, vous pouvez utiliser l'opérateur casser:

Tandis que (true) ( ​​​​if (checkSomething()) ( break; ) )

Si nous voulons simplement arrêter la progression de l'itération en cours, mais ne pas quitter la boucle, mais accéder au bloc de vérification de condition, alors nous devons utiliser l'opérateur continuer:

Tandis que (true) ( ​​​​if (checkSomething()) ( continue; ) )

Les instructions continue et break peuvent être utilisées avec toutes les variantes des boucles FOR et WHILE.

Boucles imbriquées dans Arduino

Toutes les variantes de boucles peuvent être facilement combinées les unes avec les autres, créant ainsi des structures imbriquées. Les variables définies dans le bloc de la boucle « sus-jacente » seront disponibles dans la boucle interne. L’exemple le plus courant de ce type de boucle est le parcours de tableaux à deux dimensions. Dans l'exemple suivant, nous utilisons une double boucle : la première parcourra les lignes (variable i), la seconde, imbriquée, parcourra les colonnes (variable j) du tableau, que nous avons défini dans la variable arr.

Int arr; void setup() ( pour (int i = 0; i< 10; i++) { for (int j = 0; j < 3; j++) { arr[i][j] = i * j; Serial.println(arr[i][j]); } } }

En savoir plus sur les cycles

Si vous n'avez jamais travaillé avec des boucles, plongeons un peu dans le monde de la théorie et découvrons ce que sont les boucles et pourquoi nous avons besoin de ces mystérieuses constructions de langage.

Pourquoi avons-nous besoin d’une boucle ?

En fait, la tâche principale de la boucle est de répéter plusieurs fois les mêmes constructions de langage. Ce besoin se pose dans presque tous les programmes, et certainement pas un seul croquis Arduino ne peut se passer d'une boucle - la fonction loop() est également appelée dans une boucle infinie.

Regardons l'exemple suivant. Vous devez alimenter simultanément 5 LED connectées à la carte Arduino entre les broches 5 à 9. L’option la plus évidente serait de placer cinq instructions d’affilée :

digitalWrite(5, ÉLEVÉ);

digitalWrite(6, ÉLEVÉ);

digitalWrite(7, ÉLEVÉ);

digitalWrite(8, ÉLEVÉ);

digitalWrite(9, ÉLEVÉ);

Ignorons pour l’instant le caractère risqué d’une telle action, car l’inclusion simultanée d’un tel nombre de LED crée une charge accrue sur le circuit d’alimentation de la carte. L'essentiel pour nous maintenant est que nous avons créé cinq lignes de code, chacune différant des autres par un seul chiffre. Cette approche présente les inconvénients suivants :

• Pour tout changement, vous devrez apporter des modifications à plusieurs lignes simultanément. Par exemple, si nous devons commuter les LED sur les broches 2 à 6 ou couper la tension au lieu de l'allumer, nous devrons apporter 5 modifications au code. Que se passe-t-il s'il y a plus d'instructions et de modifications ?
• Un code volumineux avec un grand nombre d'instructions similaires est peu pratique et désagréable à lire. Cinq lignes identiques ne font pas très peur. Mais l'habitude du code sale finira par conduire à des dizaines et des centaines de pages supplémentaires dans la liste, ce qui vous découragera, vous et vos collègues.
• Dans le processus de « copier-coller » d'instructions presque identiques, vous pouvez facilement faire une erreur, par exemple en oubliant de changer le numéro de broche : digitalWrite(5, HIGH) ; digitalWrite(5, ÉLEVÉ);
• Vous pouvez facilement échouer un entretien dans n’importe quel éditeur de logiciels normal en montrant ce code à l’intervieweur.

De tout cela, nous pouvons conclure que la réutilisation répétée des mêmes cordes doit presque toujours être évitée et remplacée par des boucles. De plus, dans de nombreuses situations, il est impossible de se passer des cycles, rien ne peut les remplacer. Vous ne pouvez pas modifier le nombre de fois que le code est répété pendant l'exécution du programme. Par exemple, vous devez traiter chaque élément tableau de données, reçus de périphériques externes. Vous ne prédirez jamais la quantité de données qu'il y aura, combien de fois le traitement sera répété, et vous ne pourrez donc pas insérer le nombre d'instructions requis au moment de la rédaction de l'article.

Et ici, les cycles nous viennent en aide.

Règles de syntaxe

Boucle dans Arduino est un bloc de programme spécial qui sera appelé un certain nombre de fois lors de l'exécution du programme. Dans ce bloc, nous décrivons les commandes elles-mêmes qui seront appelées et les règles selon lesquelles le contrôleur déterminera combien de fois elles doivent être appelées.

Dans notre exemple ci-dessus, nous pourrions indiquer au contrôleur ce qui suit :

Répétez la commande digitalÉcrire 5 fois

Dans un monde idéal avec des programmeurs de robots, cela serait probablement suffisant, mais comme nous parlons à l'ordinateur en C++, nous devons traduire cette phrase dans ce langage :

Répétez la commande – vous devez utiliser des instructions spéciales qui indiquent au contrôleur que quelque chose d’intéressant est sur le point de commencer avec des boucles while ou for

écriture numérique – laissez-le tel quel, mais écrivez-le une fois et placez-le entre accolades. Que faire des numéros de broches - juste en dessous.

5 fois – utilisez pour cela un compteur, qui augmentera à chaque répétition. Au début (ou à la fin) d'un bloc, vous pouvez comparer la valeur de ce compteur à une valeur limite (en l'occurrence 5) à l'aide d'une opération de comparaison.

Regardons un exemple d'une telle commande de boucle « traduite » avec une instruction while :

Compteur int = 0 ; // Une variable qui stockera la valeur du compteur // Nous demandons au processeur de répéter la construction entre accolades jusqu'à ce que la condition entre parenthèses retourne vraie. // Dans notre cas, counter est notre compteur, 5 est la valeur limite, la condition est que la valeur du compteur soit inférieure à 5. // Mais nous pouvons spécifier des opérateurs logiques complètement différents while (counter< 5) { digitaWrite(5, HIGH); // Будем включать светодиод counter++; // Увеличиваем значение счетчика } // Дойдя до сюда, исполняющий процессор переместится в начало блока и опять займется проверкой условий. Если условия вернут истину, команды в блоке между { и } выполнятся еще раз. Если условие не выполнится - процессор переместится к концу блока и пойдет дальше. Этот цикл больше его не заинтересует.

Pour ceux qui ont remarqué une erreur dans le code donné, nous donnons un cinq et écrivons le bloc de boucle différemment :

Tandis que(compteur< 5) { // Вот теперь мы будем включать разные светодиоды, с 5 (0+5) по 9 (4+5) digitalWrite(counter + 5, HIGH); counter++; }

Le même résultat peut être obtenu en utilisant une boucle FOR :

Pour (compteur int =0 ; compteur<5; counter ++){ digitalWrite(counter+5, HIGH); }

Comme vous pouvez le voir, dans ce cas, nous plaçons immédiatement toutes les opérations nécessaires avec le compteur dans une seule instruction FOR - c'est beaucoup plus pratique si vous devez compter le montant requis.

Vous pouvez obtenir des informations détaillées sur les règles d'utilisation des boucles dans les sections correspondantes de cet article.

Conclusion

Dans cet article, nous avons examiné des constructions très importantes du langage Arduino : les boucles FOR et WHILE. Vous pouvez trouver ces opérateurs dans presque toutes les esquisses plus ou moins complexes, car sans boucles, de nombreuses opérations sur les données seraient impossibles. Il n'y a rien de compliqué dans la syntaxe des boucles - vous pouvez facilement vous y habituer et les utiliser activement dans vos projets.

Voyons comment fonctionnent les opérateurs de boucles for, while et do while dans l'IDE Arduino, comment utiliser correctement les boucles dans les croquis et quelles erreurs éviter. À l’aide d’exemples simples, nous montrerons comment arrêter une boucle ou passer d’une boucle à une autre. Afin de comprendre l'exactitude des cycles d'écriture, vous devez tout d'abord étudier les types et les propriétés des algorithmes en robotique.

Comment fonctionnent les boucles dans l'IDE Arduino

Toute boucle en C++ et dans le langage de programmation Arduino est une action qui est répétée plusieurs fois, voire un nombre infini de fois. Pas un seul programme pour le microcontrôleur Arduino n'est complet sans une boucle, par exemple, une boucle vide est appelée dans une boucle infinie. Il existe trois types d'opérateurs de boucle : for, while et do while - examinons chaque opérateur et voyons comment ils fonctionnent à l'aide d'exemples.

Le principe de fonctionnement de for et while peut être expliqué avec les exemples simples suivants. La boucle for est exécutée un nombre fini de fois (indiqué dans la condition de l'opérateur) ; elle est utilisée lorsque le programme, par exemple, nécessite que la LED clignote plusieurs fois. La boucle while peut s'exécuter sans fin, par exemple lorsque la LED de l'Arduino clignote jusqu'à ce que les données du capteur changent.

Description de la boucle for dans Arduino avec un exemple

La construction for dans Arduino est définie comme suit :

Une boucle for est utilisée pour répéter des commandes spécifiques entourées d’accolades. Ce cycle est adapté pour effectuer des actions répétitives.
À initialisation une variable est créée et une valeur initiale est attribuée.
DANS condition la valeur de la variable à laquelle la boucle sera exécutée est enregistrée.
DANS changement indique comment la variable changera à chaque étape de la boucle.

Dans l'exemple de croquis, une variable avec une valeur initiale est définie je = 0, la condition stipule que la boucle s'exécutera jusqu'à ce que la variable soit égale ou supérieure à cinq je<=5 . Le changement indique que la variable sera incrémentée de un à chaque étape de la boucle. Enfin, la boucle for se termine lorsque la variable est égale à cinq, donc la LED clignote cinq fois avant la fin de la boucle.

Le pas variable (changement) peut être n'importe quoi. S'il est nécessaire d'augmenter une variable de deux unités à la fois, alors la modification du compteur doit s'écrire comme suit : je = je + 2. La boucle for peut être utilisée dans la procédure de configuration void, par exemple, pour indiquer le mode de fonctionnement de plusieurs broches à la fois. Et aussi dans la procédure de boucle vide, par exemple, dans le programme d'allumage séquentiel des LED sur Arduino.

Description de la boucle while Arduino avec un exemple

La construction while dans Arduino est définie comme suit :

La boucle while s'exécutera en continu et sans fin tant que la condition entre parenthèses est vraie. La sortie de la boucle sera atteinte lorsque la variable dans la condition while change, donc quelque chose doit changer sa valeur. La modification d'une variable peut se produire dans le code du programme à l'intérieur d'une boucle ou lors de la lecture des valeurs de n'importe quel capteur, par exemple à partir d'un télémètre à ultrasons HC-SR04.

Lors de l'utilisation de la fonction while, la variable doit être créée avant le début de la boucle. Dans l'exemple de croquis, la LED clignotera cinq fois avant la fin du cycle. Si vous ne modifiez pas la variable entre les accolades je++, alors le cycle se répétera sans fin. La deuxième façon de quitter la boucle while de l'Arduino Uno consiste à lire les données du capteur et à utiliser une instruction if pour modifier la variable.

Une autre boucle qui peut être utilisée dans l’IDE ​​Arduino est la boucle de postcondition. faire pendant. Lors de l'utilisation de cette construction, les commandes d'une boucle seront exécutées au moins une fois, quelle que soit la condition, puisque la condition est vérifiée après l'exécution du corps de la boucle. Dans l'exemple de code suivant, la LED s'allumera quelles que soient les lectures du capteur et vérifiera ensuite seulement la postcondition.

Comment sortir d'une boucle while ou for

Dans le cas où il est nécessaire de sortir du corps de la boucle, quelles que soient les conditions précisées, l'opérateur est utilisé casser ou aller à. L'instruction break vous permet de quitter la boucle et le programme continuera à exécuter les commandes suivantes. L'instruction goto vous permet non seulement de quitter la boucle, mais également de continuer à exécuter le programme à partir du point souhaité le long de l'étiquette, par exemple, vous pouvez accéder à une autre boucle dans Arduino.