Syntaxe du switch ... case

Dans le cas d’un switch ... case, la condition est remplacée par une expression évaluée par le switch. Chaque case mentionne la valeur de l’expression pour laquelle ses instructions doivent être exécutées. C’est à dire que si l’expression qui apparaît dans le switch est égal à la valeur du case alors les instructions du case sont exécutées.

La syntaxe générale de cette instruction est la suivante :

switch (expression) {
  case valeur1:
    // instructions à exécuter si expression est égale à valeur1
    break;
  case valeur2:
    // instructions à exécuter si expression est égale à valeur2
    break;
  case valeur3:
    // instructions à exécuter si expression est égale à valeur3
    break;
  default:
    // instructions à exécuter si expression n'est égale à aucune des valeurs des case
    break;
}

Les valeurs des case sont impérativement des constantes.

default est optionnel et est exécuté quand aucun des case ne correspond à l’expression qui apparaît dans le switch (expression). C’est généralement une bonne idée d’y mettre le signalement d’une erreur.

les instructions break qui apparaissement après les instructions de chaque case sont primordiales. En effet, en leur absence, l’exécution se poursuivrait avec les instructions du case suivant. Par exemple, si expression est égale à valeur2 et que le break situé à la fin des instructions du case valeur2: est omise, les instructions du case valeur3: seront exécutées à la suite.

Le dernier break est inutile mais je recommande de le mettre tout de même. En effet, si dans le futur vous ajoutez un nouveau case à la fin du switch, il y a fort à pariez que vous oublierez le break pour fermer le case qui précède. Vous ne pouvez pas imaginer le nombre de bugs de ce type qui ont enquiquiné les programmeurs.

Le break provoque la poursuite de l’exécution à l’instruction qui suit le switch.

Le nombre de case n’est pas limité.

Usage du switch ... case

Les usages sont multiples mais les cas d’application sont généralement liés à l’exécution d’une conditionnelle selon un état du système. Cela va du codage ou du décodage d’un protocole de communication, vous en avez un exemple dans l’article de Dominique, « Comment piloter trains et accessoires en DCC avec un Arduino (1) », où dans l’ISR, l’état d’envoi de la trame DCC est géré via un switch ... case à la gestion d’un feu tricolore dont nous allons donner un exemple :

Supposons que nous voulions gérer un signal de BAL [1]. Le signal possède 3 feux : vert, jaune et rouge. Il peut prendre 5 états : feu vert, feu jaune, feu jaune clignotant, feu rouge, feu rouge clignotant. Nous allons donc définir 5 constantes pour désigner ces états : VERT, JAUNE, JAUNE_CLIGNOTANT, ROUGE et ROUGE_CLIGNOTANT. Comme ceci [2] :

const byte VERT = 0;
const byte JAUNE = 1;
const byte JAUNE_CLIGNOTANT = 2;
const byte ROUGE = 3;
const byte ROUGE_CLIGNOTANT = 4;

Chaque feu va évidemment correspondre à une DEL associée à une broche. Appelons ces broches pinVerte, pinJaune et pinRouge. Ce qui donne également lieu à la déclaration de constantes :

const byte pinVerte = 4;
const byte pinJaune = 5;
const byte pinRouge = 6;

Les DEL sont connectées de telle sorte qu’un état HIGH sur la broche provoque l’allumage de la DEL. Voir « Fonctionnement et pilotage d’une DEL ».

Il nous faut également une variable qui va accueillir l’état du signal et que l’on va initialiser à ROUGE :

byte etatSignal = ROUGE;

Et puis également une variable qui va nous permettre de gérer les clignotements comme on a pu le voir dans « Comment gérer le temps dans un programme ? » que je vous engage à lire pour comprendre ce qui va venir et une seconde variable etatClignotant qui mémorise l’état de la broche du feu qui est en cours de clignotement.

unsigned long dateDernierClignotement = 0;
byte etatClignotant = LOW;

Enfin, grâce à un switch ... case nous allons déterminer ce qui doit être fait sur les DEL pour que l’affichage corresponde à l’état du signal. Nous allons mettre ça dans une fonction afficheFeu :

void afficheFeu()
{
  switch (etatSignal) {
 
    case VERT:
      digitalWrite(pinVerte, HIGH);
      break;
 
    case JAUNE:
      digitalWrite(pinJaune, HIGH);
      break;
 
    case JAUNE_CLIGNOTANT:
      unsigned long dateCourante = millis();
      if (dateCourante - dateDernierClignotement > 480) {
        dateDernierClignotement = dateCourante;
        etatClignotant = ! etatClignotant;
        digitalWrite(pinJaune, etatClignotant);
      }
      break;
 
    case ROUGE:
      digitalWrite(pinRouge, HIGH);
      break;
 
    case ROUGE_CLIGNOTANT:
      unsigned long dateCourante = millis();
      if (dateCourante - dateDernierClignotement > 480) {
        dateDernierClignotement = dateCourante;
        etatClignotant = ! etatClignotant;
        digitalWrite(pinRouge, etatClignotant);
      }
      break;
  
    default:
      Serial.println("Code de feu inconnu !");
      break;     
  }
}

Pour permettre le clignotement, ce afficheFeu doit être appelé à intervalles réguliers dans loop().

Bien entendu il ne s’agit pas d’une application complète mais le code présenté ici servira de base à un exemple plus complet que nous verrons prochainement.