La instrucción switch..case es una estructura condicional que ejecuta diferentes bloques de instrucciones dependiendo del valor de una variable. Esta instrucción es equivalente a las instrucciones anidadas si.

Sintaxis de la instrucción switch

La instrucción del interruptor toma, como entrada, una variable en forma de número entero (integer o int) y ejecuta diferentes bloques de instrucciones según su valor. Los bloques de instrucciones se colocan bajo las instrucciones del caso. En cada ejecución, la instrucción comparará el valor de val con los valores val1, val2, etc. y ejecutará los bloques de código correspondientes.

  switch (val) {
    case val1:
      // instructions si val=val1
      break;
    case val2:
      // instructions si val=val2
      break;
    default:
      // instructions par défaut
      break;
  }

Un entero es un tipo de variable. En el lenguaje C(Arduino), las variables enteras se inicializan con la palabra clave int.

En el siguiente ejemplo, una variable val se define e incrementa en cada bucle. La instrucción del interruptor ejecuta el código correspondiente al valor val. Notará que cuando el valor del val no está definido en una casilla, se ejecuta el código de la instrucción predeterminada.

int val=0;

void setup() {
  Serial.begin(9600);  
}

void loop() {
  switch (val) {
    case 0:
      Serial.println("ZERO");
      break;
    case 1:
       Serial.println("ONE");
      break;
    case 2:
       Serial.println("TWO");
      break;
    case 3:
       Serial.println("THREE");
      break;
    default:
      Serial.println("UNDEFINED");
      break;
  }
  val++;
  if(val>5) val=0;
  delay(500);
}

Estructuras auxiliares

Usando una variable de tipo char

La variable que se va a analizar suele ser un número entero, pero también puede ser una variable de tipo char. No debe confundirse con una cuerda (un conjunto de caracteres o una cuerda).

char val='a';

void setup() {
  Serial.begin(9600);  
}

void loop() {
  switch (val) {
    case 'a':
      Serial.println("A");
      val='b';
      break;
    case 'b':
       Serial.println("B");
       val='d';
      break;
    case 'c':
       Serial.println("C");
       val='a';
      break;
    case 'd':
       Serial.println("D");
       val='c';
      break;
    default:
      Serial.println("UNDEFINED");
      break;
  }
  delay(500);
}

Reunir varias cajas para un bloque de instrucciones

Al eliminar la instrucción break, es posible ejecutar el mismo bloque de instrucciones en diferentes casos. Esto permite no reescribir el bloque de instrucciones cuando la función es la misma en diferentes casos.

char val=0;

void setup() {
  Serial.begin(9600);  
}

void loop() {
  switch (val) {
    case 1:
    case 3:
    case 5:
    case 7:
    case 9:
      Serial.println("IMPAIR");
      break;
    case 2:
    case 4:
    case 6:
    case 8:
      Serial.println("PAIR");
      break;
    default:
      Serial.println("> 10");
      break;
  }
  val++;
  if(val>10) val=0;
  delay(500);
}

Cosas a recordar

• la instrucción del interruptor toma como entrada una variable int o char colocada entre paréntesis
• el bloque de instrucciones del interruptor se encuentra entre llaves {}
• la caja de instrucciones toma como entrada un int o un char seguido de «:»
• Es necesario añadir la instrucción break después del bloque de instrucciones del caso para evitar la ejecución de las siguientes
• Es posible reunir varias cajas case para el mismo bloque de instrucciones.
• Es posible olvidar el bloque de instrucciones default.

Bonus

La instrucción switch se utiliza a menudo en combinación con los numeradores, que es un tipo de estructura que contiene números enteros constantes. El tipo enum es un método práctico de inicialización para definir una multitud de números enteros a encadenar.

enum alphabet{
  ALPHA,
  BETA,
  GAMMA,
  UNKNOWN
};

En este ejemplo, las variables ALPHA, BETA, GAMMA, UNKNOWN tomarán los valores 0,1,2 y 3 respectivamente. Cualquier variable añadida a continuación de esta lista tomará un valor igual al valor anterior incrementado en 1. Además, es posible, en cualquier momento, definir explícitamente el valor de la variable y cambiar así el punto de partida de la enumeración.

enum alphabet{
  ALPHA=0,
  BETA,
  GAMMA=9,
  UNKNOWN
};

En este ejemplo, los valores definidos son

• ALPHA=0
• BETA=1
• GAMMA=9
• UNKNOWN=10

Un numerador puede ser usado para representar una máquina de estados, lo cual es un método conveniente cuando se quiere manejar un sistema complejo como un algoritmo de un robot.

enum States{
  INITIALIZED,
  WAITING,
  FAILED,
  VALID
};
int state=0;

void setup() {
  Serial.begin(9600);  
}

void loop() {
  switch (state) {
    case INITIALIZED:
      Serial.println("INITIALIZED");
      break;
    case WAITING:
       Serial.println("WAITING");
      break;
    case VALID:
       Serial.println("VALID");
      break;
    case FAILED:
       Serial.println("FAILED");
      break;
    default:
      Serial.println("DEFAULT");
      break;
  }
  state++;
  if(state>5) state=0;
  delay(500);
}

Sources

• C Language norm ISO
• Reference Arduino Switch
• Reference Arduino enum
• Programa con Arduino