Fundamentos · 11 min de lectura

Máquina de estados en Arduino: enum, switch-case y millis()

Máquina de estados en Arduino: estados con enum y switch-case, transiciones, estados temporizados con millis, semáforo, menú, lavadora y versión para Pico.

Una máquina de estados en Arduino (state machine) es una forma de escribir código en la que divides el programa en estados separados y solo estás en uno de ellos cada vez. Un semáforo está en el estado "rojo", "ámbar" o "verde"; una lavadora está "llenando", "lavando" o "centrifugando". En cada estado está claro qué hacer y con qué condición pasar al siguiente. En Arduino lo construyes con un enum, un switch-case y millis(). El resultado es un código que hace varias tareas a la vez sin delay() y que es fácil de leer y ampliar.

En esta guía veremos primero los conceptos de estado, transición y acción, cómo dibujar un diagrama de estados y la máquina más sencilla de dos estados. Después escribiremos un semáforo con pulsador para peatones, un menú de ajustes que se recorre con dos pulsadores y la simulación de una lavadora que se pausa al abrir la tapa. También aprenderás a ejecutar varias máquinas de estados en el mismo loop(), las acciones de entrada, los errores más comunes y cómo se escribe la misma estructura en MicroPython en la Raspberry Pi Pico.

¿Qué es una máquina de estados?

Una máquina de estados (máquina de estados finitos, FSM) tiene cuatro partes. Los estados son el número limitado de situaciones en que puede estar el sistema. Las transiciones llevan de un estado a otro, y las condiciones o eventos deciden cuándo ocurre: pulsar un botón, que un sensor supere un umbral o que pase un tiempo. Las acciones son el trabajo que se hace al entrar en un estado o mientras se está en él: encender un LED, poner en marcha un motor, escribir en una pantalla. En cada vuelta de loop() el programa solo se pregunta: "¿En qué estado estoy y se ha cumplido la condición para salir?" Así nunca espera, y en lugar de ifs anidados y cientos de variables bandera obtienes una estructura ordenada alrededor de una sola variable de estado.

ConceptoSignificadoEjemplo del semáforo
EstadoLa situación actual del sistemaKIRMIZI (rojo), KIRMIZI_SARI (rojo-ámbar), YESIL (verde), SARI (ámbar)
TransiciónPaso de un estado a otroDe YESIL a SARI
Condición o eventoLo que dispara la transiciónHan pasado 10 segundos o se ha pulsado el botón de peatones
Acción de entradaTrabajo que se hace una vez al entrarEncender el LED verde y apagar los demás
Acción en el estadoTrabajo que se hace continuamente en el estadoLeer el botón de peatones

¿Por qué una máquina de estados en lugar de delay()?

Cuando escribes delay(5000), el Arduino no hace nada durante cinco segundos: no nota que pulsas un botón, no lee sensores ni actualiza la pantalla. En programas pequeños de una sola tarea no pasa nada, pero en cuanto añades una segunda tarea el código empieza a fallar. En una máquina de estados no se espera nunca; cada estado pregunta con millis() "¿cuánto tiempo ha pasado desde que entré?" y, si no ha terminado, vuelve a loop() enseguida. Como loop se ejecuta miles de veces por segundo, las demás tareas, como botones, sensores y pantallas, siguen funcionando sin cortes. Explicamos a fondo cómo temporizar con millis() en el artículo millis frente a delay en Arduino.

CaracterísticaCódigo con delay()Máquina de estados
¿Se leen los botones mientras espera?NoSí
Varias tareas a la vezDifícil, el código se enredaFácil, cada tarea en su máquina
Añadir un estado nuevoHay que reescribir todo el flujoSe añade un case nuevo
DepuraciónNo se sabe dónde está el programaBasta con escribir el nombre del estado en el Monitor Serie
MemoriaPocaPoca (una variable y una marca de tiempo)

Primera máquina de estados con enum y switch-case

Un enum sirve para dar nombres a los estados en lugar de números. La línea enum Durum { YANIK, SONUK }; (encendido, apagado) define un tipo nuevo que para el compilador vale 0 y 1, pero que para ti tiene nombres con significado. La variable de estado es de este tipo y switch-case ejecuta un bloque distinto para cada estado. En el ejemplo de abajo, el LED de la placa del Uno (D13) se enciende 200 ms y se apaga 1,8 segundos. Se podría hacer con delay, pero con esta estructura loop() nunca espera y puedes añadir al final todas las tareas que quieras.

C++ (Arduino IDE)
1// En basit durum makinesi: farklı sürelerde yanıp sönen LED
2// Simplest state machine: an LED with different on/off times
3const int LED_PIN = 13;
4
5enum Durum { YANIK, SONUK };            // durumlar / states
6Durum durum = SONUK;
7unsigned long durumBaslangic = 0;        // duruma giriş zamanı / time the state began
8
9void setup() {
10  pinMode(LED_PIN, OUTPUT);
11}
12
13void loop() {
14  unsigned long gecen = millis() - durumBaslangic;   // durumda geçen süre / time in state
15
16  switch (durum) {
17    case YANIK:
18      if (gecen >= 200) {                // 200 ms yandıktan sonra / after 200 ms on
19        digitalWrite(LED_PIN, LOW);
20        durum = SONUK;
21        durumBaslangic = millis();
22      }
23      break;
24    case SONUK:
25      if (gecen >= 1800) {               // 1,8 sn söndükten sonra / after 1.8 s off
26        digitalWrite(LED_PIN, HIGH);
27        durum = YANIK;
28        durumBaslangic = millis();
29      }
30      break;
31  }
32  // loop asla beklemez; buraya başka işler eklenebilir
33  // loop never blocks; other tasks can be added here
34}
Escribe la definición del enum al principio del archivo, antes de las funciones. El IDE de Arduino genera automáticamente los prototipos de las funciones; si el enum se define después de una función que lo usa como parámetro, puedes obtener el error "was not declared in this scope". Tampoco olvides el break al final de cada case; si no, el programa ejecuta también el código del estado siguiente.

Dibujar el diagrama de estados

Dibujar la máquina de estados en papel antes de programar elimina la mayoría de los errores antes de empezar. En el diagrama cada estado es un círculo o una caja redondeada y cada transición es una flecha. Sobre la flecha escribes la condición de la transición y, si hace falta, la acción tras una barra, por ejemplo "10 s / encender ámbar". El estado inicial se marca con una flecha corta que no sale de ningún sitio. Con el diagrama terminado, hazte estas preguntas para cada estado: ¿Hay salida de este estado? Si dos condiciones se cumplen a la vez, ¿cuál va primero? ¿Qué pasa ante un evento inesperado (se abre la tapa, falla un sensor)? Convertir el diagrama en una tabla hace que escribir el código sea casi mecánico.

  1. Enumera todos los estados del sistema y dale a cada uno un nombre corto en mayúsculas.
  2. Elige el estado inicial; el Arduino estará en él al encenderse o reiniciarse.
  3. Escribe las condiciones de salida de cada estado: tiempo, botón, sensor u otro evento.
  4. Añade el estado de destino de cada transición y la acción que haya que hacer en ella.
  5. Decide la acción de entrada de cada estado: ¿qué salidas estarán encendidas y cuáles apagadas?
  6. Anota aparte las reglas comunes que valen en todos los estados (parada de emergencia, apertura de la tapa).
  7. Convierte el diagrama en una tabla de transiciones como la de abajo y escribe cada fila como un if dentro de un case.
EstadoCondiciónEstado siguienteAcción de entrada
KIRMIZIPasan 5 sKIRMIZI_SARIRojo encendido, se borra la petición de peatones
KIRMIZI_SARIPasan 1,5 sYESILRojo y ámbar encendidos
YESILPasan 10 s, o 4 s si hay peticiónSARIVerde encendido
SARIPasan 2 sKIRMIZIÁmbar encendido

Ejemplo 1: semáforo con pulsador para peatones

La secuencia clásica de un semáforo es rojo, rojo-ámbar, verde y ámbar. Añadamos un pulsador para peatones: si un peatón lo pulsa mientras está en verde, el verde se acorta, siempre que lleve al menos 4 segundos encendido, y el semáforo pasa a ámbar. Escrito con delay, este comportamiento es casi imposible, porque no puedes leer el botón mientras esperas en verde. En una máquina de estados el botón se lee en cada vuelta de loop y la petición se guarda en una variable. Si nunca has montado el circuito básico del semáforo, mira antes el artículo semáforo con Arduino.

LED rojo, ámbar y verde
Los ejemplos del semáforo, el menú y la lavadora usan los mismos tres LED y dos pulsadores.
PiezaPin del Arduino UnoNota
LED rojoD8Con resistencia de 220 Ω, pata corta a GND
LED ámbarD9Con resistencia de 220 Ω
LED verdeD10Con resistencia de 220 Ω (pin con PWM)
ZumbadorD11Solo en el ejemplo de la lavadora
Pulsador 1D2La otra pata a GND, INPUT_PULLUP
Pulsador 2D3La otra pata a GND, INPUT_PULLUP
C++ (Arduino IDE)
1// Yaya butonlu trafik lambası durum makinesi / traffic light with pedestrian button
2const int KIRMIZI_LED = 8, SARI_LED = 9, YESIL_LED = 10, YAYA_BUTON = 2;
3
4enum Durum { KIRMIZI, KIRMIZI_SARI, YESIL, SARI };
5Durum durum = KIRMIZI;
6unsigned long durumBaslangic = 0;
7bool yayaIstegi = false;
8
9void lambalar(bool k, bool s, bool y) {
10  digitalWrite(KIRMIZI_LED, k);
11  digitalWrite(SARI_LED, s);
12  digitalWrite(YESIL_LED, y);
13}
14
15// Durum değiştir + giriş eylemi / change state + entry action
16void durumDegistir(Durum yeni) {
17  durum = yeni;
18  durumBaslangic = millis();
19  switch (yeni) {
20    case KIRMIZI:      lambalar(1, 0, 0); yayaIstegi = false; break;  // yayalar geçer / pedestrians cross
21    case KIRMIZI_SARI: lambalar(1, 1, 0); break;
22    case YESIL:        lambalar(0, 0, 1); break;
23    case SARI:         lambalar(0, 1, 0); break;
24  }
25}
26
27void setup() {
28  pinMode(KIRMIZI_LED, OUTPUT);
29  pinMode(SARI_LED, OUTPUT);
30  pinMode(YESIL_LED, OUTPUT);
31  pinMode(YAYA_BUTON, INPUT_PULLUP);
32  durumDegistir(KIRMIZI);
33}
34
35void loop() {
36  if (digitalRead(YAYA_BUTON) == LOW) yayaIstegi = true;   // isteği hatırla / remember the request
37
38  unsigned long gecen = millis() - durumBaslangic;
39  switch (durum) {
40    case KIRMIZI:
41      if (gecen >= 5000) durumDegistir(KIRMIZI_SARI);
42      break;
43    case KIRMIZI_SARI:
44      if (gecen >= 1500) durumDegistir(YESIL);
45      break;
46    case YESIL:
47      // En az 4 sn yeşil; yaya isterse kısalır, yoksa 10 sn
48      // At least 4 s green; shortened on request, otherwise 10 s
49      if ((yayaIstegi && gecen >= 4000) || gecen >= 10000) durumDegistir(SARI);
50      break;
51    case SARI:
52      if (gecen >= 2000) durumDegistir(KIRMIZI);
53      break;
54  }
55}

La parte más importante de este código es la función durumDegistir() (cambiar estado). Al pasar a un estado ocurren tres cosas: se actualiza la variable de estado, se reinicia la marca de tiempo y se ejecuta una vez la acción de entrada del estado. Hacer que todas las transiciones pasen por esta única función elimina errores del tipo "olvidé reiniciar el temporizador". La petición de peatones se borra al entrar en KIRMIZI, porque en ese momento los peatones cruzan de todos modos. Para calcular las resistencias de los LED puedes usar la calculadora de resistencia para LED.

Ejemplo 2: menú de ajustes con dos pulsadores

Los menús son el uso más natural de una máquina de estados: la página que se muestra es un estado y los pulsadores disparan las transiciones. En el ejemplo de abajo, el pulsador D2 significa "siguiente" o "subir valor" y D3 significa "OK". En el menú principal pasas entre las opciones de brillo y velocidad; con OK entras en la página de ajuste, cambias el valor con D2 y sales con OK. Al mismo tiempo, una segunda máquina de estados independiente hace parpadear el LED de D10 con el brillo y la velocidad elegidos. El LED no se traba ni un instante mientras navegas por el menú.

Pulsador
Los pulsadores se conectan con INPUT_PULLUP; al pulsar, el pin lee LOW.
C++ (Arduino IDE)
1// İki butonlu menü + bağımsız LED makinesi / two-button menu + independent LED machine
2// D2: ileri / değer artır, D3: tamam, D10: LED (PWM)
3const int ILERI_PIN = 2, TAMAM_PIN = 3, LED_PIN = 10;
4
5enum MenuDurum { MENU_PARLAKLIK, MENU_HIZ, AYAR_PARLAKLIK, AYAR_HIZ };
6MenuDurum menu = MENU_PARLAKLIK;
7int parlaklik = 153;    // 51..255
8int hizMs = 500;        // yanıp sönme yarım periyodu / blink half period
9
10struct Buton {
11  uint8_t pin;
12  bool kararli;               // kararlı seviye / debounced level
13  bool sonOkuma;
14  unsigned long sonDegisim;
15};
16Buton ileri = {ILERI_PIN, HIGH, HIGH, 0};
17Buton tamam = {TAMAM_PIN, HIGH, HIGH, 0};
18
19// Yalnız basma anında bir kez true döner / true once, on the press edge only
20bool basildi(Buton &b) {
21  bool okuma = digitalRead(b.pin);
22  if (okuma != b.sonOkuma) {
23    b.sonOkuma = okuma;
24    b.sonDegisim = millis();
25  }
26  if (millis() - b.sonDegisim > 30 && okuma != b.kararli) {   // 30 ms debounce
27    b.kararli = okuma;
28    return okuma == LOW;
29  }
30  return false;
31}
32
33void menuYaz() {
34  switch (menu) {
35    case MENU_PARLAKLIK: Serial.println(F("> Parlaklik ayari (D3: sec)")); break;
36    case MENU_HIZ:       Serial.println(F("> Hiz ayari (D3: sec)")); break;
37    case AYAR_PARLAKLIK: Serial.print(F("Parlaklik: ")); Serial.println(parlaklik); break;
38    case AYAR_HIZ:       Serial.print(F("Hiz (ms): ")); Serial.println(hizMs); break;
39  }
40}
41
42void menuGuncelle() {                       // 1. durum makinesi / machine 1
43  bool i = basildi(ileri);
44  bool t = basildi(tamam);
45  if (!i && !t) return;
46
47  switch (menu) {
48    case MENU_PARLAKLIK:
49      if (t) menu = AYAR_PARLAKLIK;
50      else menu = MENU_HIZ;
51      break;
52    case MENU_HIZ:
53      if (t) menu = AYAR_HIZ;
54      else menu = MENU_PARLAKLIK;
55      break;
56    case AYAR_PARLAKLIK:
57      if (t) menu = MENU_PARLAKLIK;          // kaydet ve çık / save and exit
58      else parlaklik = (parlaklik >= 255) ? 51 : parlaklik + 51;
59      break;
60    case AYAR_HIZ:
61      if (t) menu = MENU_HIZ;
62      else hizMs = (hizMs >= 1000) ? 100 : hizMs + 100;
63      break;
64  }
65  menuYaz();
66}
67
68void ledGuncelle() {                         // 2. durum makinesi / machine 2
69  static bool yanik = false;
70  static unsigned long son = 0;
71  if (millis() - son >= (unsigned long)hizMs) {
72    son = millis();
73    yanik = !yanik;
74    analogWrite(LED_PIN, yanik ? parlaklik : 0);
75  }
76}
77
78void setup() {
79  Serial.begin(9600);
80  pinMode(ILERI_PIN, INPUT_PULLUP);
81  pinMode(TAMAM_PIN, INPUT_PULLUP);
82  pinMode(LED_PIN, OUTPUT);
83  menuYaz();
84}
85
86void loop() {
87  menuGuncelle();      // ikisi de beklemeden sırayla çalışır
88  ledGuncelle();       // both run in turn without blocking
89}

Al leer pulsadores hay que fijarse en el instante de la pulsación, no en el nivel. Si actuáramos mientras digitalRead() devuelve LOW, el menú avanzaría cientos de veces con una sola pulsación. La función basildi() (pulsado) guarda el último nivel estable de cada pulsador, aplica un antirrebote de 30 ms y devuelve true una sola vez, en el paso de HIGH a LOW. Encontrarás los detalles de la conexión y el rebote en el artículo cómo conectar un pulsador. Para mostrar el menú en una pantalla LCD I2C en lugar del Monitor Serie, solo tienes que cambiar la función menuYaz(); la máquina de estados no cambia.

EstadoD2 (siguiente)D3 (OK)
MENU_PARLAKLIKIr a MENU_HIZEntrar en AYAR_PARLAKLIK
MENU_HIZIr a MENU_PARLAKLIKEntrar en AYAR_HIZ
AYAR_PARLAKLIKSubir el brillo 51 (tras 255 vuelve a 51)Guardar, volver a MENU_PARLAKLIK
AYAR_HIZSubir el tiempo 100 ms (tras 1000 vuelve a 100)Guardar, volver a MENU_HIZ

Ejemplo 3: una lavadora

Los aparatos reales suelen seguir un programa paso a paso y reaccionar ante eventos inesperados. En nuestra simulación de lavadora, al pulsar el botón de inicio de D2 la máquina carga agua, lava, desagua, centrifuga y termina con un pitido, por ese orden. La válvula de agua, el motor y la bomba se representan con tres LED. En el estado de lavado el motor funciona 2 segundos y para 2 segundos; es un pequeño patrón temporizado dentro del estado. Y lo más importante: si se abre el interruptor de la tapa en D3, la máquina se pausa esté en el paso que esté, y al cerrar la tapa continúa donde lo dejó con el tiempo que le quedaba.

C++ (Arduino IDE)
1// Çamaşır makinesi durum makinesi (LED'lerle benzetim) / washing machine simulation
2// D8: su vanası, D9: motor, D10: pompa, D11: buzzer, D2: başlat, D3: kapak anahtarı
3const int VANA = 8, MOTOR = 9, POMPA = 10, BUZZER = 11, BASLA = 2, KAPAK = 3;
4
5enum Program { BEKLEME, SU_ALMA, YIKAMA, BOSALTMA, SIKMA, BITTI, DURAKLATILDI };
6const char *const adlar[] = {"BEKLEME", "SU ALMA", "YIKAMA", "BOSALTMA", "SIKMA", "BITTI", "DURAKLATILDI"};
7
8Program durum = BEKLEME;
9Program oncekiDurum = BEKLEME;       // duraklatmadan dönmek için / to resume after pause
10unsigned long durumBaslangic = 0;
11unsigned long kalanGecen = 0;        // duraklatıldığında geçen süre / time spent before pause
12
13const unsigned long SURE_SU = 5000, SURE_YIKAMA = 12000, SURE_BOSALTMA = 4000, SURE_SIKMA = 6000;
14
15void cikislar(bool vana, bool motor, bool pompa) {
16  digitalWrite(VANA, vana);
17  digitalWrite(MOTOR, motor);
18  digitalWrite(POMPA, pompa);
19}
20
21void gir(Program yeni) {                             // giriş eylemleri / entry actions
22  durum = yeni;
23  durumBaslangic = millis();
24  Serial.print(F("Durum: "));
25  Serial.println(adlar[yeni]);
26  switch (yeni) {
27    case BEKLEME:      cikislar(0, 0, 0); break;
28    case SU_ALMA:      cikislar(1, 0, 0); break;
29    case YIKAMA:       cikislar(0, 1, 0); break;
30    case BOSALTMA:     cikislar(0, 0, 1); break;
31    case SIKMA:        cikislar(0, 1, 1); break;
32    case BITTI:        cikislar(0, 0, 0); tone(BUZZER, 2000, 800); break;
33    case DURAKLATILDI: cikislar(0, 0, 0); break;
34  }
35}
36
37bool calisiyor() {
38  return durum == SU_ALMA || durum == YIKAMA || durum == BOSALTMA || durum == SIKMA;
39}
40
41void setup() {
42  Serial.begin(9600);
43  pinMode(VANA, OUTPUT);
44  pinMode(MOTOR, OUTPUT);
45  pinMode(POMPA, OUTPUT);
46  pinMode(BUZZER, OUTPUT);
47  pinMode(BASLA, INPUT_PULLUP);
48  pinMode(KAPAK, INPUT_PULLUP);      // kapak kapalı = LOW / lid closed = LOW
49  gir(BEKLEME);
50}
51
52void loop() {
53  static bool oncekiBasla = HIGH;
54  bool basla = digitalRead(BASLA);
55  bool baslaBasildi = (oncekiBasla == HIGH && basla == LOW);   // basma anı / press edge
56  oncekiBasla = basla;
57  bool kapakAcik = digitalRead(KAPAK) == HIGH;
58
59  // Her çalışma durumu için ortak kural: kapak açılırsa duraklat
60  // Common rule for every running state: pause if the lid opens
61  if (calisiyor() && kapakAcik) {
62    oncekiDurum = durum;
63    kalanGecen = millis() - durumBaslangic;
64    gir(DURAKLATILDI);
65    return;
66  }
67
68  unsigned long gecen = millis() - durumBaslangic;
69  switch (durum) {
70    case BEKLEME:
71      if (baslaBasildi && !kapakAcik) gir(SU_ALMA);
72      break;
73    case SU_ALMA:
74      if (gecen >= SURE_SU) gir(YIKAMA);
75      break;
76    case YIKAMA:
77      digitalWrite(MOTOR, (gecen / 2000) % 2 == 0);  // 2 sn çalış, 2 sn dur / 2 s on, 2 s off
78      if (gecen >= SURE_YIKAMA) gir(BOSALTMA);
79      break;
80    case BOSALTMA:
81      if (gecen >= SURE_BOSALTMA) gir(SIKMA);
82      break;
83    case SIKMA:
84      if (gecen >= SURE_SIKMA) gir(BITTI);
85      break;
86    case BITTI:
87      if (gecen >= 3000) gir(BEKLEME);
88      break;
89    case DURAKLATILDI:
90      if (!kapakAcik) {
91        gir(oncekiDurum);                            // kaldığı yere dön / resume
92        durumBaslangic = millis() - kalanGecen;      // kalan süreyi koru / keep remaining time
93      }
94      break;
95  }
96}

La pausa muestra dos técnicas potentes de las máquinas de estados. La primera es una regla común: la comprobación de la tapa se hace en un solo sitio, antes del switch, para todos los estados en marcha; no se escribe en cada case por separado. La segunda es recordar el estado anterior: la variable oncekiDurum guarda de qué paso se salió y kalanGecen cuánto tiempo se había pasado en él. Al cerrar la tapa la máquina vuelve al mismo estado y la marca de tiempo se retrasa lo que ya había transcurrido, así que el paso no empieza de cero. En un aparato real, un módulo de relés mueve la válvula, el motor y la bomba en lugar de los LED.

Este ejemplo es solo una simulación con LED. No intentes sustituir la placa de control de una lavadora, un calentador o una bomba reales que funcionan con tensión de red; la tensión de red supone peligro de muerte y riesgo de incendio.

Ejecutar varias máquinas de estados a la vez

Como viste en el ejemplo del menú, cada tarea independiente puede ser su propia máquina de estados. Una buena organización es poner cada máquina en su propia función y llamar a esas funciones por turnos dentro de loop(): trafikGuncelle(), butonGuncelle(), ekranGuncelle(), etc. Como ninguna función espera, loop da una vuelta cada pocos microsegundos y todas las máquinas parecen funcionar a la vez. Las máquinas se comunican mediante variables compartidas: la del menú cambia hizMs y la del LED la lee. Es la forma más sencilla de hacer multitarea en Arduino sin un sistema operativo de verdad. Una máquina no debería cambiar directamente el estado de otra; en su lugar debe dejar una variable de petición, como la petición de peatones.

  • Usa una variable de estado y una marca de tiempo por máquina; no las compartas entre máquinas.
  • Guardar la variable de estado como static dentro de la función o en un struct propio evita choques de nombres.
  • Que sea la máquina que atiende una petición (como yayaIstegi) la que la borre.
  • Al depurar, escribe el nombre del estado en el Monitor Serie en cada cambio; verás enseguida dónde se queda atascado el programa.

Máquina de estados en MicroPython con la Raspberry Pi Pico

MicroPython no tiene enum; defines los estados como números constantes o cadenas. Gracias a los diccionarios de Python es muy fácil escribir la máquina de estados totalmente dirigida por tablas: las luces, la duración y el estado siguiente de cada estado se guardan en diccionarios, y el bucle decide consultando esas tablas. Para añadir un estado nuevo añades una línea a las tablas, no al código. Para temporizar se usan time.ticks_ms() y time.ticks_diff(); ticks_diff da la diferencia correcta incluso cuando el contador se desborda. En el código de abajo los LED están en GP13 (rojo), GP12 (ámbar) y GP11 (verde), y el pulsador de peatones en GP4. Si eres nuevo en MicroPython, empieza por el artículo fundamentos de MicroPython.

MicroPython
1# Raspberry Pi Pico MicroPython: tablo tabanlı trafik lambası durum makinesi
2# Table-driven traffic light state machine
3from machine import Pin
4import time
5
6kirmizi = Pin(13, Pin.OUT)
7sari = Pin(12, Pin.OUT)
8yesil = Pin(11, Pin.OUT)
9buton = Pin(4, Pin.IN, Pin.PULL_UP)
10
11KIRMIZI, KIRMIZI_SARI, YESIL, SARI = 0, 1, 2, 3      # durumlar / states
12ADLAR = ("KIRMIZI", "KIRMIZI_SARI", "YESIL", "SARI")
13LAMBALAR = {KIRMIZI: (1, 0, 0), KIRMIZI_SARI: (1, 1, 0), YESIL: (0, 0, 1), SARI: (0, 1, 0)}
14SURE = {KIRMIZI: 5000, KIRMIZI_SARI: 1500, YESIL: 10000, SARI: 2000}
15SONRAKI = {KIRMIZI: KIRMIZI_SARI, KIRMIZI_SARI: YESIL, YESIL: SARI, SARI: KIRMIZI}
16
17durum = KIRMIZI
18baslangic = time.ticks_ms()
19yaya_istegi = False
20
21def gir(yeni):
22    global durum, baslangic, yaya_istegi
23    durum = yeni
24    baslangic = time.ticks_ms()
25    k, s, y = LAMBALAR[yeni]
26    kirmizi.value(k)
27    sari.value(s)
28    yesil.value(y)
29    if yeni == KIRMIZI:
30        yaya_istegi = False          # yayalar geçer / pedestrians cross
31    print("durum:", ADLAR[yeni])
32
33gir(KIRMIZI)
34while True:
35    if buton.value() == 0:
36        yaya_istegi = True
37    gecen = time.ticks_diff(time.ticks_ms(), baslangic)   # taşmaya dayanıklı / overflow safe
38    sure = SURE[durum]
39    if durum == YESIL and yaya_istegi:
40        sure = 4000
41    if gecen >= sure:
42        gir(SONRAKI[durum])
43    time.sleep_ms(10)

Errores comunes y soluciones

ErrorSíntomaSolución
delay() dentro de un estadoLos botones y las demás máquinas se congelanEn lugar de esperar, comprueba el tiempo transcurrido con millis()
Olvidar el breakEl código de un estado ejecuta también el del siguienteTermina cada case con break
No reiniciar la marca de tiempoEl estado nuevo termina al instante o nuncaHaz todas las transiciones con una única función durumDegistir()
Mirar el nivel del botónUna pulsación provoca varias transicionesDetecta el instante de la pulsación y aplica antirrebote
Repetir la acción de entrada dentro del estadoEl Monitor Serie se llena, el zumbador no paraPasa el trabajo de una sola vez a la acción de entrada
Un estado sin salidaEl programa se queda para siempre en un estadoComprueba que de cada estado sale al menos una flecha
Escribir la comparación de millis() con una sumaLa temporización falla a los 49,7 díasUsa siempre la forma millis() - inicio >= duracion
Si tu número de estados empieza a pasar de 8–10, plantéate dividir la máquina: por ejemplo, en la lavadora "elegir programa" y "ejecutar programa" podrían ser dos máquinas separadas. Varias máquinas pequeñas que hablan mediante variables de petición se entienden mucho mejor que una sola gigantesca.

Ideas de proyectos con máquinas de estados

  • Caja fuerte con código: una cerradura con teclado y servo y los estados KILITLI (cerrada), SIFRE_GIRILIYOR (introduciendo código), ACIK (abierta) y ALARM; con un código erróneo suena el zumbador en el estado ALARM.
  • Juego de memoria Simon: un juego que muestra una secuencia de LED al jugador y lee los pulsadores, con los estados GOSTER (mostrar), BEKLE (esperar), KONTROL (comprobar) y KAYBETTIN (perdiste).
  • Luz inteligente de escalera: iluminación con los estados BOS (reposo), YANIYOR (encendida) y SONUYOR (apagándose) que se enciende al detectar movimiento y se apaga poco a poco al acabar el tiempo.
  • Test de reacción: un juego con los estados HAZIR (preparado), RASTGELE_BEKLE (espera aleatoria), OLC (medir) y SONUC (resultado) que mide el tiempo de reacción en milisegundos.
  • Robot que recibe órdenes por serie: un vehículo con los estados DUR (parar), ILERI (avanzar), DON (girar) y ENGEL (obstáculo) que reacciona a sensores y órdenes a la vez.

Una máquina de estados convierte cualquier proyecto de Arduino en un código más ordenado, que responde más rápido y crece con más facilidad. En la app BlueGrays encontrarás proyectos como un semáforo, el control de un LED con un pulsador, un contador con display de 7 segmentos, una cerradura con teclado, el juego Simon y un semáforo de cuatro modos con la Raspberry Pi Pico, cada uno con esquema y código paso a paso; aplícales la estructura de máquina de estados de esta guía.

Preguntas frecuentes

¿Qué es una máquina de estados en Arduino?

Una máquina de estados es una estructura de código que divide el programa en un número limitado de estados y solo está en uno de ellos cada vez. En cada estado está claro qué hacer y con qué condición pasar a otro. En Arduino se suele escribir con enum, switch-case y millis().

¿Cómo se usa enum en Arduino?

Se define como enum Durum { BEKLE, CALIS, BITTI }; y se crea una variable con Durum durum = BEKLE;. El compilador convierte los nombres en números como 0, 1 y 2, pero en el código usas nombres con significado. La definición del enum debe ir al principio del archivo, antes de las funciones.

¿Cómo se escribe una máquina de estados con switch-case?

Pones la variable de estado en switch(durum) y escribes un bloque case para cada estado. En cada bloque compruebas la condición de salida de ese estado y, si se cumple, cambias de estado. No olvides poner break al final de cada case.

¿Cómo esperar en Arduino sin delay?

Guarda con millis() el instante en que entras en un estado y comprueba en cada vuelta de loop la condición millis() - inicio >= duracion. Si no ha pasado el tiempo, loop sigue enseguida y las demás tareas no se bloquean. Este método funciona bien incluso cuando millis() se desborda.

¿Puede un Arduino hacer varias cosas a la vez?

El Arduino Uno tiene un solo núcleo, así que no hace las cosas realmente a la vez, pero con máquinas de estados que no bloquean las ejecuta por turnos miles de veces por segundo y parecen simultáneas. Basta con poner cada tarea en su función y llamarlas por turnos dentro de loop().

¿Cómo se escribe una máquina de estados en MicroPython?

MicroPython no tiene enum, así que los estados se definen como números constantes. Es muy práctico usar una estructura dirigida por tablas que guarda en diccionarios la duración, las salidas y el estado siguiente de cada estado. Para temporizar se usan time.ticks_ms() y time.ticks_diff().

Ver todos los proyectos
Semáforo
AR-3Principiante

Semáforo

Una copia en miniatura del semáforo que ves cada día en la calle. El rojo se queda dos segundos, el amarillo brilla un instante, el verde se queda dos segundos y luego vuelve al rojo pasando otra vez…

4.8(137)
440
Encender y apagar un LED con un botón
AR-10Principiante

Encender y apagar un LED con un botón

Pulsas el botón una vez y la luz se enciende, lo pulsas otra vez y se apaga, igual que el interruptor de tu habitación.

4.7(103)
177
ESP32 Semáforo
ES-5Principiante

ESP32 Semáforo

Simulación de un semáforo real con 3 LED rojo-amarillo-verde. Los tiempos se aproximan a la lógica del tráfico real: rojo largo, amarillo corto, verde largo. Ejemplo clásico de control GPIO secuencial.

4.4(22)
45
Simulador de Semáforo Raspberry Pi Pico (3 LEDs Secuenciales)
PI-4Principiante

Simulador de Semáforo Raspberry Pi Pico (3 LEDs Secuenciales)

Simulamos un semáforo real con LEDs rojo, amarillo y verde. Verde 4 seg "pase", amarillo 1,5 seg "prepárese", rojo 3 seg "detenga" y rojo+amarillo 1 seg "arranque" (patrón europeo). Aprende definición de función, lógica de máquina de estados y sincronización multi-GPIO. Circuito simple: 3 LEDs en GP11/GP12/GP13.

4.0(1)
12
Semáforo Raspberry Pi Pico con selector de 4 modos (máquina de estados)
PI-12Intermedio

Semáforo Raspberry Pi Pico con selector de 4 modos (máquina de estados)

¡4 modos de semáforo con 1 botón! Cada pulsación cambia de modo: ciclo normal (rojo → amarillo → verde), solo rojo (alto), amarillo intermitente (precaución/modo noche) y apagado (mantenimiento). Aprenderás la máquina de estados (la variable mode decide qué comportamiento se ejecuta) y a recorrer los modos con (mode + 1) % 4.

5.0(1)
16
Contador con display de 7 segmentos y botones
AR-43Avanzado
Premium

Contador con display de 7 segmentos y botones

Un contador sencillo con tres botones: con uno el número de la pantalla sube de uno en uno, con otro baja, y el tercero lo devuelve a cero.

4.6(35)
47
Cerradura con contraseña, teclado 4x4 y LCD
AR-64Avanzado
Premium

Cerradura con contraseña, teclado 4x4 y LCD

Una pequeña cerradura electrónica que no deja pasar a quien no sepa la clave. Pulsas la tecla de almohadilla y escribes la clave en el teclado; si es correcta, la pantalla indica acceso permitido, se…

4.8(59)
75
Juego de memoria con Arduino (4 LED + 4 pulsadores + zumbador)
AR-93Avanzado
Premium

Juego de memoria con Arduino (4 LED + 4 pulsadores + zumbador)

¿Te fías de tu memoria? Cuatro LED de colores se encienden en secuencia, cada uno con su propia nota, y tú repites el mismo orden pulsando los botones.

4.8(46)
69