Aprender

Arduino millis(): timers e várias coisas ao mesmo tempo

Ou veja todas as aulas.

  • 526componentes na bancada
  • 46placas rodando agora
  • 1.00xtempo real, em todas as placas
Arduino Uno: três lâmpadas em três ritmos, sem delay()ao vivo0.000 s 0.00x
Aperte Rodar e observe as três lâmpadas
Três timers em um único loop, cada um conferido com millis() em cada passagem.

millis() devolve quantos milissegundos se passaram desde que a placa ligou, como um unsigned long. Ele não espera nada. Para fazer algo a cada segundo, guarde quando você fez pela última vez e, a cada passada pelo loop(), pergunte se já passou um segundo: if (millis() - previous >= 1000). Essa única linha é como um Arduino faz várias coisas ao mesmo tempo.

O circuito acima é a bancada de código com três lâmpadas. Aperte Rodar. A lâmpada vermelha troca a cada 200 ms, a amarela a cada 330 ms e a verde a cada 1100 ms, tudo em um só loop() sem nenhum delay(). O monitor serial imprime "pior passagem pelo loop: 2 ms" a cada dois segundos: nenhuma passada pelo loop() demorou mais que isso, então todas as lâmpadas estão no horário.

Abaixo está o que millis() devolve, o padrão de timer, um sketch rodando três tarefas ao mesmo tempo, millis() contra delay() e os erros que fazem um timer desviar, parar ou ficar negativo, cada um rodado em um Uno.

Quer a versão passo a passo? A aula "Pergunte a hora, não espere por ela" percorre tudo isso com checkpoints.

Abrir a aula

O que millis() devolve

Uma contagem de milissegundos desde a ligação ou o reset, começando em 0. Este sketch imprime o valor uma vez por segundo e imprimiu 0, 999, 1999, 3000 e 3999. A contagem é 0 no início de setup() porque a placa parte do zero todas as vezes.

É um unsigned long, de 32 bits, então conta até 4294967295 e depois volta para 0, depois de cerca de 49,7 dias. A página sobre overflow do millis() mostra por que a subtração no padrão de timer sobrevive à virada.

Imprimir millis()
void setup() {
  Serial.begin(9600);
}

void loop() {
  Serial.println(millis());
  delay(1000);
}

Abrir este sketch no editorSó o código: o editor posiciona a placa e os componentes que ele consegue ler do sketch.

Um timer com millis()

Aqui está o padrão. previous guarda quando o timer disparou pela última vez. Em cada passagem, now - previous >= INTERVAL pergunta se o intervalo já passou e, se sim, o sketch faz seu trabalho e avança previous. O delay(7) representa o resto de um sketch de verdade, que também leva tempo.

Ele imprimiu "tick at 1003", "tick at 2001", "tick at 3006", "tick at 4003" e "tick at 5001". Cada tick pode atrasar alguns milissegundos, porque o loop só olha a cada 7 ms, mas o atraso não se acumula: o quinto tick ainda sai em 5001.

Um timer a cada segundo
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 no editorSó o código: o editor posiciona a placa e os componentes que ele consegue ler do sketch.

Várias tarefas ao mesmo tempo

Cada tarefa tem seu próprio timer, e o loop() confere todos a cada passagem. Este sketch pisca o pino 13 a cada 250 ms, troca uma lâmpada no pino 12 cada vez que o botão é apertado e imprime um relatório a cada segundo, tudo ao mesmo tempo.

Apertamos o botão três vezes, um toque rápido de 150 ms cada. Ele imprimiu "1 s, presses: 1", "2 s, presses: 3" e "3 s, presses: 3", a lâmpada no pino 12 mudou a cada toque, e o pisca no pino 13 não perdeu nenhum ritmo. Adicione uma quarta tarefa do mesmo jeito: mais um timer, mais um if.

Três tarefas, um loop
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 no editorSó o código: o editor posiciona a placa e os componentes que ele consegue ler do sketch.

millis() contra delay()

Aqui está o mesmo pisca e botão escritos com delay(). O sketch passa todo o tempo dentro de delay(), então só lê o botão por um instante, uma vez por segundo. Os mesmos três toques de 150 ms imprimiram "pressed" uma vez só. Dois dos três vieram e foram embora enquanto o sketch estava esperando.

delay() é bom quando a placa tem uma coisa só para fazer. Assim que tiver duas, mude para millis().

O mesmo, com delay()
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 no editorSó o código: o editor posiciona a placa e os componentes que ele consegue ler do sketch.

Por que millis() às vezes pula 2

O timer por trás do millis() pulsa a cada 1024 µs, não a cada 1000. Então o millis() atrasa 24 µs por pulso e, a cada 41 ou 42 pulsos, recupera somando 2 de uma vez. Este sketch fica de olho nisso nos primeiros 200 ms e imprimiu "41 -> 43", "84 -> 86", "126 -> 128" e "169 -> 171". Um Uno de verdade faz exatamente o mesmo.

É por isso que a bancada de código acima pode relatar uma pior passagem de 2 ms: uma passagem que cai num salto vê o relógio andar 2. Também é por isso que um timer deve testar >= e nunca ==. Um teste para exatamente 42 nunca seria verdadeiro.

Pegar o millis() pulando
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 no editorSó o código: o editor posiciona a placa e os componentes que ele consegue ler do sketch.

Erros comuns

Guardar millis() em um int. Um int no Uno só chega a 32767. O sketch abaixo imprimiu 0, 7999, 16000, 23999, 32000 e depois -25536 aos 40 segundos, e qualquer timer construído assim quebra. Use unsigned long.

Usar previous = now em vez de previous += INTERVAL. Cada tick atrasa um pouco e, com = now, o atraso se acumula: o mesmo timer imprimiu 1003, 2009, 3013, 4018 e 5022. Use += quando os ticks precisam ficar no ritmo e = now só quando um tick atrasado deve empurrar o próximo para depois.

Testar millis() == target. millis() pode pular um valor, então o teste pode nunca ser verdadeiro. Teste >= numa diferença.

Somar em vez de subtrair. if (millis() >= previous + INTERVAL) quebra quando o millis() vira; millis() - previous >= INTERVAL não quebra.

Um delay() escondido em outro lugar. Um delay() em qualquer tarefa segura todas as outras.

millis() em um int
void setup() {
  Serial.begin(9600);
}

void loop() {
  int now = millis();  // should be unsigned long
  Serial.println(now);
  delay(8000);
}

Abrir este sketch no editorSó o código: o editor posiciona a placa e os componentes que ele consegue ler do sketch.

Abra este circuito no editor. Arduino Uno: três lâmpadas em três ritmos, sem delay(), ligado como roda no topo desta página. Troque um componente ou um valor e rode de novo.

Perguntas

O que o millis() faz no Arduino?

Ele devolve o número de milissegundos desde que a placa ligou, como um unsigned long. Ele não pausa nada, então é como um sketch conta o tempo enquanto faz outros trabalhos.

Como rodar várias tarefas com millis()?

Dê a cada tarefa seu próprio unsigned long para quando ela rodou pela última vez e, no loop(), confira cada uma com if (millis() - last >= interval). Deixe o delay() fora do loop.

Qual a diferença entre millis() e delay()?

delay() para o sketch até o tempo acabar. millis() só informa o tempo e deixa o sketch continuar. Com delay(), três toques rápidos de botão aqui pegaram um; com millis(), os três.

Por que meu temporizador com millis() fica negativo?

Ele está guardado em um int, que vira negativo depois de 32767 ms: -25536 aos 40 segundos aqui. Use unsigned long para millis() e para todo tempo calculado a partir dele.

Fontes

De onde vêm as informações desta página

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.