Arduino - #04 Introdução à Programação (Estruturas de Controle - Parte 1)

No seguimento do que temos vindo a abordar, iremos hoje falar das estruturas de controlo de fluxo e de tomada de decisão.

Estruturas de controlo de fluxo e tomada de decisão

A ordem normal execução dos comandos do código de um programa é de cima para baixo e cada comando é executado um após o outro na mesma sequência em que foram escritos. Ao que damos o nome de execução sequencial.

No entanto nas linguagens de programação existem vários comandos que permitem alterar a ordem de execução do código, estes permitem ao programador indicar qual o próximo comando ser executado que, pode ser outro que não o próximo da sequência da escrita.

Para tal recorremos as estruturas de controlo que são blocos de instruções que alteram o fluxo de execução do código de um programa. Sendo possível executar comandos diferentes de acordo com uma determinada condição ou repetir uma série de comandos várias vezes, por exemplo.

De seguida iremos analisar algumas das estruturas de controlo mais comuns usadas nas linguagens de programação em geral. Iremos ainda alterar o nosso programa de teste para demonstrar na prática cada uma destas e entendermos melhor como estas funcionam.

Estruturas de Controlo:

Parte 1 - Controlo de fluxo

While

O while é uma estrutura que executa um conjunto de comandos repetidas vezes enquanto uma determinada condição for verdadeira. While é uma expressão Inglesa que significa "enquanto". 

Declara-se da seguinte forma:

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

Para melhor compreendermos como este funciona vamos alterar o programa Blink, incluindo neste a estrutura de controlo While e uma condição. O nosso objetivo agora é fazer o LED piscar três vezes, depois ficar cinco segundos, apagado e piscar mais três vezes e ficar mais cinco segundo desligado e assim por diante. 

Iremos então alterar o código da função loop() para o seguinte código:

  void loop()
    {
         // 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, LED ON
              delay(1000); // Espera 1000 milissegundos (um segundo)
              digitalWrite(led, LOW); // Atribui nível lógico baixo ao pino do LED, LED OFF
              delay(1000); // Espera 1000 milissegundos (um segundo)
              i = i + 1; // Incrementa o número de vezes que o LED pisca
          }

         delay(5000); // Espera 5 segundos para piscar o LED de novo
     }

Breve explicação:
Primeiro declaramos uma variável i que é a variável onde iremos guardar o número de vezes que o LED piscou desde o início do programa ou desde a última pausa de cinco segundos. Sendo esta variável inicializada a zero logo no início da função loop() uma vez que o LED ainda não piscou nenhuma vez nestas condições.

De seguida 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 chavetas (Caracteres { e }) será repetidamente executado. No caso do nosso programa, enquanto o número de vezes que o LED piscar (representado pela variável i) for menor do que três ou seja "i<3", o código continuará a ser executado e o LED continuará a piscar.

Entre as chavetas “{  }” colocamos o código que faz o LED piscar, e a instrução “i = i + 1” responsável pelo incremento da variável i que conta o número de vezes que o LED pisca.

Após executar todos os comandos entre chavetas, vamos ter na variável i o número de vezes que o LED já piscou desde o início da função loop(), logo segundo a nossa condição sempre que i=3 o programa faz uma pausa de 5 segundos e em seguida voltamos ao inicio da função loop, reiniciando a variável i=0 e voltado a repetir-se o ciclo while.

Passo por passo:

1. Atribuímos 0 à variável i, uma vez que o LED ainda não piscou nenhuma vez;
2. Verificamos i < 3 como, i= 0 é menor que 3 logo executamos os comandos entre chavetas;
3. São executados os comandos para acender e apagar o LED;
4. Incrementamos 1 à variável i, i=1, sabemos que o LED piscou uma vez;
5. Voltamos ao início do while, i < 3 como i=1 e é menor do que 3, executamos os comandos entre chavetas novamente;
6. São executados os comandos para acender e apagar o LED;
7. Incrementamos 1 à variável i, i= 2, sabemos que o LED piscou duas vezes;
8. Voltamos ao início do while, i < 3 como i=2 e é menor do que 3, executamos os comandos entre chavetas novamente;
9. São executados os comandos para acender e apagar o LED;
10. Incrementamos 1 à variável i, i=3,  sabemos que o LED piscou três vezes;
11. Voltamos ao início do while, i < 3, como i=3  e não é menor do que 3, pois 3=3 não executamos os comandos entre chavetas e prosseguimos para a próxima instrução;
12. O código faz uma “pausa” de cinco segundos por meio da chamada delay(5000).

Após estes passos, chegamos ao final da função loop(), e como já é sabido, esta função é executada em loop infinito logo volta a ser chamada pelo sistema do Arduino. Isso reinicia o ciclo, executando os passos acima indefinidamente até ser interrompido por um Reset ou pelo corte da alimentação do nosso Arduino.

Exercício:

Executem o código acima nos vossos Arduinos e vão variando o valor da condição While para entenderem bem como esta funciona. 

For

Após entendermos como funciona o comando While, fica mais fácil entender o funcionamento da estrutura de controlo For, pois este é muito semelhante ao While, sendo também uma estrutura de loop. 

Esta é declarada da seguinte forma:

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

Legenda:

• Inicialização: é onde é feita a inicialização da variável de controlo, este é executado apenas uma vez no início do comando for.
• Condição: é a expressão que vai ser verificada repetidamente, de forma idêntica à condição entre parênteses do While. Enquanto esta for verdadeira, os comandos entre chavetas serão executados.
• Finalização: este comando é executado repetidas vezes no final de cada execução dos comandos entre chavetas serve para incrementar a variável i em uma unidade ou seja soma a i o valor 1.

Vamos agora alterar o código da função loop() do programa Blink como fizemos anteriormente, no entanto agora vamos usando o comando For em vez do While.

  void loop()
   {
       // 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 alteração feita foi a declaração da variável i, como se pode ver esta foi declarada mas não inicializada com o valor 0, pelo simples facto desta ir agora ser inicializada dentro do comando For. 

• i = 0, inicializa a contagem do número de vezes que o LED pisca.
• i++: incrementa 1 à variável i no final da execução dos comandos entre chavetas, sendo equivalente ao comando i = i+1. O operador ++ é chamado de operador de incremento, e é muito usado na linguagem C/C++.

Se executarmos o programa Blink com as alterações acima feitas no nosso Arduino, iremos verificar que o resultado é o mesmo que obtivemos anteriormente com o comando While.

Podemos então verificar que a estrutura For nada mais é do que um While mas representado de uma forma diferente, mas que no final tem o mesmo comportamento.

Exercício:

Executem o código acima nos vossos Arduinos e vão variando o valor da condição For para entenderem bem como esta funciona.

Não estando a alongar mais esta publicação iremos abordar na próxima publicação desta rubrica a segunda parte das estruturas de controlo designadas por estruturas de decisão.

Até lá vão fazendo testes com o que já foi introduzido para não deixarem cair no esquecimento os assuntos abordados.

Considerações Finais

As estruturas de controlo são peças fundamentais na elaboração de qualquer programa, pois embora a função loop possa fazer o nosso código ser executado de forma cíclica esta não chega para colmatar todas as necessidades ao longo da elaboração dos projetos mais ou menos complexos.
Como podemos constatar a estrutura While e For são muito semelhantes, sendo mesmo iguais no que toca a seu funcionamento, estas são duas estruturas de grande importância no mundo da programação.

Esperamos que este artigo tenha sido útil e se gostaram comentem e partilhem. Alguma dúvida ou questão deixem em comentário ou utilizem o formulário de contatos.

Um bom dia em nome da TecnoDomos.

Conteúdo redigido ao abrigo do novo Acordo Ortográfica