Arduino, Internet das Coisas e Computação vestível

[Voltar]

[Avançar]

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.

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". Ele segue o seguinte formato:

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

No código abaixo, um LED pisca três vezes, depois espera cinco segundos, piscar mais três vezes e assim por diante. 

// Programa: Pisca o LED três vezes

int i = 0; 					// Variável para contar o número de vezes que o LED piscou
  
while (i < 3) {  
     digitalWrite(led, HIGH);   	// Atribui nível lógico alto ao pino do LED, acende
     delay(1000);               		// Espera 1000 milissegundos (um segundo)
     digitalWrite(led, LOW);    	// Atribui nível lógico baixo ao pino do LED, apaga
     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

Do / While

O do / while é uma estrutura que executa um conjunto de comandos repetidas vezes enquanto uma determinada condição for verdadeira. É quase o mesmo funcionamento que o while, a diferença é que com o uso dele teremos os comandos executados ao menos uma única vez. Ele segue o seguinte formato:

do { 
      // comandos; 
} while (condicao);

No código abaixo, é feita uma verificação dos valores aumentados e a cada “passada” do loop, é incrementado em 50 o valor do aumento. 

decimal aumento = 250;

do {
     Serial.print("O valor atual do aumento é de: ");
     Serial.println(aumento);
     aumento = aumento + 50;
} while (aumento < 500);

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 iffor 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.

Switch...case

A instrução switch compara o valor de uma variável com os valores especificados em instruções case. Quando uma instrução case é encontrada, cujo valor corresponde ao da variável, o código nessa instrução case é executado. A palavra-chave break sai da instrução switch e é normalmente usada no final de cada caso. Sem uma instrução break, a instrução switch continuará executando as expressões abaixo dela. 

switch (LED) {
      case label1:
            // statements
            break;
      case label2:
            // statements
            break;
      default:
            // statements
            break;
}

Para exemplificar, vamos declarar 3 LEDs. Depois vamos fazer com que eles acendam em sequencia:

// Variável para controlar a sequencia de acionamento dos LEDs
  
int i=0;

// soma 1 a variável

i++;           					

switch (i) {
      case 1:
            digitalWrite(led1, HIGH);   	    // Atribui nível lógico alto ao pino do LED, acende
            digitalWrite(led2, LOW);   	    // Atribui nível lógico baixo ao pino do LED, acende
            digitalWrite(led3, LOW);   	    // Atribui nível lógico baixo ao pino do LED, acende 
            break;
      case 2:
            digitalWrite(led1, LOW);   	    // Atribui nível lógico baixo ao pino do LED, acende
            digitalWrite(led2, HIGH);   	    // Atribui nível lógico alto ao pino do LED, acende
            digitalWrite(led3, LOW);   	    // Atribui nível lógico baixo ao pino do LED, acende
            break;
      default:
            digitalWrite(led1, LOW);   	    // Atribui nível lógico baixo ao pino do LED, acende
            digitalWrite(led2, LOW);   	    // Atribui nível lógico baixo ao pino do LED, acende
            digitalWrite(led3, HIGH);   	    // Atribui nível lógico alto ao pino do LED, acende
            i=0;                               	    // Inicializa a variável em 0;
            break;
}
delay(1000);
 

Saiba mais em: https://www.arduino.cc/reference/en/#structure

 

 

[Voltar]

[Avançar]

 
 
© Copyright 2018 / 2024 - André Luis Marques da Silveira