Arduino multitarea: varias tareas a la vez con millis()
- 526componentes en el banco de trabajo
- 46placas funcionando ahora
- 1.00xtiempo real, en todas las placas
Un Arduino Uno tiene un solo núcleo y no tiene sistema operativo, así que nunca ejecuta dos cosas en el mismo instante. Aun así puede atender varias tareas a la vez, siempre que cada tarea tome un momento y devuelva el control. El patrón se llama multitarea cooperativa: loop() ejecuta cada tarea una vez por pasada, cada tarea consulta millis() para ver si le toca, y nada espera nunca dentro de delay().
El circuito de arriba es el banco de código del curso de C++: tres LEDs en los pines 13, 12 y 11 y un botón en el pin 2. Su sketch parpadea los tres LEDs a 200, 330 y 1100 ms y mide su propio loop. El monitor serie imprime "peor pasada por loop: 2 ms" cada dos segundos, y por eso los tres ritmos se mantienen correctos.
Abajo verás por qué delay() no puede hacer esto, cuatro tareas escritas al estilo millis(), una clase por tarea, lo que hace una tarea que bloquea a las demás, y la biblioteca TaskScheduler, que ejecuta el mismo patrón por ti.
¿Quieres la versión paso a paso? La lección "Pregunta la hora, no la esperes" recorre esto con puntos de control.
Abrir la lecciónPor qué delay() solo puede hacer una cosa
delay() detiene todo el sketch. Mientras cuenta, ninguna otra línea se ejecuta, así que un sketch que parpadea con delay() lee su botón una vez por parpadeo como mucho. El sketch de abajo parpadea el pin 13 con dos delays de un segundo y revisa el botón después de ellos.
Mantuvimos el botón presionado de 0.5 s a 1.4 s y no pasó nada: la presión empezó y terminó mientras el sketch estaba dentro de un delay(). Una segunda presión sostenida desde 2.3 s solo se notó cuando el sketch llegó a ella, y el monitor serie imprimió "presión vista en 3999", con 1.7 segundos de retraso. Hacer los delays más cortos reduce el retraso pero nunca lo elimina.
const int BUTTON = 2;
void setup() {
Serial.begin(9600);
pinMode(13, OUTPUT);
pinMode(12, OUTPUT);
pinMode(BUTTON, INPUT_PULLUP);
}
void loop() {
digitalWrite(13, HIGH);
delay(1000);
digitalWrite(13, LOW);
delay(1000);
if (digitalRead(BUTTON) == LOW) {
digitalWrite(12, HIGH);
Serial.print("press seen at ");
Serial.println(millis());
}
}Abrir este sketch en el editorSolo el código: el editor coloca la placa y los componentes que puede leer del sketch.
Cuatro tareas en un loop
Dale a cada tarea una función y su propia variable de "última vez que corrí". En cada pasada, loop() lee millis() una vez y se lo pasa a cada tarea; una tarea a la que aún no le toca regresa de inmediato. Aquí un parpadeo lento en el pin 13 corre cada 1000 ms, uno rápido en el pin 12 cada 150 ms, un botón alterna el pin 11 y un reporte se imprime cada dos segundos.
Con las mismas dos presiones, el monitor serie imprimió "presión vista en 499" y "presión vista en 2298": cada presión se detectó a un milisegundo de haber empezado, mientras ambos LEDs mantenían sus ritmos. Luego "presiones hasta ahora: 1" y "presiones hasta ahora: 2" llegaron a tiempo desde la tarea de reporte.
Dos detalles importan. Guarda cada tiempo en un unsigned long y compara now - last >= interval, para que la suma siga funcionando cuando millis() se desborde después de 49.7 días. Y la tarea del botón ignora cualquier cambio dentro de los 20 ms del anterior, porque un botón real rebota y el simulado también lo hace; sin eso, una sola presión cuenta varias veces.
const int BUTTON = 2;
unsigned long lastBlink = 0;
unsigned long lastFlash = 0;
unsigned long lastReport = 0;
unsigned long lastChange = 0;
bool blinkOn = false;
bool flashOn = false;
bool wasPressed = false;
int presses = 0;
void setup() {
Serial.begin(9600);
pinMode(13, OUTPUT);
pinMode(12, OUTPUT);
pinMode(11, OUTPUT);
pinMode(BUTTON, INPUT_PULLUP);
}
void blinkTask(unsigned long now) {
if (now - lastBlink >= 1000) {
lastBlink = now;
blinkOn = !blinkOn;
digitalWrite(13, blinkOn);
}
}
void flashTask(unsigned long now) {
if (now - lastFlash >= 150) {
lastFlash = now;
flashOn = !flashOn;
digitalWrite(12, flashOn);
}
}
void buttonTask(unsigned long now) {
bool pressed = digitalRead(BUTTON) == LOW;
if (pressed != wasPressed && now - lastChange >= 20) {
lastChange = now;
wasPressed = pressed;
if (pressed) {
presses++;
digitalWrite(11, presses % 2);
Serial.print("press seen at ");
Serial.println(now);
}
}
}
void reportTask(unsigned long now) {
if (now - lastReport >= 2000) {
lastReport = now;
Serial.print("presses so far: ");
Serial.println(presses);
}
}
void loop() {
unsigned long now = millis();
blinkTask(now);
flashTask(now);
buttonTask(now);
reportTask(now);
}Abrir este sketch en el editorSolo el código: el editor coloca la placa y los componentes que puede leer del sketch.
Una clase por tarea
Cuando tres tareas hacen el mismo trabajo con números distintos, escribe el trabajo una sola vez como clase y crea tres de ellas. Cada Blinker guarda su propio pin, intervalo, última vez y estado, así que agregar un cuarto LED es una línea. Esta es la forma que usan por dentro la mayoría de las bibliotecas de multitarea.
Al ejecutarlo durante tres segundos, el sketch imprimió "después de 3 s: 6, 15, 59": seis conmutaciones a 500 ms, quince a 200 ms y cincuenta y nueve a 50 ms, la última cayendo un momento después del reporte.
class Blinker {
public:
Blinker(int pin, unsigned long everyMs) : pin_(pin), everyMs_(everyMs) {}
void begin() {
pinMode(pin_, OUTPUT);
}
void update(unsigned long now) {
if (now - last_ >= everyMs_) {
last_ = now;
on_ = !on_;
digitalWrite(pin_, on_);
toggles_++;
}
}
unsigned long toggles() const {
return toggles_;
}
private:
int pin_;
unsigned long everyMs_;
unsigned long last_ = 0;
bool on_ = false;
unsigned long toggles_ = 0;
};
Blinker slow(13, 500);
Blinker mid(12, 200);
Blinker fast(11, 50);
bool reported = false;
void setup() {
Serial.begin(9600);
slow.begin();
mid.begin();
fast.begin();
}
void loop() {
unsigned long now = millis();
slow.update(now);
mid.update(now);
fast.update(now);
if (!reported && now >= 3000) {
reported = true;
Serial.print("after 3 s: ");
Serial.print(slow.toggles());
Serial.print(", ");
Serial.print(mid.toggles());
Serial.print(", ");
Serial.println(fast.toggles());
}
}Abrir este sketch en el editorSolo el código: el editor coloca la placa y los componentes que puede leer del sketch.
Una tarea que bloquea frena a todas
Cooperativo significa que cada tarea tiene que cooperar. El sketch del banco de arriba mide la pasada más larga por loop(), y con tres tareas bien comportadas imprimió "peor pasada por loop: 2 ms". Agregamos delay(250); solo a la tarea más lenta e imprimió "peor pasada por loop: 250 ms": mientras esa tarea esperaba, el LED de 200 ms perdió su turno y el botón habría quedado sin leer.
Los culpables habituales son delay(), un while que espera un pin, pulseIn() con un timeout largo y una impresión larga a una velocidad de baudios baja. Divide una tarea lenta en pasos, con una variable que recuerde qué paso sigue, y deja que loop() vuelva a pasar entre ellos. Eso es una máquina de estados, y es la siguiente página para leer.
La biblioteca TaskScheduler
TaskScheduler se encarga de la contabilidad: creas una Task con un intervalo, un contador y una función, la agregas a un Scheduler y llamas runner.execute() en loop(). Sigue siendo cooperativo, así que la misma regla aplica, y una función callback que bloquea bloquea todas las tareas. Mokxi la trae integrada; el sketch de abajo corrió en el Uno tal cual está escrito.
Imprimió "slow 1, fast 1" de una vez, porque una tarea se ejecuta apenas se habilita, luego "slow 5, fast 21" a los dos segundos y "slow 8, fast 40" a los cuatro. El informe vence en el mismo milisegundo que ambos parpadeos, así que si un parpadeo ya contó en ese milisegundo depende de en qué punto de su pasada esté el planificador.
#include <TaskScheduler.h>
void blinkSlow();
void blinkFast();
void report();
Scheduler runner;
Task slowTask(500, TASK_FOREVER, &blinkSlow);
Task fastTask(100, TASK_FOREVER, &blinkFast);
Task reportTask(2000, TASK_FOREVER, &report);
int slowRuns = 0;
int fastRuns = 0;
void blinkSlow() {
digitalWrite(13, !digitalRead(13));
slowRuns++;
}
void blinkFast() {
digitalWrite(12, !digitalRead(12));
fastRuns++;
}
void report() {
Serial.print("slow ");
Serial.print(slowRuns);
Serial.print(", fast ");
Serial.println(fastRuns);
}
void setup() {
Serial.begin(9600);
pinMode(13, OUTPUT);
pinMode(12, OUTPUT);
runner.addTask(slowTask);
runner.addTask(fastTask);
runner.addTask(reportTask);
slowTask.enable();
fastTask.enable();
reportTask.enable();
}
void loop() {
runner.execute();
}Abrir este sketch en el editorSolo el código: el editor coloca la placa y los componentes que puede leer del sketch.
Abre este circuito en el editor. Arduino Uno: tres LEDs en tres relojes, desde un solo loop, conectado como funciona en la parte superior de esta página. Cambia un componente o un valor y ejecútalo de nuevo.
Preguntas
¿Puede un Arduino Uno hacer varias tareas a la vez?
No de verdad: tiene un solo núcleo y ejecuta una instrucción a la vez. Puede atender muchas tareas a la vez ejecutando cada una por un momento en cada pasada de loop(), usando millis() en lugar de delay(), lo cual es suficientemente rápido para que las tareas parezcan ejecutarse juntas.
¿Por qué mi botón no funciona mientras un LED parpadea?
El parpadeo usa delay(), y nada más se ejecuta durante un delay. Una pulsación que empieza y termina dentro de uno se pierde, y una que dura más se detecta tarde. Cronometra el parpadeo con millis() y revisa el botón en cada pasada de loop().
¿Cuál es la mejor biblioteca de multitarea para Arduino?
TaskScheduler es una opción común y funciona en el Uno; también hay otras más pequeñas. Todas hacen lo que el sketch de cuatro tareas hace a mano, así que aprender primero el patrón facilita leer cualquier biblioteca.
¿Un ESP32 hace multitarea de otra forma?
Un ESP32 real ejecuta FreeRTOS, así que xTaskCreate() crea tareas verdaderas con su propia pila, en ambos núcleos de un ESP32 clásico. Mokxi ejecuta el sketch del ESP32 en un núcleo sin planificador: xTaskCreate() dice una vez en el monitor serie que la tarea no se ejecuta. El patrón de millis() de esta página funciona igual en ambos.
¿Cuántas tareas puede ejecutar loop()?
Tantas como quepan en memoria, siempre que cada una regrese rápido. Mide la pasada más larga por loop(), como lo hace el sketch de banco de trabajo; si se mantiene en unos pocos milisegundos, cada tarea conserva su temporización.
Sigue así
De dónde vienen los datos de esta página
Á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.