Multitarea en Arduino sin delay: millis y máquina de estados
Quieres que cuatro LED parpadeen a la vez, cada uno a su ritmo. Con delay() no puedes: mientras espera, Arduino no hace nada más. La documentación de Arduino lo compara con quedarse mirando el temporizador del microondas: si llega un correo importante mientras tanto, te lo pierdes.
La solución es una máquina de estados: cada LED recuerda si está encendido o apagado y desde cuándo. Es como un semáforo: no se queda dormido esperando, sino que mira el reloj de vez en cuando y cambia de luz cuando toca.
El modelo: tres estados
El ejemplo parte de un diagrama de Avelino Herrera:
| Estado | Qué hace al entrar | Cuándo sale |
|---|---|---|
| Inicio | Configura el pin como salida | Inmediatamente, a «encendido» |
| LED encendido | Enciende el LED y anota la hora | Cuando pasa el tiempo de encendido |
| LED apagado | Apaga el LED y anota la hora | Cuando pasa el tiempo de apagado |
La clave está en millis(): devuelve los milisegundos desde que arrancó la placa. Restando la hora actual menos la hora anotada sabes cuánto tiempo lleva el LED en ese estado, sin bloquear nada.
Primera aproximación (L. Salas)
Cada LED es una estructura con su pin, sus tiempos, su estado y la hora del último cambio. El estado es un número: 0, 1 o 2.
struct Blink {
int pin;
int timeOn;
int timeOff;
int estado;
unsigned long relojAnt;
};
Blink blink1{ 3, 100, 100};
Blink blink2{ 6, 500, 300};
Blink blink3{ 9, 300, 500};
Blink blink4{12, 900, 200};
void setup() {
Serial.begin(9600);
}
void loop() {
parpadea(&blink1);
parpadea(&blink2);
parpadea(&blink3);
parpadea(&blink4);
}
void parpadea(Blink *blink) {
if (blink->estado == 0) { // Estado 0: es para inicializar
pinMode(blink->pin, OUTPUT);
digitalWrite(blink->pin, HIGH);
blink->relojAnt = millis();
blink->estado = 1;
} else if (blink->estado == 1) { // Estado 1: led on
if (millis() - blink->relojAnt > blink->timeOn) {
blink->relojAnt = millis();
digitalWrite(blink->pin, LOW);
blink->estado = 2;
}
} else if (blink->estado == 2) { // Estado 2: led off
if (millis() - blink->relojAnt > blink->timeOff) {
blink->relojAnt = millis();
digitalWrite(blink->pin, HIGH);
blink->estado = 1;
}
}
}
Funciona, pero los estados son números mágicos (hay que leer el comentario para saber qué es el 2) y toda la lógica está en una sola función.
Después del refactor (Rubén Tejera)
El refactor da nombre a los estados con un enum y separa cada acción en una función pequeña:
enum State {Initialize, LedOn, LedOff};
struct Led {
int pin;
unsigned long timeFrameOn;
unsigned long timeFrameOff;
State actualState;
unsigned long previusClock;
};
Led led1{ 3, 100, 100};
Led led2{ 6, 500, 300};
Led led3{ 9, 300, 500};
Led led4{12, 900, 200};
bool isTimeToChangeState(unsigned long previusTime, unsigned long rangeTime){
return millis() - previusTime > rangeTime;
}
void setPreviusClock(Led *led){
led->previusClock = millis();
}
void setState(Led *led, State newState){
led->actualState = newState;
}
void setPinMode(int pin, bool type){
pinMode(pin, type);
}
void setDigitalOutput(int pin, int newState){
digitalWrite(pin, newState);
}
void switchOnLed(Led *led){
setPreviusClock(led);
setDigitalOutput(led->pin, HIGH);
setState(led, LedOn);
}
void switchOffLed(Led *led){
setPreviusClock(led);
setDigitalOutput(led->pin, LOW);
setState(led, LedOff);
}
void startLed(Led *led){
setPinMode(led->pin, OUTPUT);
switchOnLed(led);
}
void blink(Led *led) {
switch ( led->actualState ){
case Initialize:
startLed(led);
break;
case LedOn:
if (isTimeToChangeState(led->previusClock, led->timeFrameOn)) {
switchOffLed(led);
}
break;
case LedOff:
if (isTimeToChangeState(led->previusClock, led->timeFrameOff)) {
switchOnLed(led);
}
break;
default:
startLed(led);
break;
}
}
void setup() {
Serial.begin(9600);
}
void loop() {
blink(&led1);
blink(&led2);
blink(&led3);
blink(&led4);
}
Ahora blink() se lee casi como el diagrama: en cada estado, si ha pasado el tiempo, cambia al siguiente.
Una vuelta más: lo que se puede pulir
Al ejecutar las dos versiones en un simulador aparece un detalle: con > el LED cambia a los 101 ms en lugar de a los 100, y ese milisegundo se acumula en cada ciclo (101, 202, 303…). El ejemplo oficial de Arduino, Blink Without Delay, usa >=. Estos son los cambios de esta versión:
>=en lugar de>, para que los tiempos sean exactos.- Nombres corregidos:
previusClocktenía una errata yactualStatees un falso amigo (actual significa «real», no «actual»). Ahora sonlastChangeystate. - Fuera los envoltorios que no añaden nada (
setPinMode,setDigitalOutput,setState):digitalWrite()ya se entiende por sí solo. - Fuera
Serial.begin(), porque el programa no escribe nada por el puerto serie. - Inicialización completa de cada
Led, para que el compilador no avise de campos sin valor.
enum State { Initialize, LedOn, LedOff };
struct Led {
uint8_t pin;
unsigned long timeOn; // milisegundos encendido
unsigned long timeOff; // milisegundos apagado
State state; // empieza en Initialize
unsigned long lastChange;
};
Led led1{ 3, 100, 100, Initialize, 0};
Led led2{ 6, 500, 300, Initialize, 0};
Led led3{ 9, 300, 500, Initialize, 0};
Led led4{12, 900, 200, Initialize, 0};
bool hasElapsed(unsigned long since, unsigned long interval) {
return millis() - since >= interval; // funciona aunque millis() se desborde
}
void switchOn(Led *led) {
digitalWrite(led->pin, HIGH);
led->lastChange = millis();
led->state = LedOn;
}
void switchOff(Led *led) {
digitalWrite(led->pin, LOW);
led->lastChange = millis();
led->state = LedOff;
}
void start(Led *led) {
pinMode(led->pin, OUTPUT);
switchOn(led);
}
void blink(Led *led) {
switch (led->state) {
case Initialize:
start(led);
break;
case LedOn:
if (hasElapsed(led->lastChange, led->timeOn)) switchOff(led);
break;
case LedOff:
if (hasElapsed(led->lastChange, led->timeOff)) switchOn(led);
break;
}
}
void setup() {
}
void loop() {
blink(&led1);
blink(&led2);
blink(&led3);
blink(&led4);
}
Mira el reloj, no te duermas esperando.
Por dónde seguir
- Añade un botón: un quinto «LED» cuyo estado cambia al pulsarlo. Verás que el resto sigue parpadeando.
- Si trabajas con un ESP8266, el mismo patrón sirve para animar una tira LED: ESP8266 con tira LED WS2812B.
- Si programas en Ruby on Rails, no hace falta escribir la máquina a mano: la gema AASM declara los estados y las transiciones de un modelo.
- Más sobre funciones pequeñas y con buen nombre en Funciones en código limpio.
Fuentes
- Documentación oficial de Arduino, comprobada en noviembre de 2026: millis() (devuelve
unsigned longy se desborda tras unos 50 días; la nota de la referencia dice 49) y el ejemplo Blink Without Delay (por quédelay()bloquea, el símil del microondas y la comparación con>=). Consultadas en sus fuentes de GitHub (reference-en y docs-content). - Las tres versiones se han compilado con g++ 15.2.0 (C++11) en un PC, sustituyendo
millis(),pinMode()ydigitalWrite()por una simulación de 1000 ms. No se han probado en una placa real en esta revisión.