Arduino millis(): temporizador, y varias cosas a la vez
- 526componentes en el banco de trabajo
- 46placas funcionando ahora
- 1.00xtiempo real, en todas las placas
millis() devuelve cuántos milisegundos han pasado desde que se encendió la placa, como unsigned long. No espera nada. Para hacer algo cada segundo, recuerda cuándo lo hiciste por última vez, y en cada vuelta de loop() pregunta si ya pasó un segundo: if (millis() - previous >= 1000). Esa sola línea es como un Arduino hace varias cosas a la vez.
El circuito de arriba es el banco de código con tres lámparas. Presiona Ejecutar. La lámpara roja cambia cada 200 ms, la amarilla cada 330 ms y la verde cada 1100 ms, todo desde un solo loop() sin ningún delay(). El monitor serie imprime "peor pasada por loop: 2 ms" cada dos segundos: ninguna pasada de loop() tardó más que eso, así que cada lámpara va a tiempo.
Abajo tienes lo que devuelve millis(), el patrón del temporizador, un sketch ejecutando tres tareas a la vez, millis() contra delay(), y los errores que hacen que un temporizador se desvíe, se detenga o se vuelva negativo, cada uno ejecutado en un Uno.
¿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ónQué devuelve millis()
Un conteo de milisegundos desde el encendido o el reinicio, empezando en 0. Este sketch lo imprime una vez por segundo e imprimió 0, 999, 1999, 3000 y 3999. El conteo es 0 al inicio de setup() porque la placa parte de cero cada vez.
Es un unsigned long, de 32 bits, así que cuenta hasta 4294967295 y luego vuelve a 0, después de unos 49.7 días. La página sobre el desbordamiento de millis() explica por qué la resta del patrón del temporizador sobrevive al desbordamiento.
void setup() {
Serial.begin(9600);
}
void loop() {
Serial.println(millis());
delay(1000);
}Abrir este sketch en el editorSolo el código: el editor coloca la placa y los componentes que puede leer del sketch.
Un temporizador con millis()
Aquí está el patrón. previous guarda cuándo se disparó el temporizador por última vez. En cada pasada, now - previous >= INTERVAL pregunta si ya pasó el intervalo, y si es así el sketch hace su trabajo y adelanta previous. El delay(7) representa el resto de un sketch real, que también tarda.
Imprimió "tick at 1003", "tick at 2001", "tick at 3006", "tick at 4003" y "tick at 5001". Cada tick puede llegar unos milisegundos tarde, porque el loop solo revisa cada 7 ms, pero el retraso no se acumula: el quinto tick sigue en 5001.
const unsigned long INTERVAL = 1000;
unsigned long previous = 0;
void setup() {
Serial.begin(9600);
}
void loop() {
unsigned long now = millis();
if (now - previous >= INTERVAL) {
previous += INTERVAL;
Serial.print("tick at ");
Serial.println(now);
}
delay(7); // stands in for the rest of a busy loop
}Abrir este sketch en el editorSolo el código: el editor coloca la placa y los componentes que puede leer del sketch.
Varias tareas a la vez
Cada tarea tiene su propio temporizador, y loop() los revisa todos en cada pasada. Este sketch parpadea el pin 13 cada 250 ms, cambia una lámpara en el pin 12 cada vez que se presiona el botón, e imprime un reporte cada segundo, todo al mismo tiempo.
Presionamos el botón tres veces, un toque rápido de 150 ms cada uno. Imprimió "1 s, presses: 1", "2 s, presses: 3" y "3 s, presses: 3", la lámpara del pin 12 cambió en cada toque, y el parpadeo del pin 13 no falló ni una vez. Agrega una cuarta tarea igual: un temporizador más, un if más.
const int BLINK_LED = 13;
const int LAMP = 12;
const int BUTTON = 2;
unsigned long lastBlink = 0;
unsigned long lastChange = 0;
unsigned long lastReport = 0;
int lastReading = HIGH;
bool blinkOn = false;
bool lampOn = false;
int presses = 0;
void setup() {
Serial.begin(9600);
pinMode(BLINK_LED, OUTPUT);
pinMode(LAMP, OUTPUT);
pinMode(BUTTON, INPUT_PULLUP);
}
void loop() {
unsigned long now = millis();
// Task 1: blink pin 13 every 250 ms.
if (now - lastBlink >= 250) {
lastBlink = now;
blinkOn = !blinkOn;
digitalWrite(BLINK_LED, blinkOn ? HIGH : LOW);
}
// Task 2: each press flips the lamp on pin 12.
int reading = digitalRead(BUTTON);
if (reading != lastReading && now - lastChange > 50) {
lastChange = now;
lastReading = reading;
if (reading == LOW) {
presses++;
lampOn = !lampOn;
digitalWrite(LAMP, lampOn ? HIGH : LOW);
}
}
// Task 3: report once a second.
if (now - lastReport >= 1000) {
lastReport = now;
Serial.print(now / 1000);
Serial.print(" s, presses: ");
Serial.println(presses);
}
}Abrir este sketch en el editorSolo el código: el editor coloca la placa y los componentes que puede leer del sketch.
millis() contra delay()
Aquí está el mismo parpadeo y botón escritos con delay(). El sketch pasa todo su tiempo dentro de delay(), así que solo lee el botón un momento una vez por segundo. Los mismos tres toques de 150 ms imprimieron "pressed" una sola vez. Dos de los tres llegaron y se fueron mientras el sketch esperaba.
delay() está bien cuando la placa tiene una sola cosa que hacer. En cuanto tiene dos, cambia a millis().
const int BUTTON = 2;
void setup() {
Serial.begin(9600);
pinMode(13, OUTPUT);
pinMode(BUTTON, INPUT_PULLUP);
}
void loop() {
digitalWrite(13, HIGH);
delay(500);
digitalWrite(13, LOW);
delay(500);
if (digitalRead(BUTTON) == LOW) {
Serial.println("pressed");
}
}Abrir este sketch en el editorSolo el código: el editor coloca la placa y los componentes que puede leer del sketch.
Por qué millis() a veces salta en 2
El temporizador detrás de millis() late cada 1024 µs, no cada 1000. Así que millis() se atrasa 24 µs por latido, y cada 41 o 42 latidos se pone al día sumando 2 de una vez. Este sketch lo detecta en los primeros 200 ms e imprimió "41 -> 43", "84 -> 86", "126 -> 128" y "169 -> 171". Un Uno real hace exactamente lo mismo.
Por eso el banco de código de arriba puede reportar una peor pasada de 2 ms: una pasada que cae en un salto ve que el reloj avanza en 2. También es por eso que un temporizador debe comprobar >= y nunca ==. Una comprobación de exactamente 42 nunca daría verdadero.
void setup() {
Serial.begin(9600);
unsigned long last = millis();
while (millis() < 200) {
unsigned long now = millis();
if (now - last > 1) {
Serial.print(last);
Serial.print(" -> ");
Serial.println(now);
}
last = now;
}
}
void loop() {
}Abrir este sketch en el editorSolo el código: el editor coloca la placa y los componentes que puede leer del sketch.
Errores comunes
Guardar millis() en un int. Un int en un Uno solo llega a 32767. El sketch de abajo imprimió 0, 7999, 16000, 23999, 32000, luego -25536 a los 40 segundos, y cualquier temporizador construido sobre eso se rompe. Usa unsigned long.
Poner previous = now en lugar de previous += INTERVAL. Cada tick llega un poco tarde, y con = now el retraso se acumula: el mismo temporizador imprimió 1003, 2009, 3013, 4018 y 5022. Usa += cuando los ticks deben mantener el ritmo, y = now solo cuando un tick tarde deba empujar el siguiente.
Probar millis() == target. millis() puede saltarse un valor, así que la prueba puede nunca ser verdadera. Prueba >= sobre una diferencia.
Sumar en lugar de restar. if (millis() >= previous + INTERVAL) se rompe cuando millis() se desborda; millis() - previous >= INTERVAL no.
Un delay() escondido en otra parte. Un solo delay() en cualquier tarea detiene a todas las demás.
void setup() {
Serial.begin(9600);
}
void loop() {
int now = millis(); // should be unsigned long
Serial.println(now);
delay(8000);
}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 lámparas a tres ritmos, sin delay(), conectado como se ejecuta arriba en esta página. Cambia un componente o un valor y ejecútalo de nuevo.
Preguntas
¿Qué hace millis() en Arduino?
Devuelve el número de milisegundos desde que se encendió la placa, como unsigned long. No pausa nada, así que es la forma en que un sketch lleva la cuenta del tiempo mientras hace otras cosas.
¿Cómo ejecuto varias tareas con millis()?
Dale a cada tarea su propio unsigned long con la última vez que se ejecutó, y en loop() revisa cada una con if (millis() - last >= interval). Mantén delay() fuera del loop.
¿Cuál es la diferencia entre millis() y delay()?
delay() detiene el sketch hasta que pasa el tiempo. millis() solo reporta el tiempo y deja que el sketch siga. Con delay(), tres toques rápidos de botón aquí capturaron uno; con millis(), los tres.
¿Por qué mi temporizador de millis() se vuelve negativo?
Está guardado en un int, que se desborda a negativo después de 32767 ms: -25536 a los 40 segundos aquí. Usa unsigned long para millis() y para cada tiempo calculado a partir de él.
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.