Aprender

O laço while do Arduino, num cronômetro de reação

Intermediário

Ou veja todas as aulas.

  • 526componentes na bancada
  • 46placas rodando agora
  • 1.00xtempo real, em todas as placas
Arduino Uno: um cronômetro de reaçãoao vivo0.000 s 0.00x
Aperte Rodar, espere a lâmpada e depois aperte o botão
Espere a lâmpada verde e depois aperte o botão. Os laços while fazem a espera.

while (condição) { ... } executa seu bloco de novo e de novo enquanto a condição for verdadeira. Ele verifica antes de cada passagem, então se a condição já começa falsa, o bloco nunca é executado. Seu trabalho mais comum em um Arduino é esperar: while (digitalRead(2) == HIGH) { } não faz nada, repetidamente, até que o botão no pino 2 seja apertado.

O circuito acima é um cronômetro de reação. Aperte Rodar e espere. A lâmpada verde acende em um momento aleatório, e o monitor serial mostra quantos milissegundos você levou para apertar o botão. No nosso teste, a lâmpada acendeu 1,94 segundos depois de Rodar, e um toque um quarto de segundo depois imprimiu "reação: 251 ms". Se apertar antes da lâmpada, ele imprime "cedo demais" e o buzzer rosna.

O jogo inteiro são quatro laços while. Abaixo está como eles funcionam, como o while difere do for e do do while, e os três jeitos de um laço while dar errado, cada um executado em um Uno com o que ele imprimiu.

Quatro laços while fazem um jogo

Aqui está o coração do sketch que está rodando acima. O primeiro laço é a espera aleatória, e ele continua enquanto o tempo desde started for menor que wait. Dentro dele, uma verificação do botão pega uma largada falsa, e um segundo laço, menor, while (pressed()) delay(5);, espera você soltar antes de a rodada começar de novo.

Quando a espera acaba, a lâmpada acende, e while (!pressed()) delay(1); é o terceiro laço: ele não faz nada além de esperar, um milissegundo de cada vez, até o botão ser apertado. O tempo que ele esperou é a sua reação. O quarto laço, no fim da rodada, espera o botão voltar para cima, para um aperto longo não contar duas vezes.

firmware/uno/examples/reaction (a espera, do sketch rodando acima)
  unsigned long wait = (unsigned long)random(1500, 4000);
  unsigned long started = millis();
  while (millis() - started < wait) {
    if (pressed()) {
      Serial.println("too soon");
      growl();
      while (pressed()) delay(5);
      delay(500);
      return;
    }
    delay(5);
  }

  digitalWrite(LAMP, HIGH);
  unsigned long lit = millis();
  while (!pressed()) delay(1);
  unsigned long took = millis() - lit;

while, for e do while

Use for quando você sabe quantas voltas quer dar, e while quando você só sabe quando parar. Dobrar um número até passar de 100 é um trabalho para o while, porque ninguém quer calcular a contagem antes. O sketch abaixo imprimiu 128.

do { ... } while (condição); é o mesmo laço de cabeça para baixo: o bloco executa primeiro e o teste vem depois, então ele sempre executa pelo menos uma vez. Abaixo, x é 10, então while (x < 5) nunca executou seu bloco, e a versão com do executou uma vez e imprimiu "do executou". Note o ponto e vírgula depois do do while; é o único laço que precisa de um.

Dobrar até passar de 100
void setup() {
  Serial.begin(9600);
  int n = 1;
  while (n < 100) {
    n = n * 2;
  }
  Serial.println(n);
}

void loop() {
}

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

Esperar um botão

O laço vazio abaixo é o while mais simples e útil que existe. Com o botão ligado do pino 2 ao ground e o pull-up ativado, o pino lê HIGH até ser apertado, então o laço gira sem nada para fazer até lá. Apertamos 1,2 segundos depois e ele imprimiu "apertado em 1199 ms".

As chaves podem estar vazias, mas não podem faltar: while (digitalRead(BUTTON) == HIGH); com um ponto e vírgula faz a mesma coisa, e é tão fácil de ler errado que a maioria das pessoas escreve { } de propósito.

Esperar o aperto
const int BUTTON = 2;

void setup() {
  Serial.begin(9600);
  pinMode(BUTTON, INPUT_PULLUP);
  Serial.println("press the button");
  while (digitalRead(BUTTON) == HIGH) {
  }
  Serial.print("pressed at ");
  Serial.print(millis());
  Serial.println(" ms");
}

void loop() {
}

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

Laços que nunca acabam

A while loop stops only when something inside it makes the condition false. Forget to change the counter and it never does. The sketch below never adds one to i, so it printed 0 six times in just over half a second and would have kept going for as long as the board had power.

Um ponto e vírgula depois da condição faz a mesma coisa de modo mais silencioso. Em while (i < 3); {, o ponto e vírgula é o laço inteiro e o bloco depois dele fica fora, então i nunca muda. Esse sketch não imprimiu nada, nem sequer o "pronto" depois do laço, e a compilação não deu nenhum aviso. Se o seu sketch morrer depois de um tempo, olhe primeiro o fim daquela linha.

Às vezes você quer um laço que nunca acaba. while (true) { } no fim do setup() para um sketch de propósito: o nosso imprimiu "setup" e nunca imprimiu o "loop" que o loop() imprimiria.

Um contador que nunca conta
void setup() {
  Serial.begin(9600);
  int i = 0;
  while (i < 3) {
    Serial.println(i);
    delay(100);
  }
}

void loop() {
}

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

Sair com break, e a velocidade de um laço

break sai do laço na hora, o que faz de while (true) com um break dentro um formato prático quando o motivo de parar só é descoberto no meio do caminho. Abaixo, o laço soma 1, 2, 3 e assim por diante até o total passar de 50, e imprimiu "10 55": dez números, somando 55.

Um laço while vazio é muito rápido. Contando as próprias passagens por um segundo do relógio da placa, o nosso deu 353287 voltas. Coloque um analogRead() dentro e ele conseguiu 9139, porque cada leitura leva cerca de um décimo de milissegundo. É por isso que um sketch que espera em um laço while ainda percebe um aperto rapidamente.

Parar quando o total passa de 50
void setup() {
  Serial.begin(9600);
  int total = 0;
  int n = 0;
  while (true) {
    n++;
    total = total + n;
    if (total > 50) break;
  }
  Serial.print(n);
  Serial.print(" ");
  Serial.println(total);
}

void loop() {
}

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

O laço que congela tudo

Enquanto um laço while espera, nada mais acontece no sketch. No sketch abaixo, um LED pisca e imprime o tempo, e um laço while espera sempre que o botão fica apertado. Ele imprimiu "piscada em 499" e "piscada em 999", e então seguramos o botão de 0,6 a 1,8 segundos. A próxima linha foi "piscada em 2299": a piscada simplesmente parou enquanto o laço esperava.

Para o cronômetro de reação isso é exatamente certo, porque não há nada mais a fazer. Para um sketch que precisa continuar piscando, lendo um sensor ou escutando o monitor serial, não espere em um laço. Deixe o loop() girar, verifique o botão com um if a cada volta e meça o tempo com millis(), como mostra a página de piscar sem delay.

Uma piscada que para
const int BUTTON = 2;

void setup() {
  Serial.begin(9600);
  pinMode(BUTTON, INPUT_PULLUP);
  pinMode(13, OUTPUT);
}

void loop() {
  digitalWrite(13, HIGH);
  delay(250);
  digitalWrite(13, LOW);
  delay(250);
  Serial.print("blink at ");
  Serial.println(millis());
  while (digitalRead(BUTTON) == LOW) {
  }
}

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: um cronômetro de reação, ligado como está rodando no topo desta página. Mude um componente ou um valor e rode de novo.

Abrir o circuito

Perguntas

Qual é a diferença entre um laço while e um laço for?

Um laço for serve para um número conhecido de passagens e guarda seu contador em seus próprios colchetes. Um laço while só tem uma condição e roda até ela ficar falsa, o que combina com esperar um botão, um sensor ou uma entrada serial.

Qual é a diferença entre loop() e while?

loop() é a função que o Arduino chama repetidamente depois do setup(). while é um comando dentro do seu código. Um laço while dentro de loop() segura o loop() até terminar.

Por que meu laço while está travado?

Ou nada dentro dele nunca torna a condição falsa, ou há um ponto e vírgula logo depois da condição, como em while (i < 3); que faz um laço vazio para sempre. Imprima algo dentro do laço para ver se ele está girando.

Como saio de um laço while no Arduino?

Torne a condição falsa de dentro do laço, ou use break, que sai do laço na hora. return sai da função inteira em que o laço está.

Como espero um aperto de botão no Arduino?

Com o botão do pino para o terra e pinMode(pin, INPUT_PULLUP), while (digitalRead(pin) == HIGH) { } espera até ser apertado. Nada mais no sketch roda enquanto ele espera.

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.