Por que delay() bloqueia, e o que usar no lugar
- 526componentes na bancada
- 46placas rodando agora
- 1.00xtempo real, em todas as placas
delay(500) faz exatamente o que diz: para o sketch, por completo, por quinhentos milissegundos. Nada mais em loop() roda, nenhum outro pino muda, nenhum dado serial é lido, até a espera acabar. Isso é bom para um único LED piscando, porque não há nada mais que o sketch precise fazer nesse meio-tempo. Deixa de funcionar no momento em que há duas coisas que precisam acontecer em seu próprio ritmo, porque um segundo delay() só pode rodar depois que o primeiro termina, o que significa que as duas coisas nunca podem ser de fato independentes.
Vale a pena montar isso uma vez especificamente porque a maioria dos tutoriais para iniciantes ensina delay() primeiro, por um bom motivo: é a forma mais fácil possível de fazer um LED piscar, e está correto para essa única tarefa. O problema só aparece quando um sketch cresce além do seu primeiro LED, que é exatamente o momento em que um iniciante está menos preparado para uma mudança em como o tempo funciona, então vale a pena encontrar o limite deliberadamente aqui, em um circuito pequeno, em vez de encontrá-lo pela primeira vez no meio de um projeto maior.
The circuit above is the demonstration: two LEDs, one on pin 13 blinking every 250 milliseconds and one on pin 12 blinking every 400 milliseconds, both timed from the same loop with no delay() anywhere in it. Watch them for a few seconds and the two rates visibly drift in and out of phase with each other, because 250 and 400 only line up again every two seconds, which is exactly what two independent rates should do, and exactly what two lamps sharing one delay() call could never manage.
O que delay() realmente faz
No chip de verdade, e no modelo dele no Mokxi, delay() não é um laço ocupado girando a CPU à toa: o sketch blink do próprio Uno depende de um tique de timer de hardware e deixa o core dormir entre os tiques, o que é eficiente e correto para exatamente um trabalho por vez. O problema nunca foi que delay() seja desperdício. O problema é que ele é total: enquanto roda, o sketch não pode fazer mais nada, incluindo verificar um segundo timer que deveria estar rodando de forma independente.
O formato de máquina de estados
A correção é parar de esperar e passar a perguntar as horas. Para cada coisa que precisa do seu próprio cronograma, guarde o momento em que ela aconteceu pela última vez e, a cada passagem por loop(), pergunte se já passou tempo suficiente: if (now - lastTime >= INTERVAL) { lastTime = now; ...act... }. O loop() em si nunca para; ele simplesmente não faz nada, na maioria das passagens, para os timers que ainda não chegaram à hora.
Two details in that line are not optional. now and lastTime have to be unsigned long, because that is the type millis() returns and the type the subtraction has to happen in. And the comparison has to be a subtraction, now - lastTime, rather than an addition like lastTime + INTERVAL, because subtracting two unsigned longs comes out correct even across the roll-over that happens roughly every 49.7 days, when millis() wraps back to zero. An addition-based comparison breaks exactly at that boundary; the subtraction never does.
This shape scales past two timers with no change to it at all. The Uno's built-in cpptiming example runs three lamps at three unrelated rates, 200, 330 and 1100 milliseconds, from a small array of little structs, each holding its own pin, interval and last-fired time, and one loop that checks all three the same way this page's two-lamp version checks two. It also prints the longest a single pass through loop() has ever taken, which stays at 2 milliseconds or less as long as nothing in the sketch blocks (2 rather than 1, because millis() itself now and then jumps by 2), and climbs the moment something does. That number is a genuinely useful thing to watch in a sketch you are not sure is blocking anywhere: a loop() that is meant to be instant and suddenly is not has a delay(), or something that behaves like one, hiding in it somewhere.
Dois timers ao mesmo tempo
O programa tworates incluído no Uno é o circuito acima, rodando como mostrado: dois trabalhos independentes, dois intervalos, um loop, sem delay().
const int RED_PIN = 13;
const int GREEN_PIN = 12;
const unsigned long RED_MS = 250;
const unsigned long GREEN_MS = 400;
unsigned long lastRed = 0;
unsigned long lastGreen = 0;
bool redOn = false;
bool greenOn = false;
void loop() {
unsigned long now = millis();
if (now - lastRed >= RED_MS) {
lastRed = now;
redOn = !redOn;
digitalWrite(RED_PIN, redOn ? HIGH : LOW);
}
if (now - lastGreen >= GREEN_MS) {
lastGreen = now;
greenOn = !greenOn;
digitalWrite(GREEN_PIN, greenOn ? HIGH : LOW);
}
}O que você tentaria com delay(), e por que isso para de escalar
É possível fazer duas lâmpadas alternarem usando nada além de delay(), e o programa twoleds incluído no Uno faz exatamente isso: acende a lâmpada vermelha e apaga a verde, espera, depois troca as duas, espera de novo. Visto sozinho, parece muito com dois ritmos. Não é: as duas lâmpadas estão travadas na mesma espera de meio segundo, porque só existe uma espera no sketch inteiro. Tente dar à lâmpada verde um ritmo que não divide igualmente o da vermelha, sem tocar em millis(), e não há como escrever: uma terceira chamada de delay() só pode rodar depois que as outras duas terminarem, então um terceiro ritmo independente não é um passo mais difícil, é impossível nesse formato.
Ler um botão no mesmo loop
A recompensa real deste padrão aparece quando um sketch precisa fazer mais do que piscar. Um loop() construído em torno de delay() não consegue verificar um botão, imprimir no monitor serial ou atualizar um display enquanto espera um piscar terminar; um loop() construído em torno de verificações de millis() faz tudo isso como mais blocos if que rodam a cada passagem, então a leitura de um botão convive tranquilamente com dois timers de piscar independentes sem que nada mude em nenhum deles. Este também é o formato que a página sobre debouncing de botão usa para a própria correção, e não é coincidência: é o mesmo problema, cronometrar algo sem bloquear todo o resto, resolvido da mesma forma.
Abra este circuito no editor. Arduino Uno: dois ritmos, sem delay, ligado como roda no topo desta página. Troque um componente ou um valor e rode de novo.
Perguntas
O que acontece quando millis() vira após 49,7 dias?
A subtração sem sinal em now - lastTime faz a virada corretamente e continua produzindo o intervalo certo, que é todo o motivo de o padrão ser escrito como subtração e não como lastTime + INTERVAL comparado a now.
Is delay() ever fine to use?
Sim, para um sketch que realmente não tem mais nada a fazer enquanto espera, ou para uma espera muito curta em setup(). No momento em que um segundo timer independente, uma leitura de botão ou uma verificação serial precisa acontecer durante essa espera, delay() é a ferramenta errada.
Como adiciono um terceiro timer em um terceiro ritmo?
Adicione uma terceira variável lastTime, um terceiro intervalo e um terceiro bloco if, exatamente no formato dos dois que já estão lá. Nada no padrão muda conforme mais timers entram, que é o objetivo de escrevê-lo assim.
Usar interrupções substitui este padrão?
Elas resolvem um problema diferente: uma interrupção reage a um evento (uma borda, um estouro de timer) no instante em que ele acontece, enquanto a temporização com millis() serve para trabalhos que só precisam acontecer em um cronograma que o próprio loop() consegue verificar. Muitos sketches usam os dois.
Por que usar unsigned long em vez de int para as variáveis de tempo?
millis() retorna um unsigned long porque a contagem precisa de mais alcance do que um int de 16 bits oferece em um Uno; armazenar em um tipo menor ou com sinal trunca ou interpreta errado o valor muito antes de a virada de 49,7 dias sequer se tornar o problema.
Para que serve micros(), se millis() já existe?
Resolução mais fina, em microssegundos em vez de milissegundos, para temporizações que precisam ser mais precisas do que um milissegundo, ao custo de virar muito mais cedo, aproximadamente a cada 71 minutos em vez de a cada 49,7 dias. O mesmo padrão de subtração acima funciona para ele sem mudanças.
Continuar
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.