Nivel avanzado7 min de lectura · Publicado el

Multitarea en Arduino sin delay: millis y máquina de estados

Multitarea en Arduino sin delay(): un semáforo que mira el reloj con millis() y dos LED, en los pines 3 y 12, que parpadean cada uno a su ritmo. Sin delay(): mira millis()rubentejera.com millis()delay()pin 3pin 12900 ms
Como un semáforo que no se duerme: en cada vuelta de loop(), cada LED mira millis() y cambia de estado si ya le toca. Así el del pin 3 se enciende y se apaga cada 100 ms y el del pin 12 se queda 900 ms encendido.

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:

Diagrama de estados proyectado en una pantalla: desde «inicio» se pasa a «led encendido»; cuando expira el temporizador se pasa a «led apagado» y, cuando vuelve a expirar, otra vez a «led encendido»
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: previusClock tenía una errata y actualState es un falso amigo (actual significa «real», no «actual»). Ahora son lastChange y state.
  • 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 long y 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() y digitalWrite() por una simulación de 1000 ms. No se han probado en una placa real en esta revisión.