Aprender

Estouro de millis() no Arduino: o que acontece na virada, e a única linha que sobrevive a ela

Ou veja todas as aulas.

  • 526componentes na bancada
  • 46placas rodando agora
  • 1.00xtempo real, em todas as placas
Arduino Uno: duas taxas, cronometradas com millis()ao vivo0.000 s 0.00x
Clique para abrir no editor
O pino 13 pisca a cada 250 ms e o pino 12 a cada 400 ms, cada um cronometrado com now - last >= interval.

millis() conta milissegundos desde que a placa ligou, em um unsigned long. São 32 bits tanto no Uno quanto no ESP32, então a contagem chega a 4294967295 e depois dá a volta para 0 e continua. Ela não reinicia a placa, não para e não gera erro. Simplesmente começa de novo do zero, e qualquer sketch que compare tempos do jeito errado quebra nesse momento.

A correção é uma regra: sempre subtraia. Escreva if (millis() - start >= interval), com start e o resultado como unsigned long, e a comparação fica certa antes da virada, através dela e depois dela. Escrito como if (millis() >= start + interval) falha na virada. O resto desta página mostra o porquê, com um sketch que atravessa a virada em um Uno simulado e imprime cada valor.

O circuito acima pisca dois LEDs em duas taxas a partir de um único loop, sem delay(): o pino 13 a cada 250 ms e o pino 12 a cada 400 ms. O loop dele é construído exatamente sobre essa linha, uma vez para cada LED.

Quanto tempo até millis() dar a volta

O maior valor que um unsigned long guarda é 4294967295. Some um e você obtém 0: no Uno simulado, Serial.println(4294967295UL + 1) imprimiu 0. Em milissegundos, 4294967296 são 49,71 dias, que são os "49,7 dias" que toda resposta de fórum cita. Uma placa que roda por sete semanas encontra a virada.

micros() usa o mesmo tipo de 32 bits, mas conta mil vezes mais rápido, então dá a volta após 4294967296 microssegundos, 71,58 minutos. Esse não é uma curiosidade. Um sketch que cronometra coisas com micros() encontra a virada pouco mais de uma hora depois de ligar, tempo suficiente para passar em todo teste na bancada e curto demais para falhar na primeira noite de uso real.

A virada, executada em um Uno simulado

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.

Ele imprimiu "t=0 now=4294967000 now-start=0 subtraction: wait, addition: DUE" na primeira linha. A adição diz que o intervalo já acabou antes de ter passado um único milissegundo. Isso porque start + interval é 4294968000, que não cabe, então virou 704, e todo valor de now antes da virada é maior que 704.

A subtração continuou contando: 100, 200, 300 direto através da virada, onde now foi de 4294967200 para 4, e informou "due" pela primeira vez na linha "t=1000 now=704 now-start=1000 subtraction: DUE, addition: DUE". Isso é exatamente 1000 ms após o início. A adição, enquanto isso, disse "DUE" até a virada e "wait" depois, certa só por acaso a partir da linha dos 1000 ms. Longe da virada as duas concordam, e é por isso que a versão com adição passa em todo teste curto.

As duas comparações, avançando pela virada
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 no editorSó o código: o editor posiciona a placa e os componentes que ele consegue ler do sketch.

Por que a subtração está sempre certa

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.

A adição não tem essa sorte. start + interval dá a volta por conta própria, e now vira em um momento diferente, então por um tempo um lado já virou e o outro não, e a comparação responde à pergunta errada. Comparar com um prazo guardado, if (millis() > deadline), é o mesmo erro em outra forma.

Os outros jeitos de dar errado: o tipo errado

A subtração só funciona em unsigned long. Guarde millis() em um long com sinal e ele fica negativo depois de 24,86 dias, metade do intervalo: no Uno, (long)4294967000UL imprimiu -296. Guarde em um int em um Uno, que lá tem 16 bits, e ele quebra depois de 32,767 segundos: (int)40000UL imprimiu -25536, então um sketch que salva int start = millis(); começa a se comportar mal no primeiro minuto. Em um ESP32 um int tem 32 bits, o que esconde o segundo erro, mas não o primeiro.

Use unsigned long para toda variável que guarda um tempo, e para o intervalo também. const unsigned long INTERVAL = 1000; não custa nada e mantém a expressão inteira no tipo certo.

Você precisa lidar com o overflow?

Não, se toda comparação for uma subtração em unsigned long. Não há necessidade de detectar a virada, reiniciar millis() ou reiniciar a placa a cada poucas semanas; sketches que fazem isso estão contornando uma comparação escrita da forma errada. delay() já mede sua espera dessa forma, então um delay() que atravessa a virada funciona bem.

O único limite real é um intervalo maior que o próprio contador. Você não consegue medir 60 dias com uma subtração de millis(). Conte algo mais lento: some um a um contador de days cada vez que passarem 86400000 ms, usando a mesma subtração, ou leia a hora de um módulo de relógio de tempo real.

Abra este circuito no editor. Arduino Uno: duas frequências, cronometradas com millis(), ligado como ele roda no topo desta página. Troque um componente ou um valor e rode de novo.

Perguntas

Qual é o valor máximo de millis()?

4294967295, o maior unsigned long. Um milissegundo depois ele é 0. Em um Uno simulado, 4294967295UL + 1 imprime 0.

Quanto tempo até o millis() passar do limite?

Cerca de 49,71 dias, 4294967296 milissegundos. O micros() passa do limite depois de cerca de 71,58 minutos.

O Arduino reinicia quando o millis() passa do limite?

Não. A contagem volta para 0 e continua, e o sketch segue em frente. Só comparações escritas como uma soma, ou guardadas no tipo errado, dão errado nesse momento.

Como evito problemas de overflow do millis()?

Escreva toda verificação como if (millis() - start >= interval), com start e interval declarados como unsigned long. Essa única linha está correta através da virada, então não há nada mais a tratar.

Monte isto de verdade

Abra o editor, mude um valor e veja o número mudar junto. Nada para instalar, e não precisa de conta.