Código sem Delay no Arduino com Waiting Time

Dispense o uso exagerado do delay e tenha um código performático com seu Arduino de forma simples e prática com Waiting Time.

Diferença entre Delay e Millis

Para entender a diferença entre delay e millis é necessário fazer uma analogia, até um pouco “maluca” mas servirá como exemplo.

Quando um ônibus de uma determinada rota precisa deixar um passageiro, ele vai parar em um ponto de ónibus, quando isso ocorre seu fluxo dentro da rota ficará parado até que a tarefa de deixar o passageiro seja concluído, o delay com arduino é a mesma coisa.

Pegando o mesmo principio, agora usando o conceito do mills, se ao invés do motorista ter que parar o ônibus para os passageiros descer, caso se jogassem sem se machucar o ônibus conseguiria fazer mais ciclos na sua rota em comparação com o sistema anterior.

Problemas do Uso do Millis

O millis é até bem usado em diversas bibliotecas e aplicações porém usam um padrão de código como o abaixo:

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

O problema desse uso é que em alguns casos que trabalha também como o delay, métodos e callbacks, pode ocorrer do ciclo entrar na condicional e executar o que estiver dentro na velocidade do clock do microcontrolador.

Esse problema se da pelo uso do ‘maior que’ usado na condicional, porém caso for usado o sinal de igualdade, será executado uma vez da maneira certa e depois irá parar de funcionar. O ideal com base em teste, foi usar o ‘maior que’ e ‘menor que’ uma margem de erro, mas ainda assim não resolveria 100% pois haverá uma série de fatores que poderão atrasar o código e ultrapassar os limites da condicional.

Solução para o Uso do Millis com Waiting Time

A solução foi criar um sistema que se autocompense para que atenda não só a margem de erro para variação de tempo mas também que se ajustasse total do microcontrolador. Se houver um ciclo anterior ou posterior e ultrapassar o tempo desejado, a biblioteca irá se ajustar e no próximo ciclo já será executado a tarefa com o tempo programado.

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;
}

Baixe Agora Gratuitamente no Botão Abaixo

Como Usar?

Primeiramente ao inicializar a biblioteca, deve ser definido um valor acima de zero e a quantidade de vezes que será usado da seguinte forma:

#include <Elcereza_Waiting_Time.h>

Waiting_Time t(3);                     // Valor deve ser > 0

A biblioteca é compatível com diversos microcontroladores, no entanto, em caso de ESP o Waiting Time não deverá ser nomeado como “time” pois haverá conflito.

Na hora de usar dentro do processo do microcontrolador, a operação a ser executada deve está dentro de uma condicional e o parâmetro que habilita é justamente o retorno ‘true’ do callback ‘wait(tempo, memoria)’. Para usar o callback ‘wait’ é necessário entender e definir duas coisas:

1. O primeiro valor definido é sempre o tempo desejado em milissegundos;
2. O segundo valor é justamente um endereço no qual o tempo anterior será armazenado, da mesma forma que é usado no padrão do millis e por se tratar de um array, o primeiro posição sempre será 0.

Exemplo com LEDs

Toda essa questão anteriormente citadas, podem ser observadas com mais detalhes no exemplo com o uso de 3 LEDs.

Diagrama

Código

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.

/*=======================================================================
  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 : 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));
}

Funcionamento

No vídeo abaixo é possível perceber claramente a diferença do uso de nossa biblioteca que utiliza o millis em relação ao uso tradicional do delay. Ambos os arduinos abaixo, estão realizando a mesma operação de mesmo tempo, a diferença é justamente o millis e delay.