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.
| Concepto | Significado | Ejemplo del semáforo |
|---|---|---|
| Estado | La situación actual del sistema | KIRMIZI (rojo), KIRMIZI_SARI (rojo-ámbar), YESIL (verde), SARI (ámbar) |
| Transición | Paso de un estado a otro | De YESIL a SARI |
| Condición o evento | Lo que dispara la transición | Han pasado 10 segundos o se ha pulsado el botón de peatones |
| Acción de entrada | Trabajo que se hace una vez al entrar | Encender el LED verde y apagar los demás |
| Acción en el estado | Trabajo que se hace continuamente en el estado | Leer 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ística | Código con delay() | Máquina de estados |
|---|---|---|
| ¿Se leen los botones mientras espera? | No | Sí |
| Varias tareas a la vez | Difícil, el código se enreda | Fácil, cada tarea en su máquina |
| Añadir un estado nuevo | Hay que reescribir todo el flujo | Se añade un case nuevo |
| Depuración | No se sabe dónde está el programa | Basta con escribir el nombre del estado en el Monitor Serie |
| Memoria | Poca | Poca (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.
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}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.
- Enumera todos los estados del sistema y dale a cada uno un nombre corto en mayúsculas.
- Elige el estado inicial; el Arduino estará en él al encenderse o reiniciarse.
- Escribe las condiciones de salida de cada estado: tiempo, botón, sensor u otro evento.
- Añade el estado de destino de cada transición y la acción que haya que hacer en ella.
- Decide la acción de entrada de cada estado: ¿qué salidas estarán encendidas y cuáles apagadas?
- Anota aparte las reglas comunes que valen en todos los estados (parada de emergencia, apertura de la tapa).
- Convierte el diagrama en una tabla de transiciones como la de abajo y escribe cada fila como un if dentro de un case.
| Estado | Condición | Estado siguiente | Acción de entrada |
|---|---|---|---|
| KIRMIZI | Pasan 5 s | KIRMIZI_SARI | Rojo encendido, se borra la petición de peatones |
| KIRMIZI_SARI | Pasan 1,5 s | YESIL | Rojo y ámbar encendidos |
| YESIL | Pasan 10 s, o 4 s si hay petición | SARI | Verde encendido |
| SARI | Pasan 2 s | KIRMIZI | Á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.

| Pieza | Pin del Arduino Uno | Nota |
|---|---|---|
| LED rojo | D8 | Con resistencia de 220 Ω, pata corta a GND |
| LED ámbar | D9 | Con resistencia de 220 Ω |
| LED verde | D10 | Con resistencia de 220 Ω (pin con PWM) |
| Zumbador | D11 | Solo en el ejemplo de la lavadora |
| Pulsador 1 | D2 | La otra pata a GND, INPUT_PULLUP |
| Pulsador 2 | D3 | La otra pata a GND, INPUT_PULLUP |
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ú.

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.
| Estado | D2 (siguiente) | D3 (OK) |
|---|---|---|
| MENU_PARLAKLIK | Ir a MENU_HIZ | Entrar en AYAR_PARLAKLIK |
| MENU_HIZ | Ir a MENU_PARLAKLIK | Entrar en AYAR_HIZ |
| AYAR_PARLAKLIK | Subir el brillo 51 (tras 255 vuelve a 51) | Guardar, volver a MENU_PARLAKLIK |
| AYAR_HIZ | Subir 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.
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.
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.
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
| Error | Síntoma | Solución |
|---|---|---|
| delay() dentro de un estado | Los botones y las demás máquinas se congelan | En lugar de esperar, comprueba el tiempo transcurrido con millis() |
| Olvidar el break | El código de un estado ejecuta también el del siguiente | Termina cada case con break |
| No reiniciar la marca de tiempo | El estado nuevo termina al instante o nunca | Haz todas las transiciones con una única función durumDegistir() |
| Mirar el nivel del botón | Una pulsación provoca varias transiciones | Detecta el instante de la pulsación y aplica antirrebote |
| Repetir la acción de entrada dentro del estado | El Monitor Serie se llena, el zumbador no para | Pasa el trabajo de una sola vez a la acción de entrada |
| Un estado sin salida | El programa se queda para siempre en un estado | Comprueba que de cada estado sale al menos una flecha |
| Escribir la comparación de millis() con una suma | La temporización falla a los 49,7 días | Usa siempre la forma millis() - inicio >= duracion |
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().
Proyectos para hacer después de leer esto
Ver todos los proyectos
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…

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.

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.

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.

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.

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.

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…

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.
Más artículos
App BlueGrays
Monta este circuito paso a paso en tu teléfono
Esquema, código y lista de piezas en una sola pantalla. Más de 500 proyectos de Arduino, ESP32 y Pico listos para montar.
Escanea con tu teléfono
Apunta la cámara al código y se abrirá la tienda de apps de tu teléfono.
o ábrela en la tienda

