Dans cet article, on va faire le point sur les contrôles d’état dans les programmes Arduino. Les contrôles d’état vont permettre d’évaluer des conditions pour permettre l’exécution d’une partie de programme.

Les contrôles d’état vont déterminer si une condition est vraie ou fausse. La réponse est forcément binaire. Elle peut être retournée par la réponse à la condition ou par le retour d’une fonction.

Voici la forme générale d’un contrôle d’état (valable pour la plupart des langages de programmation) :

Conditions SI

Il prend une expression entre parenthèses et une déclaration ou un bloc de déclarations. Si l’expression est vraie, l’instruction ou le bloc d’instructions est exécuté sinon ces instructions sont ignorées.

Différents appels de la condition if

Appel 1

if (expression à vérifier)
	une ligne à exécuter si la condition est vraie;

Vous pouvez utiliser l’instruction if sans accolades {} si et seulement si vous n’avez qu’une seule instruction dans la boucle if.

Appel 2

if (expression à vérifier) {
	Bloc de code à exécuter;
}

Séquence d’exécution if

Exemple

/* Définition des variables */

int A = 5 ;

int B = 9 ;

 

Void setup () {

 

}

 

Void loop () {

   /* vérification de la condition booléenne */

   if (A > B) /* si la condition est vérifiée, la prochaine ligne est exécutée*/

   A++;

   /* vérification de la condition booléenne */

   If ( ( A < B ) && ( B != 0 )) /* si la condition est vérifiée, le prochain bloc de code est exécuté*/ { 

      A += B;

      B--;

   }

}

Conditions SI… SINON

Une instruction if peut être suivie d’une instruction else facultative, qui s’exécute lorsque l’expression est fausse.

Appel de la condition if… else

if (expression à vérifier) {
	"Bloc de code à exécuter si l'expression est vraie";
}
else {
	"Bloc de code à exécuter si l'expression est fausse";
}

Séquence d’exécution if… else

Exemple

/* Définition des variables */

int A = 5 ;

int B = 9 ;

 

Void setup () {

 

}

 

Void loop () {

 /* vérification de la condition booléenne */

   if (A > B) /* si la condition est vérifiée, le prochain bloc de code est exécuté */ {

      A++;

   	}
	else {  /* si la condition est fausse, c'est ce prochain bloc qui sera exécuté à la place */

      B -= A;

   }

}

Conditions SI… SINON SI… SINON (imbriqué)

L’instruction if peut être suivie d’une instruction else if… puis d’une instruction else, ce qui est très utile pour tester diverses conditions. On appelle ça une imbrication de conditions.

Il faut garder à l’esprit que :

• Une condition if peut être suivit d’autre if avant une instruction else.
• L’instruction else correspondra à sa propre imbrication de if. Veillez à bien vérifier vos imbrications grâce aux « {} ».
• Si une boucle if retourne un résultat vrai, les conditions if suivantes (de la même imbrication), ne seront pas testées.

Appel de la condition if… else if… else

if (expression 1 à vérifier) {
	"Bloc de code à exécuter si l'expression 1 est vraie";
}
else if (expression 2 à vérifier) { // n'est vérifiée que si l'expression 1 est fausse
	"Bloc de code à exécuter si l'expression 2 est vrai (la première devra être fausse)";
}
else {
	"Bloc de code à exécuter si les expressions 1 et 2 sont fausses";
}

Séquence d’exécution if… else if… else

Exemple

/* Définition des variables */

int A = 5 ;

int B = 9 ;

 

Void setup () {

 

}

 

Void loop () {

 /* vérification de la condition booléenne */

   if (A > B) /* si la condition est vérifiée, le prochain bloc de code est exécuté */ {

      A++;

   	}
	else if (A < B) {  /* si la condition est vérifiée, le prochain bloc de code est exécuté */

      B -= A;

   }
	else {  // ici, les deux premières expressions ne sont pas vraies. Implicitement, pour que le else soit exécuté, A == B.
	
		A = 5;
		B = 9;
		
	}

}

Conditions au cas par cas (switch case)

Cet instruction est similaire aux conditions imbriquées. Cela permet de comparer une condition à plusieurs valeurs. Si une des valeurs correspond, la condition est vraie et le code correspondant est exécuté. On peut également définir le code à exécuter si aucune valeur ne correspond grâce à l’état default.

Le mot-clé break permet de sortir de la boucle. Il est généralement placé à la fin de chaque code (par condition). Si le mot clé break n’est pas placé à la fin de chaque condition, l’appel switch continuera de tester les cas suivants.

Appel de la condition switch… case

switch (variable) { 
   case cas1:{
	   // code cas 1 => variable == cas1
	   break;
	}
 
   case cas2:{
	   // code cas 2 => variable == cas2
	   break;
	}
 
   default:{
	   // code par défaut, lorsqu'aucun cas n'a été vérifié
	   break;
	}
}

Séquence d’exécution switch… case

Exemple

//Exemple d'une variable phase pouvant prendre 3 valeurs : 0, 1 ou 2. Selon le cas, 3 fonctions peuvent être lancées : Lo(), Mid() ou Hi().

switch (phase) {
   case 0: Lo(); break;
   case 1: Mid(); break;
   case 2: Hi(); break;
   default: Message("Erreur !");
}

Opérateur conditionnel « ? »

Il s’agit du seul opérateur de condition en C.

Appel de la condition « ? »

expression1 ? expression2 : expression3

Expression1 est évaluée en premier. Si sa valeur est true, expression2 est évaluée et expression3 est ignorée. Si expression1 est évaluée comme fausse, alors expression3 est évalué et expression2 est ignorée. Le résultat sera une valeur de expression2 ou expression3 en fonction de laquelle d’entre elles est évaluée comme True.

Exemples

/* trouver la valeur max entre a et b : */
max = ( a > b ) ? a : b;

/* Conversion de lettre minuscules en lettres capitales : */
/* (les parenthèses ne sont pas nécessaires) */
c = ( c >= 'a' && c <= 'z' ) ? ( c - 32 ) : c;

Les règles à respecter

• Expression2 et Expression3 doivent être de type void et ne rien retourner (si ce sont des appels de fonction).
• Les expressions doivent être de type arithmétique.
• Expression1 doit être une expression pouvant retourner true ou false.