Arduino SEM Delay com Waiting Time

O recurso mais comum para definir tempo no Arduino é o “delay”, no entanto, não é nada performático o que reduz muito o poder computacional do microcontrolador. Entretanto, o uso da biblioteca Waiting Time pode trazer ao seu código alta performance e eficiência.

Problema do Uso do Delay na Performance

O delay embora seja útil e funcional em determinados casos, em aplicações mais complexas que precisam ser executadas no menor tempo possível o delay acaba sendo um grande problema. No entanto, é uma solução alternativa é o uso do millis().

Uso do waiting time para tirar o atraso do processamento do arduino.
Fonte: Freepik

Como Usar Millis?

Um recurso bastante utilizado ao invés do delay é o millis mas muita gente não sabe usar e em alguns casos as aplicações do millis ficam restritas exclusivamente para processos de loop e geralmente é usado dessa forma abaixo:

int ptime = 0; 
void loop(){
 if(millis() - ptime > 1000){
   Serial.println("1s");
   ptime = millis();
 }
}

Problemas do Uso do Millis()

Em casos simples o código acima funciona bem, mas em casos mais complexos que necessitem do uso de callbacks e métodos ou até mesmo um uso misto com o delay, o ‘ptime’ que seria o tempo anterior acaba sempre sendo maior que o tempo estimado, no caso a cima ‘1s’, fazendo com que haja processamento muito rápido do código dentro da condicional.

Solução para Uso do Millis()

Quando comparado de forma exata com o uso de ‘==’ pode funcionar a penas uma única vez e acaba deixando todo resto do processo completamente inutilizável. Porém a lógica a seguir funcionou muito bem em aplicações gerais com uma margem de variação de 1% no tempo estipulado, como o código abaixo:

Se resume a um callback do tipo boleeano que retorna verdadeiro quando o tempo desejado é atingido, caso contrário retorna falso e se ajusta com o tempo atual para no próximo ciclo coincidir com o tempo certo e por isso deve ser usado um com condicional ‘if’.

bool Waiting_Time::wait(double t, int i){
  int m = millis();  
  if(((m - p[i]) > t && (m - p[i]) < (t * 1.01)) || !c[i])
  {
    p[i] = millis();
    if(!c[i])
    {
      c[i] = true;
      return false;
    }
    else
      return true;
  }
  else if((m - p[i]) > (t * 1.01))
  {
    p[i] = millis();
    return false;
  }
  else
    return false;
}

Exemplo com LEDs

A forma mais simples de demonstrar o funcionamento do Waiting Time é com LEDs piscando de forma independentes com tempos dependentes.

Diagrama Esquemático

Diagrama esquemático exemplo do waiting time com LEDs no Arduino.
Fonte: Elcereza

Código Exemplo Waiting Time

O código abaixo é um exemplo de aplicações com LED e está disponível em ‘exemples’ da biblioteca que está disponível para download no GitHub. Caso queira aprender como criar sua biblioteca para Arduino, clique aqui.

/*=======================================================================
  Esse é um exemplo básico para acionar LEDs de forma independente sem
  o uso do delay. Podendo ser implementado em diversas aplicações, 
  dando uma sensação de processamento assincrono mas na verdade
  só aproveita 100% do clock do microcontrolador.
  
  Site  : https://elcereza.com/waiting_time
  Autor : Gustavo Cereza
  Disponibilizado por : Elcereza
  Redes : @ellcereza
  Canal : https://t.me/elcereza
=======================================================================*/

#include <Elcereza_Waiting_Time.h>

#define LED1 12
#define LED2 9
#define LED3 6

Waiting_Time t(3);                                                 // Define quantos 'wait' serão usados

void setup() {
  pinMode(LED1, 1);
  pinMode(LED2, 1);
  pinMode(LED3, 1);
}

void loop() {
  if(t.wait(1000, 0))                                              // Aguarda 1000ms armazenado em 0
    digitalWrite(LED1, !digitalRead(LED1));
    
  if(t.wait(2500, 1))                                              // Aguarda 2500ms armazenado em 1
    digitalWrite(LED2, !digitalRead(LED2));

  if(t.wait(4500, 2))                                              // Aguarda 4500ms armazenado em 2
    digitalWrite(LED3, !digitalRead(LED3));
}

Comparativo Waiting Time com Delay

No vídeo abaixo é possível perceber que cada LED pisca de forma independente em tempos distintos. Do outro lado, o arduino realiza o mesmo processo porém com o uso do delay, note a diferença de velocidade.

Sobre Gustavo Cereza 1 artigo
Meu nome é Gustavo Cereza sou de SA/BA/BR, tenho 21 anos, fiz iniciação cientifica de inovações tecnológicas no SESI e atualmente estou cursando eletromecânica. Sou fundador da elcereza.com e do app Orion, um amante da eletrônica desde a infância e gosto de transformar ideias em realidade usando a tecnologia.

Seja o primeiro a comentar

Deixe uma resposta

O seu endereço de email não será publicado.


*