Arduino millis(): timers e várias coisas ao mesmo tempo
- 526componentes na bancada
- 46placas rodando agora
- 1.00xtempo real, em todas as placas
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 aulaO 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.
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.
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.
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().
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.
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.
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.
Continuar
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.