Aprender

Máquinas de estados en Arduino, con un juego que puedes jugar

O mira todas las lecciones.

  • 526componentes en el banco de trabajo
  • 46placas funcionando ahora
  • 1.00xtiempo real, en todas las placas
Arduino Uno: un juego de reacción de cuatro estadosen vivo0.000 s 0.00x
Mantén presionado el botón
READY, ARMED, RUNNING, DONE: presiona el botón para empezar, y de nuevo cuando se encienda la lámpara amarilla.

Tarde o temprano todo sketch tiene que hacer cosas en orden y aun así reaccionar al mundo: esperar un botón, luego esperar un tiempo aleatorio, luego encender una lámpara, luego medir cuánto tardas en volver a presionar. Escrito con delay() e ifs anidados, se convierte en un programa difícil de seguir y sordo a la entrada la mitad del tiempo. Una máquina de estados es la salida estándar, y no necesita nada más que un enum y una variable.

El circuito de arriba es un juego de reacción en un Uno con un botón en el pin 2 y tres lámparas. El programa tiene cuatro estados: READY (la lámpara roja del pin 13 encendida, esperando a que presiones), ARMED (todo apagado, esperando un tiempo aleatorio de 0.7 a 2 segundos), RUNNING (la lámpara amarilla del pin 12 encendida, el reloj corriendo) y DONE (la lámpara verde del pin 11 indica que la ronda terminó). Presiona Ejecutar, presiona el botón una vez y espera el amarillo.

¿Quieres la versión paso a paso? La lección "Una variable que dice dónde estás" recorre esto con puntos de control.

Abrir la lección

Lo que te dice el monitor serie

El sketch imprime cada cambio de estado, así que el monitor serie es un registro de la máquina. Una ronda que jugamos decía: "state: READY", "state: ARMED", "state: RUNNING", "reaction: 861 ms", "state: READY". Si presionas durante ARMED, en cambio, obtienes "too early", pasas directo a DONE y vuelves a READY 1.2 segundos después.

Ese registro es la primera razón para escribir código así. Cuando algo sale mal sabes exactamente en qué estado estaba el programa y qué lo hizo avanzar, en lugar de adivinar cuál de cinco ifs anidados era verdadero.

La forma del código

Nombra los estados con un enum, guarda el actual en una variable y dale a cada estado un bloque que diga qué hace y qué lo hace avanzar. Un auxiliar, enter(), cambia el estado y anota el tiempo, así cada estado sabe cuánto lleva activo sin llevar su propio temporizador.

Observa lo que no está. No hay ningún delay(). Cada pasada por loop() lee el botón, revisa el estado y regresa en microsegundos, así que el botón se lee miles de veces por segundo en cada estado. La espera se hace comparando millis() con el momento en que se entró al estado, el mismo patrón que usa la página de parpadeo sin delay para dos LEDs.

firmware/uno/examples/cppstate (la máquina, resumida del programa que corre arriba)
enum State { READY, ARMED, RUNNING, DONE };
State state = READY;
unsigned long enteredAt = 0;

static void enter(State next) {
  state = next;
  enteredAt = millis();
}

// in loop(), after reading the button into justPressed:
if (state == READY) {
  if (justPressed) {
    waitMs = random(700, 2000);
    enter(ARMED);
  }
} else if (state == ARMED) {
  if (justPressed) {
    enter(DONE);                       // too early
  } else if (now - enteredAt >= waitMs) {
    enter(RUNNING);
  }
} else if (state == RUNNING) {
  if (justPressed) {
    Serial.println(now - enteredAt);   // the reaction time
    enter(DONE);
  }
} else {                               // DONE
  if (now - enteredAt >= 1200) enter(READY);
}

Eventos, no niveles

La máquina reacciona a justPressed, que es verdadero durante exactamente una pasada por loop() cuando el botón pasa de arriba a abajo. Si reaccionara a "el botón está presionado", una sola presión mantenida un cuarto de segundo se vería cientos de veces y llevaría la máquina directa por READY, ARMED y a un arranque en falso. Detectar el flanco, con un antirrebote de 25 milisegundos para que el rebote del contacto no cuente como pulsos extra, es lo que convierte una presión en un solo evento.

Este es el error de máquina de estados más común en un banco de trabajo real: una transición guiada por un nivel donde hacía falta un flanco. Si un estado parece saltarse, revisa qué hace avanzar la máquina.

Dibújala antes de escribirla

Antes de escribir una máquina de estados, dibújala: un círculo por estado y una flecha por transición, con el evento que la causa escrito sobre la flecha. Para este juego son cuatro círculos y cinco flechas: READY a ARMED con una presión, ARMED a RUNNING cuando se agota la espera aleatoria, ARMED a DONE con una presión (demasiado pronto), RUNNING a DONE con una presión, y DONE a READY tras 1.2 segundos. Si no puedes dibujar una flecha para algo que el programa debe hacer, al diseño le falta un estado o un evento, y es mucho más barato descubrirlo en papel.

El dibujo también se convierte en tu lista de pruebas. Cada flecha es un caso para probar una vez. En el simulador puedes recorrer las cinco en menos de un minuto: presiona una vez y espera, presiona dos veces rápido, presiona una vez y luego otra vez cuando se encienda el amarillo. Ver el registro serie imprimir cada transición mientras lo haces es toda la prueba. Dos errores que salen así son olvidar llamar a enter() (así enteredAt queda viejo y un estado con tiempo termina de inmediato) y un estado sin salida.

Compáralo con un sketch que bloquea

El ejemplo Traffic light de la galería corre un cruce peatonal a la otra manera: una secuencia directa de luces con delay() entre ellas. Funciona, pero solo porque el botón de solicitud está en una interrupción; sin eso, una presión durante un delay() se perdería. Ábrelo con el botón de abajo y lee los dos sketches lado a lado.

Reescribir el cruce como una máquina de estados (GREEN, AMBER, WALK, FLASHING) elimina la necesidad de la interrupción, y agregar una regla nueva, digamos "mantener verde al menos tres segundos", se vuelve una condición extra en un bloque en lugar de una reestructuración de todo el ciclo.

Abre este circuito en el editor. Arduino Uno: un juego de reacción de cuatro estados, cableado como corre arriba en esta página. Cambia un componente o un valor y ejecútalo de nuevo.

Preguntas

¿Debo usar switch o if y else if?

Cualquiera funciona. Un switch sobre la variable de estado es común y hace que el compilador te avise de un valor del enum que olvidaste manejar, siempre que recuerdes un break al final de cada case. El ejemplo usa if y else if porque se lee bien en un sketch corto.

¿Cómo agrego un estado nuevo?

Agrega un nombre al enum, agrega un bloque para él y agrega las transiciones hacia dentro y hacia fuera de él. Nada más en el programa necesita cambiar, y ese es el punto del patrón.

¿Puede una máquina de estados correr junto con otro código?

Sí, siempre que nada en loop() bloquee. Varias máquinas pueden correr en paralelo, cada una con su propia variable de estado, porque cada una solo hace un poco de trabajo por pasada.

¿Dónde hago algo una sola vez cuando empieza un estado?

En la transición, justo antes o después de llamar enter(). El ejemplo elige la espera aleatoria en el momento en que entra a ARMED, así la espera se elige una vez por ronda y no en cada pasada.

Ármalo en la vida real

Abre el editor, cambia un valor y mira cómo cambia el número con él. Nada que instalar y sin necesidad de cuenta.