Multitarefa no Arduino: várias tarefas ao mesmo tempo com millis()
- 526componentes na bancada
- 46placas rodando agora
- 1.00xtempo real, em todas as placas
Um Arduino Uno tem um núcleo só e nenhum sistema operacional, então ele nunca executa duas coisas no mesmo instante. Ainda assim, ele pode cuidar de várias tarefas ao mesmo tempo, desde que cada tarefa leve só um momento e devolva o controle. O padrão se chama multitarefa cooperativa: loop() executa cada tarefa uma vez por passagem, cada tarefa consulta millis() para ver se chegou a sua hora, e nada nunca espera em delay().
O circuito acima é a bancada de código do curso de C++: três LEDs nos pinos 13, 12 e 11 e um botão no pino 2. O seu sketch pisca os três LEDs a 200, 330 e 1100 ms e mede o próprio loop. O monitor serial imprime "pior passagem pelo loop: 2 ms" a cada dois segundos, e é por isso que os três ritmos se mantêm certos.
Abaixo você vê por que delay() não consegue fazer isso, quatro tarefas escritas do jeito millis(), uma classe por tarefa, o que uma tarefa que bloqueia faz com as outras, e a biblioteca TaskScheduler, que roda o mesmo padrão para você.
Quer a versão passo a passo? A aula "Pergunte a hora, não espere por ela" percorre tudo isso com checkpoints.
Abrir a aulaPor que delay() só consegue fazer uma coisa
delay() para o sketch inteiro. Enquanto ele conta, nenhuma outra linha roda, então um sketch que pisca com delay() lê o seu botão uma vez por piscada, no máximo. O sketch abaixo pisca o pino 13 com dois delays de um segundo e só confere o botão depois deles.
Seguramos o botão de 0,5 s a 1,4 s e nada aconteceu: o aperto começou e terminou enquanto o sketch estava dentro de um delay(). Um segundo aperto, segurado a partir de 2,3 s, só foi notado quando o sketch chegou até ele, e o monitor serial imprimiu "aperto visto em 3999", 1,7 segundo atrasado. Encurtar os delays diminui o atraso, mas nunca o elimina.
const int BUTTON = 2;
void setup() {
Serial.begin(9600);
pinMode(13, OUTPUT);
pinMode(12, OUTPUT);
pinMode(BUTTON, INPUT_PULLUP);
}
void loop() {
digitalWrite(13, HIGH);
delay(1000);
digitalWrite(13, LOW);
delay(1000);
if (digitalRead(BUTTON) == LOW) {
digitalWrite(12, HIGH);
Serial.print("press seen at ");
Serial.println(millis());
}
}Abrir este sketch no editorSó o código: o editor posiciona a placa e os componentes que ele consegue ler do sketch.
Quatro tarefas em um loop
Dê a cada tarefa uma função e a sua própria variável "última vez que rodei". A cada passagem, loop() lê millis() uma vez e repassa para cada tarefa; uma tarefa que ainda não está na hora retorna imediatamente. Aqui uma piscada lenta no pino 13 roda a cada 1000 ms, uma rápida no pino 12 a cada 150 ms, um botão alterna o pino 11, e um relatório é impresso a cada dois segundos.
Com os mesmos dois apertos, o monitor serial imprimiu "aperto visto em 499" e "aperto visto em 2298": cada aperto foi capturado em até um milissegundo do início, enquanto os dois LEDs mantinham os seus ritmos. Depois vieram "apertos até agora: 1" e "apertos até agora: 2", da tarefa de relatório, bem na hora.
Dois detalhes importam. Guarde todo tempo em um unsigned long e compare now - last >= interval, para que a conta continue certa quando millis() virar após 49,7 dias. E a tarefa do botão ignora qualquer mudança em menos de 20 ms da última, porque um botão de verdade sofre bounce e o simulado também; sem isso, um aperto conta várias vezes.
const int BUTTON = 2;
unsigned long lastBlink = 0;
unsigned long lastFlash = 0;
unsigned long lastReport = 0;
unsigned long lastChange = 0;
bool blinkOn = false;
bool flashOn = false;
bool wasPressed = false;
int presses = 0;
void setup() {
Serial.begin(9600);
pinMode(13, OUTPUT);
pinMode(12, OUTPUT);
pinMode(11, OUTPUT);
pinMode(BUTTON, INPUT_PULLUP);
}
void blinkTask(unsigned long now) {
if (now - lastBlink >= 1000) {
lastBlink = now;
blinkOn = !blinkOn;
digitalWrite(13, blinkOn);
}
}
void flashTask(unsigned long now) {
if (now - lastFlash >= 150) {
lastFlash = now;
flashOn = !flashOn;
digitalWrite(12, flashOn);
}
}
void buttonTask(unsigned long now) {
bool pressed = digitalRead(BUTTON) == LOW;
if (pressed != wasPressed && now - lastChange >= 20) {
lastChange = now;
wasPressed = pressed;
if (pressed) {
presses++;
digitalWrite(11, presses % 2);
Serial.print("press seen at ");
Serial.println(now);
}
}
}
void reportTask(unsigned long now) {
if (now - lastReport >= 2000) {
lastReport = now;
Serial.print("presses so far: ");
Serial.println(presses);
}
}
void loop() {
unsigned long now = millis();
blinkTask(now);
flashTask(now);
buttonTask(now);
reportTask(now);
}Abrir este sketch no editorSó o código: o editor posiciona a placa e os componentes que ele consegue ler do sketch.
Uma classe por tarefa
Quando três tarefas fazem o mesmo trabalho com números diferentes, escreva o trabalho uma vez como uma classe e crie três delas. Cada Blinker guarda o seu próprio pino, intervalo, última vez e estado, então adicionar um quarto LED é uma linha. Essa é a forma que a maioria das bibliotecas de multitarefa usa por dentro.
Roda por três segundos, o sketch imprimiu "após 3 s: 6, 15, 59": seis alternâncias a 500 ms, quinze a 200 ms e cinquenta e nove a 50 ms, a última caindo um momento depois do relatório.
class Blinker {
public:
Blinker(int pin, unsigned long everyMs) : pin_(pin), everyMs_(everyMs) {}
void begin() {
pinMode(pin_, OUTPUT);
}
void update(unsigned long now) {
if (now - last_ >= everyMs_) {
last_ = now;
on_ = !on_;
digitalWrite(pin_, on_);
toggles_++;
}
}
unsigned long toggles() const {
return toggles_;
}
private:
int pin_;
unsigned long everyMs_;
unsigned long last_ = 0;
bool on_ = false;
unsigned long toggles_ = 0;
};
Blinker slow(13, 500);
Blinker mid(12, 200);
Blinker fast(11, 50);
bool reported = false;
void setup() {
Serial.begin(9600);
slow.begin();
mid.begin();
fast.begin();
}
void loop() {
unsigned long now = millis();
slow.update(now);
mid.update(now);
fast.update(now);
if (!reported && now >= 3000) {
reported = true;
Serial.print("after 3 s: ");
Serial.print(slow.toggles());
Serial.print(", ");
Serial.print(mid.toggles());
Serial.print(", ");
Serial.println(fast.toggles());
}
}Abrir este sketch no editorSó o código: o editor posiciona a placa e os componentes que ele consegue ler do sketch.
Uma tarefa que bloqueia desacelera todas
Cooperativa significa que toda tarefa tem que cooperar. O sketch da bancada acima mede a passagem mais longa por loop(), e com três tarefas bem-comportadas ele imprimiu "pior passagem pelo loop: 2 ms". Adicionamos delay(250); só à tarefa mais lenta, e ele imprimiu "pior passagem pelo loop: 250 ms": enquanto aquela única tarefa esperava, o LED de 200 ms perdeu a sua vez e o botão ficaria sem leitura.
Os suspeitos de sempre são delay(), um while que espera por um pino, pulseIn() com um timeout longo e uma impressão longa num baud rate lento. Quebre uma tarefa lenta em passos, com uma variável que lembra qual passo vem depois, e deixe loop() passar entre eles. Isso é uma máquina de estados, e é a próxima página para ler.
A biblioteca TaskScheduler
TaskScheduler faz a contabilidade: você cria uma Task com um intervalo, uma contagem e uma função, adiciona-a a um Scheduler e chama runner.execute() em loop(). Ela continua cooperativa, então vale a mesma regra, e um callback que bloqueia bloqueia todas as tarefas. O Mokxi já a traz incluída; o sketch abaixo rodou no Uno exatamente como escrito.
Ele imprimiu "slow 1, fast 1" de uma vez, porque uma tarefa roda assim que é habilitada, depois "slow 5, fast 21" aos dois segundos e "slow 8, fast 40" aos quatro. O relatório vence no mesmo milissegundo dos dois blinks, então se um blink já contou naquele milissegundo depende de onde o agendador está na sua passagem.
#include <TaskScheduler.h>
void blinkSlow();
void blinkFast();
void report();
Scheduler runner;
Task slowTask(500, TASK_FOREVER, &blinkSlow);
Task fastTask(100, TASK_FOREVER, &blinkFast);
Task reportTask(2000, TASK_FOREVER, &report);
int slowRuns = 0;
int fastRuns = 0;
void blinkSlow() {
digitalWrite(13, !digitalRead(13));
slowRuns++;
}
void blinkFast() {
digitalWrite(12, !digitalRead(12));
fastRuns++;
}
void report() {
Serial.print("slow ");
Serial.print(slowRuns);
Serial.print(", fast ");
Serial.println(fastRuns);
}
void setup() {
Serial.begin(9600);
pinMode(13, OUTPUT);
pinMode(12, OUTPUT);
runner.addTask(slowTask);
runner.addTask(fastTask);
runner.addTask(reportTask);
slowTask.enable();
fastTask.enable();
reportTask.enable();
}
void loop() {
runner.execute();
}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 LEDs em três clocks, a partir de um único loop, ligados como ele roda no topo desta página. Troque um componente ou um valor e rode de novo.
Perguntas
Um Arduino Uno consegue executar várias tarefas ao mesmo tempo?
Na verdade, não: ele tem um núcleo e executa uma instrução por vez. Ele dá conta de muitas tarefas ao mesmo tempo executando cada uma por um instante em cada passada do loop(), usando millis() em vez de delay(), o que é rápido o bastante para as tarefas parecerem rodar juntas.
Por que meu botão não funciona enquanto um LED pisca?
O blink usa delay(), e nada mais roda durante um delay. Um aperto que começa e termina dentro dele é perdido, e um que dura mais é visto tarde. Meça o tempo do blink com millis() e verifique o botão em cada passada do loop().
Qual é a melhor biblioteca de multitarefa para Arduino?
TaskScheduler é uma escolha comum e funciona no Uno; há opções menores também. Todas fazem o que o sketch de quatro tarefas faz à mão, então aprender o padrão primeiro facilita a leitura de qualquer biblioteca.
Um ESP32 faz multitarefa de forma diferente?
Um ESP32 real roda FreeRTOS, então xTaskCreate() cria tarefas de verdade com pilhas próprias, nos dois núcleos de um ESP32 clássico. O Mokxi roda o sketch do ESP32 em um núcleo sem agendador: o xTaskCreate() avisa uma vez no monitor serial que a tarefa não roda. O padrão com millis() desta página funciona igual nos dois.
Quantas tarefas o loop() consegue rodar?
Quantas couberem na memória, desde que cada uma retorne rápido. Meça a passada mais longa pelo loop(), como o sketch da bancada faz; se ficar em alguns milissegundos, cada tarefa mantém seu timing.
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.