Arduino - #07 Introdução à Programação (Tempos de Espera)

No seguimento desta serie de tutoriais “Arduino - Introdução à Programação”, hoje iremos falar sobre funções que nos permitem definir tempos de espera nas nossas aplicações.

Como podemos observar em exemplos referidos em publicações anteriormente como o programa “Blick” foi utilizada uma função chamada delay para que fosse possível efetuar um atraso no tempo ou pausa chamemos assim na execução do código por alguns segundos de forma a vermos o alternar de estado LED, piscar.

Para além da função delay existem outras funções e métodos que nos permitem efetuar tempos de espera ao longo dos nossos projetos, como a função delayMicroseconds, millis, micros e interrupts. Ao longo deste tutorial iremos abordar somente as funções delay, delayMicroseconds, millis e micros, a função interrupts será abordada mais para a frente numa nova publicação desta serie de tutorias.

Função delay() / delayMicroseconds()

As funções delay() ou delayMicroseconds() têm como objetivo parar o programa por um determinado período de tempo. Ambas funções são muito simples de programar bastando colocar como parâmento o tempo em milissegundos caso usarmos a função delay() ou em microssegundos no caso de estarmos a usar a função delayMicroseconds().

Declaração:

• delay(tempo em ms) 
• delayMicroseconds(tempo em us) 

Exemplo:
No exemplo seguinte temos a função Blink que podemos encontra nos exemplos do nosso software do Arduino.

// the setup function runs once when you press reset or power the board
void setup() 
{
     // initialize digital pin LED_BUILTIN as an output.
     pinMode(LED_BUILTIN, OUTPUT);
}

// the loop function runs over and over again forever
void loop() 
{
     digitalWrite(LED_BUILTIN, HIGH);   // turn the LED on (HIGH is the voltage level)
     delay(1000);                       // wait for a second
     digitalWrite(LED_BUILTIN, LOW);    // turn the LED off by making the voltage LOW
     delay(1000);                       // wait for a second
}

Como podemos ver no código de exemplo é possível colocar o led a piscar num intervalo de 1000 milissegundos ou seja 1 segundo ficando 1 segundo em cada um dos 2 estados, de uma forma muito simples graças à função delay(). 


Estas são funções muito simples de se trabalhar, no entanto por vezes não são as mais indicadas. Pois tal como foi referido, estas funções têm como objetivo parar o nosso programa por um determinado período de tempo, em certas circunstâncias a função delay() não é a melhor opção pelo facto de por exemplo quando pretendemos que o nosso Arduino esteja a fazer várias leituras de diferentes sensores, a função delay() como para o programa por completo poderá atrapalhar as outras leituras. Por essas razões esta função só deve ser usada em pequenos projetos como piscar LEDs, luzes, etc.

Função millis() / micros()

A função millis() ou micros() funciona de uma maneira muito diferente da função delay(). Ambas contam o tempo em milissegundos(millis) ou em microssegundos(micros) desde que o nosso programa começou a sua execução.

Ao contrario da função delay() estas funções não para o nosso programa, o que se torna pertinente. Por outro lado estas funções não são tão simples como a delay(). Como podemos supor, estas funções simplesmente iniciam um pequeno contador quando o nosso programa arranca, se colocarmos o millis() da mesma maneira que colocamos o delay() simplesmente não vai acontecerá nada.

Para demonstrar e explicar como podemos usar a função millis() / micros() iremos recordar o projeto do Blick. Se olharmos para este projeto já referido atras verificamos que foi utilizado a função delay() para que nos fosse possível mostrar o led a piscar num determinado período de tempo. Desta vez iremos alterar este projeto mas de maneira a usarmos a função millis() invés da função delay().

Exemplo:

Função Blink alterada para trabalhar com a função millis() e obtermos o mesmo resultado que a função delay() nos proporcionava.

const int ledPin = 13;     //número do pino do LED
int ledState = LOW;      //ledState usado para definir o estado do LED

// Geralmente, deve-se usar "unsigned long" para variáveis que guardam tempo
unsigned long previousMillis = 0;     //irá armazenar última vez que o LED foi atualizado
const long interval = 1000;              //intervalo no qual vai piscar em (milissegundos)

void setup()
 {
  //defina o pino digital como saída:
  pinMode(ledPin, OUTPUT);
}

void loop() 
{
 
    // verifique se está na hora de piscar o LED; isto é, se a diferença
    // entre a hora atual e a última vez que você piscou, o LED é maior que
    // o intervalo em que você deseja piscar o LED.
  unsigned long currentMillis = millis();

  if (currentMillis - previousMillis >= interval) 
        {
    // salve a última vez que você piscou o LED
    previousMillis = currentMillis;

    //se o LED estiver desligado, ligue-o e vice-versa:
            if (ledState == LOW)
            {
      ledState = HIGH;
            } 
            else 
            {
      ledState = LOW;
            }

      //defina o LED com o ledState da variável:
    digitalWrite(ledPin, ledState);
  }
}

Como verificamos no programa acima, para usarmos a função millis() ou micros() invés da função delay() é preciso criar uma condição que verifica se o tempo percorrido do programa é maior ou igual ao intervalo de tempo definido.

Para que o tempo seja sempre sincronizado e atualizado é necessário guardar o tempo percorrido numa variável, neste caso a variável tem como nome “previousMillis”.

Estas funções apresentadas são aquelas que podemos usar no Arduíno. Como podemos verificar neste tutorial a melhor maneira de efecturar um tempo de espera será com a função millis() / micros(). Além destas funções podemos, podemos substituir estas funções por Interrupts, o que na maioria dos casos é a opção mais pertinente, mas é conteúdo para ser abordado num outro tutorial.

Links úteis

      Função delay()
      Função millis()

Considerações Finais

A utilização de funções que permitam controlar o tempo são muito úteis mas podem ser um problema, pois sempre que se realiza uma pausa, um atraso no nosso código todo o código é afetado o que pode em sistemas mais complexos ser um problema. No entanto garças a função millis() essa questão pode ser facilmente ultrapassada, mas o código será um pouco mais complexo.

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áfico