STRUCTURES DE CONTRÔLE

IF

---

if (condition) et ==, !=, <, > (opérateurs logiques de comparaison)
L'instruction if ("si" en français), utilisée avec un opérateur logique de comparaison, permet de tester si une condition est vraie.

Syntaxe:

if (condition)

{ 

// faire traitement 
}

Exemple:

// si intensity>0 , allumer la LED 

if (intensity > 120){

   digitalWrite(LEDpin, HIGH); 

}   

IF..ELSE

---

L'instruction if/else (si/sinon en français) permet un meilleur contrôle du déroulement du programme que la simple instruction if, en permettant de grouper plusieurs tests ensemble.

Syntaxe:

if (condition)

{ 

// faire traitement 1
}

else 

{ 

// faire traitement 2
}

Exemple:

// si intensity>120 , allumer la LED , sinon éteindre la LED

if (intensity > 120){
   digitalWrite(LEDpin, HIGH);

}  else

{
 digitalWrite(LEDpin, LED);
}

else peut contenir un autre test if, et donc des tests multiples, mutuellement exclusifs peuvent être réalisés en même temps.
Chaque test sera réalisé après le suivant jusqu'à ce qu'un test VRAI soit rencontré. Quand une condition vraie est rencontrée, les instructions associées sont réalisées, puis le programme continue son exécution à la ligne suivant l'ensemble de la construction if/else. Si aucun test n'est VRAI, le bloc d'instructions par défaut else est exécuté.

if (condition 1)

{ 

// faire traitement 1
}

else if  (condition 2)

{ 

// faire traitement 2
}

else 

{ 

// faire traitement 3
}

SWITCH..CASE

---

L'instruction switch / case permet au programmeur de construire une liste de "cas" (ou possibilités) à l'intérieur d'accolades. Le programme teste chaque cas avec la variable de test, et exécute le code si une correspondance (un test VRAI) est trouvé.

PARAMÈTRES:
var : variable dont vous vouler tester l'état .
default : si aucune autre condition vraie n'est rencontrée, le code default sera exécuté.
break : Sans une instruction break, l'instruction switch continuera à exécuter les expressions suivantes  jusqu'à un rencontrer un break ou jusqu'à la fin du switch.  L'instruction break indique à l'instruction switch d'arrêter de rechercher des conditions vraies, et fait sortir de la structure de choix.

Syntaxe:

switch (var) { // début de la structure 
    case valeur1: // cas 1
      //faire traitement2 quand la variable est égale à 1 (càd si var == valeur1)
      break;
      // l'instruction break est en option
    case valeur2: // cas 2
        //faire traitement2 quand la variable est égale à 2 (càd si var == valeur2)
      break;
      // l'instruction break est en option

    default: // cas par défaut 
      // si aucune condition n'est vraie, le code par défaut sera exécuté
      // le cas default est optionnel (non -obligatoire) 
  }

FOR

---

L'instruction for est utilisée pour répéter l'exécution d'un bloc d'instructions regroupées entre des accolades. L'instruction for est très utile pour toutes les opérations répétitives .
Il y a 3 parties dans l'entête d'une boucle for :

Syntaxe:

for (initialization; condition; incrementation){ 

   // faire traitement 
}

Exemple:

// Eteint progressivement une LED en utilisant une broche PWM (impulsion)

int PWMpin = 10; // LED en série avec une résistance de 1k sur la broche 10

void setup()
{
  // aucune initialisation nécessaire
}

void loop()
{

   // boucle incrémentant la variable i de 0 à 255, de 1 en 1
   for (int i=0; i <= 255; i++){

      // impulsion de ratio HAUT/BAS fonction de i sur la broche 10
      analogWrite(PWMpin, i);  

      delay(10); // pause de 10ms

   } // fin de la boucle for
}

WHILE

---

Les boucles while ("tant que" en anglais) bouclent sans fin, et indéfiniment, jusqu'à ce que la condition ou l'expression entre les parenthèses ( ) devienne fausse. Quelque chose doit modifier la variable testée, sinon la boucle while ne se terminera jamais. Cela peut être dans votre code, soit une variable incrémentée, ou également une condition externe, soit le test d'un capteur.

Syntaxe:

while (expression){ // tantque expression (booléenne) est vraie

   // faire traitement 
}

Exemple:

var = 0;
while(var < 200){  // tant que la variable est inférieur à 200

  // fait traitement... 

  var++; // incrémenter la variable 

}

DO..WHILE

---

La boucle do / while ("faire tant que" en anglais) fonctionne de la même façon que la boucle while, à la différence près que la condition est testée à la fin de la boucle, et par conséquent la boucle do sera toujours exécutée au moins une fois.

Syntaxe:

do  // faire
{ 

   // traitement 
}while (condition);  // tantque condition (booléenne) est vraie

Exemple:

var = 0;
do{  // faire
  x++; // incrémenter x

  serial.print("x=");
  serial.println(x);   // afficher la valeur de x

}while(x < 20); // tant que x est inférieur à 20

BREAK

---

L'instruction break est utilisée pour sortir d'une boucle do, for ou while, en passant outre le déroulement normal de la boucle. Cette instruction est également utilisée pour sortir d'une instruction switch.

Syntaxe:

break ;

Exemple:

for (x = 0; x < 255; x ++) // boucle for comptant x de 0 à 255
{
    // mettre une impulsion de largeur x sur la broche 
    digitalWrite(PWMpin, x);

    // lire la valeur de la tension d'un capteur sur la broche
    sens = analogRead(sensorPin);

    // si la mesure est supérieure à un seuil, on sort de la boucle
    if (sens > threshold){    
       x = 0;
       break; // sortie de la boucle
    }

    delay(50); // pause de 50ms

}

CONTINUE

---

L'instruction continue est utilisée pour passer outre certaines portions de code dans les boucle do, for ou while. Cela force le test de la condition sans exécuter le code restant de la boucle.

Syntaxe:

continue ;

Exemple:

for (x = 0; x < 255; x ++) // boucle for qui compte x de 0 à 255
{
    if (x > 40 && x < 120){      // crée un saut en fonction de la valeur de x

    continue; // l'instruction continue force à continuer 
                  // la boucle sans exécuter les instructions 
    }
         // les instructions suivantes sont ignorées 
         // lorsque continue; est prise en compte

         digitalWrite(PWMpin, x); // met une impulsion de largeur x sur la broche
         delay(50); // pause de 50ms 
}

RETURN

---

L'instruction return termine la fonction en cours et renvoie une valeur calculée par la fonction en cours vers la fonction d'appel, si nécessaire.

Syntaxe:

return ;

return valeur;

Exemple:

// fonction qui permet de comparer l'entrée d'un capteur à un seuil
 int checkSensor(){       // fonction de type int
    if (analogRead(0) > 400) {   // si la valeur analogique du capteur > 400
        return 1;  // renvoie 1
    else{
        return 0;  // renvoie 2
    }
}

Le mot-clé est pratique pour tester une section de code sans avoir à mettre en commentaire de larges section de code potentiellement source d'erreur de compilation et que l'on souhaite isoler :

void loop(){

// idée brillante de code à tester ici 

return; // mot clé return

// le reste du programme qui pose problème ici
// ce code ne sera jamais exécuté... 

}

GOTO

---

Fait sauter le déroulement du programme à un point précis du programme signalé par un label.

Syntaxe:

label: 

goto label;    // fait sauter le déroulement du programme au point label:

Exemple:

for(byte r = 0; r < 255; r++){
    for(byte g = 255; g > -1; g--){
        for(byte b = 0; b < 255; b++){
            if (analogRead(0) > 250){ goto sortir;}
            // plus d'instructions
        }
    }
}

sortir: