Por qué delay() bloquea, y qué usar en su lugar
- 526componentes en el banco de trabajo
- 46placas funcionando ahora
- 1.00xtiempo real, en todas las placas
delay(500) hace exactamente lo que dice: detiene el sketch, por completo, durante quinientos milisegundos. Nada más en loop() se ejecuta, ningún otro pin cambia, no se leen datos serie, hasta que termina la espera. Eso está bien para un solo LED parpadeando, porque no hay nada más que el sketch necesite hacer mientras tanto. Deja de funcionar en el momento en que hay dos cosas que deben ocurrir con su propio ritmo, porque un segundo delay() solo puede ejecutarse después de que termine el primero, lo que significa que las dos cosas nunca pueden ser realmente independientes.
Vale la pena construir esto una vez precisamente porque la mayoría de los tutoriales para principiantes enseñan delay() primero, con buena razón: es la forma más fácil posible de hacer parpadear un LED, y es correcto para ese único trabajo. El problema solo aparece cuando un sketch crece más allá de su primer LED, que es justo el momento en que un principiante está menos preparado para un cambio en cómo funciona la temporización, así que vale la pena conocer el límite deliberadamente aquí, en un circuito pequeño, en lugar de conocerlo por primera vez en medio de un proyecto más grande.
The circuit above is the demonstration: two LEDs, one on pin 13 blinking every 250 milliseconds and one on pin 12 blinking every 400 milliseconds, both timed from the same loop with no delay() anywhere in it. Watch them for a few seconds and the two rates visibly drift in and out of phase with each other, because 250 and 400 only line up again every two seconds, which is exactly what two independent rates should do, and exactly what two lamps sharing one delay() call could never manage.
Qué hace realmente delay()
En el chip real, y en el modelo de Mokxi, delay() no es un bucle que ocupa la CPU girando sin motivo: el sketch blink del propio Uno depende de un tic de temporizador de hardware y deja dormir al núcleo entre tics, lo cual es eficiente y correcto para exactamente una tarea a la vez. El problema nunca fue que delay() desperdicie recursos. El problema es que es total: mientras se ejecuta, el sketch no puede hacer absolutamente nada más, incluido revisar un segundo temporizador que se supone que corre de forma independiente.
La forma de máquina de estados
La solución es dejar de esperar y empezar a preguntar la hora. Para cada cosa que necesita su propio horario, guarda el momento en que ocurrió por última vez, y en cada pasada por loop() pregunta si ya pasó suficiente tiempo: if (now - lastTime >= INTERVAL) { lastTime = now; ...act... }. El propio loop() nunca se detiene; simplemente no hace nada, en la mayoría de las pasadas, para los temporizadores que todavía no llegan a su momento.
Two details in that line are not optional. now and lastTime have to be unsigned long, because that is the type millis() returns and the type the subtraction has to happen in. And the comparison has to be a subtraction, now - lastTime, rather than an addition like lastTime + INTERVAL, because subtracting two unsigned longs comes out correct even across the roll-over that happens roughly every 49.7 days, when millis() wraps back to zero. An addition-based comparison breaks exactly at that boundary; the subtraction never does.
This shape scales past two timers with no change to it at all. The Uno's built-in cpptiming example runs three lamps at three unrelated rates, 200, 330 and 1100 milliseconds, from a small array of little structs, each holding its own pin, interval and last-fired time, and one loop that checks all three the same way this page's two-lamp version checks two. It also prints the longest a single pass through loop() has ever taken, which stays at 2 milliseconds or less as long as nothing in the sketch blocks (2 rather than 1, because millis() itself now and then jumps by 2), and climbs the moment something does. That number is a genuinely useful thing to watch in a sketch you are not sure is blocking anywhere: a loop() that is meant to be instant and suddenly is not has a delay(), or something that behaves like one, hiding in it somewhere.
Dos temporizadores a la vez
El programa integrado tworates del Uno es el circuito de arriba, corriendo tal como se muestra: dos tareas independientes, dos intervalos, un loop, sin delay().
const int RED_PIN = 13;
const int GREEN_PIN = 12;
const unsigned long RED_MS = 250;
const unsigned long GREEN_MS = 400;
unsigned long lastRed = 0;
unsigned long lastGreen = 0;
bool redOn = false;
bool greenOn = false;
void loop() {
unsigned long now = millis();
if (now - lastRed >= RED_MS) {
lastRed = now;
redOn = !redOn;
digitalWrite(RED_PIN, redOn ? HIGH : LOW);
}
if (now - lastGreen >= GREEN_MS) {
lastGreen = now;
greenOn = !greenOn;
digitalWrite(GREEN_PIN, greenOn ? HIGH : LOW);
}
}Lo que intentarías con delay(), y por qué deja de escalar
Es posible hacer que dos lámparas se alternen con nada más que delay(), y el programa integrado twoleds del Uno hace exactamente eso: enciende la lámpara roja y apaga la verde, espera, luego las intercambia, espera otra vez. Visto por sí solo, parece mucho tener dos frecuencias. No lo es: ambas lámparas están trabadas a la misma espera de medio segundo, porque solo hay una espera en todo el sketch. Intenta darle a la lámpara verde una frecuencia que no divida exactamente a la de la roja, sin tocar millis(), y no hay forma de escribirlo: una tercera llamada a delay() solo puede correr cuando las otras dos hayan terminado, así que una tercera frecuencia independiente no es un paso más difícil, es imposible con esta forma.
Leer un botón en el mismo loop
El verdadero beneficio de este patrón aparece cuando un sketch necesita hacer más que parpadear. Un loop() construido alrededor de delay() no puede revisar un botón, imprimir en el monitor serie ni actualizar una pantalla mientras espera un parpadeo; un loop() construido alrededor de revisiones de millis() hace todo eso con solo más bloques if que corren en cada pasada, así que una lectura de botón convive cómodamente junto a dos temporizadores de parpadeo independientes sin que nada de ninguno cambie. Esta es también la forma que usa la página sobre rebotes de un botón para su propia solución, y no es coincidencia: es el mismo problema, cronometrar algo sin bloquear todo lo demás, resuelto de la misma manera.
Abre este circuito en el editor. Arduino Uno: dos frecuencias, sin delay, cableado tal como corre en la parte superior de esta página. Cambia un componente o un valor y ejecútalo de nuevo.
Preguntas
¿Qué pasa cuando millis() se desborda después de 49.7 días?
La resta de unsigned en now - lastTime se desborda correctamente y sigue produciendo el intervalo correcto, que es toda la razón por la que el patrón se escribe como una resta y no como lastTime + INTERVAL comparado con now.
Is delay() ever fine to use?
Sí, para un sketch que de verdad no tiene nada más que hacer mientras espera, o para una espera muy corta en setup(). En el momento en que un segundo temporizador independiente, una lectura de botón o una revisión serie tenga que ocurrir durante esa espera, delay() es la herramienta equivocada.
¿Cómo agrego un tercer temporizador a una tercera frecuencia?
Agrega una tercera variable lastTime, un tercer intervalo y un tercer bloque if, exactamente con la forma de los dos que ya están. Nada del patrón cambia a medida que se unen más temporizadores, y ese es el punto de escribirlo así.
¿Usar interrupciones reemplaza este patrón?
Resuelven un problema distinto: una interrupción reacciona a un evento (un flanco, un desbordamiento de temporizador) en el instante en que ocurre, mientras que el cronometraje con millis() es para tareas que solo necesitan ocurrir según un horario que loop() puede revisar por sí mismo. Muchos sketches usan ambos.
¿Por qué usar unsigned long y no int para las variables de tiempo?
millis() devuelve un unsigned long porque el conteo necesita más rango del que da un int de 16 bits en un Uno; guardarlo en un tipo más pequeño o con signo trunca o malinterpreta el valor mucho antes de que el desborde de 49.7 días llegue a ser el problema.
¿Para qué sirve micros(), si millis() ya existe?
Para una resolución más fina, en microsegundos en lugar de milisegundos, para cronometrajes que necesitan ser más precisos que un milisegundo, a cambio de desbordarse mucho antes, aproximadamente cada 71 minutos en lugar de cada 49.7 días. El mismo patrón de resta de arriba funciona sin cambios.
Sigue así
Á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.