Início / Software / Dicas de Software / Como usar temporizadores no Arduino

Como usar temporizadores no Arduino

Angelo Luis Ferreira | 26/03/2021 Acessos: 15.042

Funções de temporização na programação com Arduino

Objetivo

Nesta dica vamos mostrar utilizar as diversas funções de temporização disponíveis na programação com Arduino. As funções de Temporização servem para pausar o programa por um determinado tempo ou para contar um período de tempo entre duas referências específicas.

Funções de temporização:

delay()
delayMicroseconds()
millis()
micros()

1. Função delay()

1.1. A função delay() pausa a execução do programa por um intervalo de tempo especificado em milissegundos (ms). Cada segundo equivale a 1000 milissegundos.

1.1.1. É importante frisar que quando utilizamos a função delay() o programa fica parado completamente pelo período de tempo especificado.

1.1.2. Portanto, o emprego da função delay() deve ser utilizada apenas em aplicações muito simples ou quando usado com períodos de tempo bem pequenos, como para resolver problemas de "deboucing", por exemplo.

1.1.3. As interrupções externas não são desativadas durante a pausa pela função delay().

1.1.4. O tipo de dado aceito para o parâmetro tempo é unsigned int. Veja Tipos de dados usados pelo Arduino.

1.1.4. Recomenda-se como alternativa a utilização da função milis().

1.2. Sintaxe:

delay(tempo);

1.3. Exemplo:

1.3.1. Fazer um Led conectado no pino 13 do Arduino piscar, sendo 2 segundos aceso e 1 segundo apagado.

const byte ledPin = 13;

void setup() {
  pinMode(ledPin, OUTPUT);
}

void loop() {
  digitalWrite(ledPin, HIGH);
  delay(2000);
  digitalWrite(ledPin, LOW);
  delay(1000);
}

2. Função delayMicroseconds()

2.1. A função delayMicroseconds() pausa a execução do programa por um intervalo de tempo especificado em microsegundos (μs). Cada milissegundo equivale a 1000 microssegundos e cada segundo equivale a um milhão de microssegundos.

2.1.1. O tipo de dado aceito para o parâmetro tempo é unsigned int. Veja Tipos de dados usados pelo Arduino.

2.1.2. O maior valor (atualmente) para produzir um delay é 16383.

2.1.3. Essa função funciona de forma bastante precisa em temporização a partir de 3μs.

2.2. Sintaxe:

delayMicroseconds(tempo);

2.3. Exemplo:

2.3.1. Exibir no monitor serial o resultado de uma progressão aritmética de razão 2 a cada 10 microssegundos:

int resultado = 0;

void setup() {
  Serial.begin(9600);
}

void loop() {
  delayMicroseconds(10);
  resultado += 2;
  Serial.println(resultado);
}

3. Função millis()

3.1. A função millis() retorna o número em milissegundos decorridos desde que a placa Arduino começou a executar o programa atual, ou seja, desde que foi ligada. Esse número é zerado após aproximadamente 50 dias.

3.1.1. A vantagem de usar essa função é que o programa não é pausado. Desta forma, as demais funções do programa podem ser executadas simultaneamente enquanto a função millis() executa a contagem do tempo.

3.1.2. O tipo de dado aceito para o parâmetro tempo é unsigned long. Veja Tipos de dados usados pelo Arduino.

3.2. Sintaxe:

tempo = millis();

3.2.1. A variável tempo recebe o número de milissegundos (ms) decorridos desde que o Arduino foi ligado. O tipo de dado retornado é unsigned long.

3.3. Exemplo1:

3.3.1. Fazer um Led conectado no pino 13 do Arduino acender após 3 segundos.

const byte ledPin = 13;
unsigned long tempo;

void setup() {
  pinMode(ledPin, OUTPUT);
}

void loop() {
  tempo = millis();
  if (tempo > 3000) { 
    digitalWrite(ledPin, HIGH);
  }
}

3.4. Exemplo2:

3.4.1. Fazer um Led conectado no pino 13 do Arduino piscar, sendo 2 segundos aceso e 1 segundo apagado.

const byte ledPin = 13;
unsigned long anterior = 0;
boolean liga = 0; // led desligado

void setup() {
    pinMode(ledPin, OUTPUT);
}

void loop() {
    unsigned long atual = millis();
    if (atual - anterior > 1000 && liga == 0) {
        digitalWrite(ledPin, HIGH);
        liga = 1;
        anterior = atual;
    }

    if (atual - anterior > 2000 && liga == 1) {
        digitalWrite(ledPin, LOW);
        liga = 0;
        anterior = atual;
    }        
}

4. Função micros()

4.1. A função micros() retorna o número em microssegundos decorridos desde que a placa Arduino começou a executar o programa atual, ou seja, desde que foi ligada. Esse número é zerado após aproximadamente 70 minutos.

4.1.1. A função micros() também não pausa o programa enquanto e executado.

4.1.2. Em placas de Arduino de 16 MHz (como o Arduino Nano), a função possui resolução de 4μs, ou seja, o valor retornado é um múltiplo de 4. Já em placas Arduino de 8 MHz (como o LilyPad), a resolução da função micros() é de 8μs.

4.1.3. O tipo de dado aceito para o parâmetro tempo é unsigned long. Veja Tipos de dados usados pelo Arduino.

4.2. Sintaxe:

tempo = micros();

4.2.1. A variável tempo recebe o número de microssegundos (μs) decorridos desde que o Arduino foi ligado. O tipo de dado retornado é unsigned long.

4.3. Exemplo:

4.3.1. Fazer acender um LED conectado no pino 13 do Arduino acender após 3 segundos (equivale a 3 milhões de microssegundos):

const byte ledPin = 13;
unsigned long tempo;

void setup() {
  pinMode(ledPin, OUTPUT);
}

void loop() {
  tempo = micros();
  if (tempo > 3000000) { 
    digitalWrite(ledPin, HIGH);
  }
}

5. Timer interno do Arduino - Usando a biblioteca TimerOne

5.1. Um timer nada mais é do que um contador que é incrementado a cada intervalo de tempo (em alguns microcontroladores intervalo pode ser configurado, o Arduino é um deles). Os timers funcionam como um relógio que pode ser usado para contar o tempo, medir a duração de certos eventos, entre outras aplicações. A contagem por timer substitui as funções: delay(), millis() e a contagem por controle de" loop for", gerando um intervalo de tempo independente.

5.2. O Arduino vem equipado com um microcontrolador ATmega168 ou ATmega328 (que diferem apenas na quantidade de memória interna). Esses microcontroladores possuem 3 timers: timer0, timer1 and timer2, timer0 e timer2 são contadores de 8bits, ou seja, contam de 0 a 255, e o timer1 é um contador de 16bits, conta de 0 a 65535.

5.3. O Arduino Mega vem equipado com o ATmega1280 ou ATmega2560 (que diferem apenas na quantidade de memória). Eles possuem 6 timers: timer0, timer1, timer2, timer3, timer4, timer5. Os timers 0, 1 e 2 são idênticos aos do ATmega168/328, e os timers 3, 4 e 5 são de 16bits.

5.4 Timers utilizados no Arduino UNO e Mega:

O Timer0 é utilizado pelo Arduino para funções como delay(), millis() e micros(). Então não se deve utilizar esse timer para evitar comprometer essas funções.

O Timer1 no Arduino UNO esse é o timer utilizado pela biblioteca de controle de servos. Caso você não esteja utilizando essa biblioteca, esse timer está livre para ser utilizado para outros propósitos. No Arduino Mega esse timer só será utilizado para controlar os servos se você estiver usando mais de 12 servos. (o timer1 geralmente é o mais utilizado em projetos para contagem de tempo no Arduino UNO ou Mega)

O Timer2 é utilizado pela função tone(). Então se você não precisar da função tone() esse timer está livre para outras aplicações.

Timer3 e Timer4 estão presentes no Arduino Mega e eles só serão utilizados pela biblioteca do Arduino caso vocês esteja utilizando mais de 24 servos. De 25 a 36 servos o timer3 será utilizado e de 37 a 48 servos o timer4 será utilizado.

Timer5 é usado no Arduino Mega como padrão para o controle de servos, ou seja, se você estiver utilizando de 1 a 12 servos, apenas esse timer será utilizado pela biblioteca.

5.5. Para facilitar a utilização do timer interno do Arduino via software, precisaremos instalar a biblioteca TimerOne (download). Após fazer o download dos arquivos das bibliotecas com todos os arquivos compactados no formato zip, abra o IDE do Arduino e siga o tutorial: Como incluir uma biblioteca no IDE do Arduino.

Utilização da biblioteca TimerOne

5.6. Inicialização do timer

Timer1.initialize(microseconds);

5.6.1. Esta função deve ser chamada primeiro. Microssegundos é o período de tempo que o timer conta. Portanto 1.000.000 = 1 segundo.

5.7. Define novo período

Timer1.setPeriod(microseconds);

5.7.1 Esta função definirá, caso deseje, um novo período de tempo para a contagem, após a biblioteca já ter sido inicializada.

5.8. Chama uma função IRS (Interrupt Service Routine)

Timer1.attachInterrupt(function);

5.8.1. Executa uma função sempre que o período do timer terminar. A função é executada como uma interrupção, portanto, é necessário um cuidado especial para compartilhar quaisquer variáveis entre a função de interrupção e seu programa principal. Esta função é uma IRS (Interrupt Service Routine, ou Rotina de Serviço de Interrupções em português) e possui limitações como já mencionamos anteriormente.

5.9. Desativa a interrupção

Timer1.detachInterrupt();

5.9.1. Desativa a interrupção para que a função não seja mais executada.

5.10. Exemplo1:

5.10.1. Fazer um Led conectado no pino 13 do Arduino acender após 3 segundos.

#include  // Inclui a biblioteca TimerOne

const byte ledPin = 13;
unsigned int segundos = 0;

void setup() {
  pinMode(ledPin, OUTPUT);  
  Timer1.initialize(1000000); // define contagem a cada 1 segundo (100000micro = 1s) 
}

void loop() {
  // conta o tempo do cronômetro
  Timer1.attachInterrupt(contadorTempo);
  if (segundos == 3) { 
    digitalWrite(ledPin, HIGH);
  }
}

void contadorTempo() {
  segundos++; 
}

5.11. Exemplo2:

5.11.2. Fazer um Led conectado no pino 13 do Arduino piscar, sendo 2 segundos aceso e 1 segundo apagado.

#include  // Inclui a biblioteca TimerOne

const byte ledPin = 12;
unsigned int segundos = 0;

void setup() {
  Serial.begin(9600);
  pinMode(ledPin, OUTPUT);  
  Timer1.initialize(1000000); // define contagem a cada 1 segundo (100000micro = 1s) 
}

void loop() {
  // conta o tempo do cronômetro
  Timer1.attachInterrupt(contadorTempo);
  if (segundos == 0) digitalWrite(ledPin, HIGH);
  if (segundos == 2) digitalWrite(ledPin, LOW);
  if (segundos == 3) segundos = 0;  
}

void contadorTempo() {
  segundos++; 
}