Estruturas de Controle - Arduino

Estruturas de controle são blocos de instruções que alteram o fluxo de execução do código de um programa. Com elas é possível fazer coisas como executar comandos diferentes de acordo com uma condição ou repetir uma série de comandos várias vezes, por exemplo.
A seguir nós veremos algumas das estruturas de controle mais comuns usadas nas linguagens de programação em geral. Vamos também modificar o nosso programa de teste para exemplificar melhor como essas estruturas funcionam.

While

O while é uma estrutura que executa um conjunto de comandos repetidas vezes enquanto uma determinada condição for verdadeira. While em inglês quer dizer "enquanto", e pronuncia-se "uái-ou". Ele segue o seguinte formato:

while(condição) {
    ...
}

Vamos então fazer uma modificação no nosso programa para exemplificar melhor como o while funciona. O nosso objetivo agora é fazer o LED piscar três vezes, depois esperar cinco segundos, piscar mais três vezes e assim por diante. Nós vamos mudar o conteúdo da função loop() para o seguinte:

  // Variável para contar o número de vezes que o LED piscou
  int i = 0;
  
  // Pisca o LED três vezes
  while(i < 3) {
    digitalWrite(led, HIGH); // Atribui nível lógico alto ao pino do LED, acendendo-o
    delay(1000);             // Espera 1000 milissegundos (um segundo)
    digitalWrite(led, LOW);  // Atribui nível lógico baixo ao pino do LED, apagando-o
    delay(1000);             // Espera 1000 milissegundos (um segundo)
    i = i + 1;               // Aumenta o número de vezes que o LED piscou
  }
  
  delay(5000);               // Espera 5 segundos para piscar o LED de novo

Primeiro nós declaramos uma variável i. Essa variável vai contar quantas vezes o LED já piscou desde o início do programa ou desde a última pausa de cinco segundos. Nós vamos inicializar essa variável com zero porque no início da função loop() o LED ainda não piscou nenhuma vez sob essas condições.
Em seguida nós inserimos o comando while, que deve ser seguido de uma condição definida entre parênteses. Enquanto essa condição for verdadeira, todo o bloco de comandos entre os caracteres { e } é executado repetidamente. No caso do nosso programa, enquanto o número de "piscadas" do LED (representado pela variável i) for menor do que três, nós continuamos a executar os comandos que fazem o LED piscar. Isso é representado pela expressão i < 3 dentro dos parênteses.
Entre os caracteres { e } nós colocamos o código que faz o LED piscar, como anteriormente, mas não podemos nos esquecer de somar 1 à variável que conta o número de "piscadas". Isso é feito na seguinte linha de código:

    i = i + 1;               // Aumenta o número de vezes que o LED piscou

Veja que após executar todos os comandos entre { e }, sempre teremos na variável i o número de vezes que o LED piscou desde o início da função loop(). Vamos percorrer a sequência de passos executada cada vez que a função loop() é chamada:

1. Atribuímos 0 à variável i: o LED ainda não piscou nenhuma vez.
2. Comparamos se i < 3: como 0 é menor do que 3, executamos os comandos entre { e }:
   1. Executamos os comandos para acender e apagar o LED.
   2. Somamos 1 à variável i, tornando-a 1: sabemos que o LED piscou uma vez.
3. Voltamos ao início do while e comparamos se i < 3: como 1 é menor do que 3, executamos os comandos entre { e } novamente:
   1. Executamos os comandos para acender e apagar o LED.
   2. Somamos 1 à variável i, tornando-a 2: sabemos que o LED piscou duas vezes.
4. Voltamos ao início do while e comparamos se i < 3: como 2 é menor do que 3, executamos os comandos entre { e } novamente:
   1. Executamos os comandos para acender e apagar o LED.
   2. Somamos 1 à variável i, tornando-a 3: sabemos que o LED piscou três vezes.
5. Voltamos ao início do while e comparamos se i < 3: como 3 não é menor do que 3, não executamos mais os comandos entre { e } e prosseguimos à próxima instrução.
6. Esperamos cinco segundos por meio da chamada delay(5000).

Após esses passos, chegamos ao final da função loop(), e como já sabemos, ela é chamada novamente pelo sistema do Arduino. Isso reinicia o ciclo, executando os passos acima indefinidamente.
Rode o programa modificado com as instruções acima no seu Arduino e tente variar o número de "piscadas" e o número

For

Agora que nós já aprendemos o comando while, fica muito fácil aprender o comando for, pois ele é quase a mesma coisa. Vamos modificar o conteúdo da função loop() como fizemos acima, porém usando o for no lugar do while:

  // Variável para contar o número de vezes que o LED piscou
  int i;
  
  // Pisca o LED três vezes
  for(i = 0; i < 3; i++) {
    digitalWrite(led, HIGH); // Atribui nível lógico alto ao pino do LED, acendendo-o
    delay(1000);             // Espera 1000 milissegundos (um segundo)
    digitalWrite(led, LOW);  // Atribui nível lógico baixo ao pino do LED, apagando-o
    delay(1000);             // Espera 1000 milissegundos (um segundo)
  }
  
  delay(5000);               // Espera 5 segundos para piscar o LED de novo

A primeira modificação que fizemos foi declarar a variável i sem inicializá-la com o valor 0. Nós podemos fazer isso porque o comando for fará isso para a gente. Ele segue o seguinte formato:

for(inicialização; condição; finalização) {
    ...
}

Vamos descrever cada item separadamente:

• Condição: é uma expressão verificada repetidamente, de forma idêntica à condição entre parênteses do while. Enquanto ela for verdadeira, os comandos entre { e } continuam sendo executados.
• Inicialização: é um comando executado apenas uma vez no início do comando for.
• Finalização: é um comando executado repetidas vezes ao final de cada execução dos comandos entre { e }.

Podemos então verificar que o for nada mais é do que um while acrescido de um comando de inicialização e um comando de finalização. Para o nosso programa de teste, esses comandos são, respectivamente:

• i = 0: inicializa a contagem do número de "piscadas".
• i++: soma 1 à variável i ao final da execução dos comandos entre { e }; nesse caso ele é equivalente ao comando i = i + 1. O operador ++ é chamado de operador de incremento, e é muito usado na linguagem C++.

Se executarmos o programa acima no Arduino, veremos que o resultado é o mesmo que obtivemos com o programa que fizamos anteriormente utilizando o while.

If

O if é uma das estruturas mais básicas de programação em geral. If significa "se" em inglês, e é exatamente isso que ele faz: ele verifica uma expressão e, apenas se ela for verdadeira, executa um conjunto de comandos. Em linguagem natural, ele executa uma lógica do tipo: "se isso for verdadeiro, então faça aquilo"
Para ilustrar, vamos modificar o nosso programa de exemplo para que ele faça a mesma coisa que fizemos com o while e o for acima, porém vamos fazer isso usando um if, que segue o seguinte formato:

if(condição) {
    ...
}

A lógica é muito simples: sempre que a condição vor verdadeira, os comandos entre { e } são executados, caso contrário o programa prossegue sem executá-los. Vamos ver então como fica a função loop():

// Variável para contar o número de vezes que o LED piscou
int i = 0;

void loop() {
  digitalWrite(led, HIGH); // Atribui nível lógico alto ao pino do LED, acendendo-o
  delay(1000);             // Espera 1000 milissegundos (um segundo)
  digitalWrite(led, LOW);  // Atribui nível lógico baixo ao pino do LED, apagando-o
  delay(1000);             // Espera 1000 milissegundos (um segundo)
  
  i++;                     // Incrementa o número de "piscadas"
  if(i == 3) {
    delay(5000);           // Espera 5 segundos para piscar o LED de novo  
    i = 0;                 // Reinicia o contador de número de "piscadas"
  }
}

Aqui a lógica é um pouco diferente: nós vamos manter a função loop() piscando o LED como no programa original, porém vamos inserir uma espera adicional de 5 segundos após cada 3 piscadas. Para isso, criamos uma variável i fora da função loop(); ela precisa ser declarada de fora da função para poder reter o seu valor entre cada execução da função loop(). Chamamos isso de variável global. Quando a variável é declarada dentro do corpo da função, ela não retém o valor etnre cada execução, sendo reiniciada a cada vez que a função é re-executada. Chamamos isso de variável local.
Nós usaremos então essa variável global i para contar, novamente, o número de vezes que o LED acendeu e apagou. Na declaração da variável, nós a inicializamos com o valor 0 para indicar que o LED não acendeu nenhuma vez ainda. A função loop() então começa a ser executada, acendendo e apagando o LED. Para contar o número de vezes que o LED piscou, nós adicionamos a seguinte linha de código:

  i++;                     // Incrementa o número de "piscadas"

Em seguida utilizamos o if para verificar se acabamos de acender o LED pela terceira vez. Para isso, usamos a expressão i == 3 na condição do ìf. Se essa expressão for verdadeira, isso que dizer que o LED já acendeu 3 vezes, então inserimos uma pausa adicional de 5 segundos com a chamada delay(5000) e reiniciamos a contagem do número de "piscadas" novamente com o seguinte comando:

    i = 0;                 // Reinicia o contador de número de "piscadas"

A partir daí a função loop() continua sendo chamada e o ciclo se inicia novamente.

If-Else

O if-else, também conhecido como if-then-else, pode ser visto como uma extensão do comando if. Else em inglês significa "caso contrário", e ele faz exatamente o que o nome diz: "se isso for verdadeiro, então faça aquilo, caso contrário, faça outra coisa". Ele segue o seguinte formato:

if(condição) {
   ...
} else {
   ...
}

Para exemplificar, vamos usar o programa do for que mostramos acima, mas vamos dessa vez fazer o LED acender e apagar quatro vezes antes de dar uma pausa de cinco segundos. Depois vamos fazer com que na terceira de cada uma dessas quatro "piscadas", o LED acenda por um período mais curto. Dentro da função loop(), teremos o seguinte:

  // Variável para contar o número de vezes que o LED piscou
  int i;
  
  // Pisca o LED três vezes
  for(i = 0; i < 3; i++) {
    if(i == 2) {
      digitalWrite(led, HIGH); // Atribui nível lógico alto ao pino do LED, acendendo-o
      delay(200);              // Espera 200 milissegundos (um segundo)
      digitalWrite(led, LOW);  // Atribui nível lógico baixo ao pino do LED, apagando-o
      delay(1800);             // Espera 1800 milissegundos (um segundo)
    } else {
      digitalWrite(led, HIGH); // Atribui nível lógico alto ao pino do LED, acendendo-o
      delay(1000);             // Espera 1000 milissegundos (um segundo)
      digitalWrite(led, LOW);  // Atribui nível lógico baixo ao pino do LED, apagando-o
      delay(1000);             // Espera 1000 milissegundos (um segundo)
    }
  }
  
  delay(5000);               // Espera 5 segundos para piscar o LED de novo

Aqui o que fazemos é, toda vez que vamos acender o LED, verificar se é a terceira vez que isso acontece, por meio do comando if com a condição i == 2. Se essa expressão for verdadeira, isso quer dizer que já acendemos o LED duas vezes e estamos prestes a acendê-lo pela terceira vez; nesse caso mudamos o tempo que o LED fica acaso para um valor menor, de 0,2 segundo (uma redução de 0,8 segundo) e o tempo que ele fica apagado para um valor maior, de 1,8 segundos (aumento de 0,8 segundo).
Mas e se essa não for a terceira vez que o LED está sendo acionado? É aí que entra o else: se a condição do if for verdadeira, o bloco de comandos entre { e } logo após o if é executado, caso contrário, o bloco entre { e } após o else é executado. Isso quer dizer que para a primeira, segunda e quarta "piscadas" será usado o tempo padrão de um segundo.

Fonte:  www.circuitar.com.br/tutoriais/programacao-para-arduino-primeiros-passos/#estruturas-de-controle