Aprender

Desbordamiento de millis() en Arduino: qué pasa al reiniciar la cuenta, y la única línea que sobrevive

O mira todas las lecciones.

  • 526componentes en el banco de trabajo
  • 46placas funcionando ahora
  • 1.00xtiempo real, en todas las placas
Arduino Uno: dos frecuencias, medidas con millis()en vivo0.000 s 0.00x
Haz clic para abrirlo en el editor
El pin 13 parpadea cada 250 ms y el pin 12 cada 400 ms, cada uno medido con now - last >= interval.

millis() cuenta milisegundos desde que arrancó la placa, en un unsigned long. Eso son 32 bits tanto en una Uno como en una ESP32, así que la cuenta llega hasta 4294967295 y luego se reinicia a 0 y sigue. No reinicia la placa, no se detiene y no lanza un error. Simplemente empieza de nuevo desde cero, y cualquier sketch que compare tiempos de la forma incorrecta se rompe en ese momento.

La solución es una sola regla: siempre resta. Escribe if (millis() - start >= interval), con start y el resultado como unsigned long, y la comparación es correcta antes del reinicio de la cuenta, a través de él y después. Escrito como if (millis() >= start + interval) falla en el reinicio. El resto de esta página explica por qué, con un sketch que corre a través del reinicio en una Uno simulada e imprime cada valor.

El circuito de arriba hace parpadear dos LEDs a dos frecuencias desde un solo bucle sin delay(): el pin 13 cada 250 ms y el pin 12 cada 400 ms. Su bucle se construye exactamente con esa línea, una vez por cada LED.

Cuánto falta para que millis() se reinicie

El valor más grande que cabe en un unsigned long es 4294967295. Suma uno y obtienes 0: en la Uno simulada, Serial.println(4294967295UL + 1) imprimió 0. En milisegundos, 4294967296 son 49.71 días, que son los "49.7 días" que cita toda respuesta de foro. Una placa que corre siete semanas lo alcanza.

micros() usa el mismo tipo de 32 bits, pero cuenta mil veces más rápido, así que se reinicia después de 4294967296 microsegundos, 71.58 minutos. Ese no es una curiosidad. Un sketch que mide tiempos con micros() encuentra el reinicio poco más de una hora después de arrancar, lo cual alcanza para pasar todas las pruebas en el banco de trabajo y es lo bastante corto para fallar la primera noche de uso real.

El reinicio de la cuenta, ejecutado en una Uno simulada

Nobody wants to wait 49.7 days to see a bug, in a simulation or on a desk. So this sketch keeps its own clock: it starts it 296 ms before the wrap, at 4294967000, and steps it forward 100 ms at a time, as millis() would. At each step it asks both questions, "has 1000 ms gone by?" by subtraction and by addition, and prints the answers. The arithmetic is the board’s own: 32-bit unsigned math, run on the simulated ATmega328P.

Imprimió "t=0 now=4294967000 now-start=0 subtraction: wait, addition: DUE" en su primera línea. La suma dice que el intervalo ya terminó antes de que haya pasado un solo milisegundo. Eso es porque start + interval es 4294968000, que no cabe, así que se reinició a 704, y todo valor de now antes del reinicio es mayor que 704.

La resta siguió contando: 100, 200, 300 directamente a través del reinicio, donde now pasó de 4294967200 a 4, y reportó "due" por primera vez en la línea "t=1000 now=704 now-start=1000 subtraction: DUE, addition: DUE". Eso es exactamente 1000 ms después del inicio. La suma, mientras tanto, dijo "DUE" hasta el reinicio y "wait" después, correcta solo por casualidad desde la línea de los 1000 ms. Lejos del reinicio ambas coinciden, y por eso la versión con suma pasa toda prueba corta.

Ambas comparaciones, avanzando a través del reinicio
void setup() {
  Serial.begin(9600);
  unsigned long start = 4294967000UL;  // 296 ms before the wrap
  unsigned long interval = 1000;
  for (unsigned long t = 0; t <= 1200; t += 100) {
    unsigned long now = start + t;     // what millis() would say
    Serial.print("t=");
    Serial.print(t);
    Serial.print(" now=");
    Serial.print(now);
    Serial.print(" now-start=");
    Serial.print(now - start);
    Serial.print(now - start >= interval ? " subtraction: DUE" : " subtraction: wait");
    Serial.println(now >= start + interval ? ", addition: DUE" : ", addition: wait");
  }
}

void loop() {
}

Abrir este sketch en el editorSolo el código: el editor coloca la placa y los componentes que puede leer del sketch.

Por qué la resta siempre es correcta

Unsigned arithmetic in C and C++ is arithmetic modulo 2 to the 32nd: every result wraps the same way the clock does. When now has wrapped to 704 and start is still 4294967000, the true difference is 1000, and 704 minus 4294967000, wrapped, is 1000. The two wraps cancel. As long as the interval you are measuring is shorter than 49.7 days, now - start is the time that has really gone by.

La suma no tiene esa suerte. start + interval se reinicia por su lado, y now se reinicia en un momento distinto, así que por un rato uno ya se reinició y el otro no, y la comparación responde a la pregunta equivocada. Comparar contra una fecha límite guardada, if (millis() > deadline), es el mismo error con otra forma.

Las otras formas en que falla: el tipo incorrecto

La resta solo funciona en unsigned long. Guarda millis() en un long con signo y se vuelve negativo después de 24.86 días, la mitad del rango: en el Uno, (long)4294967000UL imprimió -296. Guárdalo en un int en un Uno, que ahí es de 16 bits, y se rompe después de 32.767 segundos: (int)40000UL imprimió -25536, así que un sketch que guarda int start = millis(); se comporta mal dentro de su primer minuto. En un ESP32 un int es de 32 bits, lo que oculta el segundo error pero no el primero.

Usa unsigned long para toda variable que guarde un tiempo, y también para el intervalo. const unsigned long INTERVAL = 1000; no cuesta nada y mantiene toda la expresión en el tipo correcto.

¿Hay que manejar el desbordamiento?

No, si cada comparación es una resta en unsigned long. No hace falta detectar el salto, reiniciar millis() ni reiniciar la placa cada pocas semanas; los sketches que hacen esas cosas están esquivando una comparación escrita de forma incorrecta. delay() ya mide su espera de esta manera, así que un delay() que atraviese el salto funciona bien.

El único límite real es un intervalo más largo que el contador mismo. No puedes medir 60 días con una sola resta de millis(). Cuenta algo más lento: suma uno a un contador de days cada vez que pasen 86400000 ms, con la misma resta, o lee la hora de un módulo de reloj de tiempo real.

Abre este circuito en el editor. Arduino Uno: dos frecuencias, medidas con millis(), cableado tal como corre al inicio de esta página. Cambia un componente o un valor y ejecútalo de nuevo.

Preguntas

¿Cuál es el valor máximo de millis()?

4294967295, el unsigned long más grande. Un milisegundo después es 0. En un Uno simulado, 4294967295UL + 1 imprime 0.

¿Cuánto tarda millis() en desbordarse?

Unos 49.71 días, 4294967296 milisegundos. micros() se desborda después de unos 71.58 minutos.

¿El Arduino se reinicia cuando millis() se desborda?

No. El contador salta a 0 y sigue, y el sketch continúa. Solo las comparaciones escritas como una suma, o guardadas en el tipo incorrecto, fallan en ese momento.

¿Cómo evito los problemas de desbordamiento de millis()?

Escribe cada verificación como if (millis() - start >= interval), con start e interval declarados como unsigned long. Esa sola línea es correcta a través del salto, así que no hay nada más que manejar.

Á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.