Classe RunTimer

* **SourceForge wiki: RunTimer**

Esta é uma classe bem enxuta, com pouco código que cria um *timer* via software. Foi feita para evitar o uso dos *timers* do arduino, que são recursos bem restritos e um tanto complicados de usar. Sempre que uma aplicação usa um *timer* de hardware, perde os recursos que utilizam aquele *timer*. O arduino Uno por exemplo tem 3 *timers* de hardware: **timer0**, ***timer1*** e **timer2**. O **timer0** é utilizado para funções de marcação de tempo como **delay()**, **millis()** e **micros()**. Portanto o uso do **timer0** em uma aplicação faz com que essas funções deixem de funcionar. O **timer1** é usado pela biblioteca *Servos* para o controle de servos. Finamente o **timer2** é usado pela função **tone()**. Além disso, todos eles estão associados a pinos de *PWM*. O **timer0** controla o *PWM* dos pinos 5 e 6, o **timer1** o dos pinos 9 e 10 e o **timer2** dos pinos 3 e 11.

O resumo da ópera é que se não é necessário uma extrema precisão na marcação de intervalos de tempo, esta classe resolve o problema sem complicações e sem o uso de *timers* de hardware.

Pode ser usada de várias maneiras: monitorando o retorno do método **run()**, indicando uma função externa para executar o código associado ao evento do *timer* ou derivando a classe em uma classe descendente e reescrevendo o método **onTimerEvent()**. Também é possível deixar a instância do **RunTimer** independente da hierarquia de classes e indicar uma instância de uma classe que seja descendente da classe abstrata **TimerOwner**. Abaixo a declaração pública da classe:

```
class TimerOwner{
public:
    virtual void onTimerEvent(){}
};

class RunTimer{
public:
  RunTimer();
  RunTimer(TimerOwner* owner);
  RunTimer(voidFunction externFunction);

  void startMicros(ulong microseconds);
  void startMillis(ulong milliseconds);
  void stop();

  boolean run();
  boolean timerIsOn();

 // Override to capture
 virtual void onTimerEvent(){}
};

```

O uso básico da classe é bastante simples. Declare uma instância da classe e use o método **startMillis()** para informar o intervalo de tempo em milissegundos ou **startMicros()** para informar o tempo em microssegundos e depois monitore o retorno do método **run()** dentro da função **loop()***.* O método **stop()** para a geração de eventos.

```
#include <runTimer.h>

RunTimer tm;

void setup()
{
  ...
  tm.startMillis(500); // 500 milissegundos ou 0,5 segundo
  ...
}

void loop()
{
  ...
  if(tm.run())
  {
     // código que será executado a cada intervalo de tempo
  }
  ...
}

```

Se preferir, pode ser usada uma função externa para capturar o evento do *timer*. Nesse caso é preciso usar o construtor que recebe o ponteiro da função:

```
#include <runTimer.h>

void timerEvent()
{
  // Código a ser executado
}

RunTimer tm(timerEvent);

void setup()
{
  ...
  tm.startMillis(500);
  ...
}

void loop()
{
  ...
  tm.run();
  ...
}

```

Também é possível derivar a classe, criar uma classe descendente e reescrever o evento **onTimerEvent()**. Abaixo um exemplo de como poderia ser feito:

```
#include <runTimer.h>

class MyClass: public RunTimer
{
  public:
    void onTimerEvent()
    {
    // código a executar
    }
};

MyClass mc;

void setup()
{
  ...
  mc.startMillis(500);
  ...
}

void loop()
{
  ...
  mc.run();
  ...
}

```

**Importante:** não deixe de chamar o método **run()** a cada iteração do *loop* principal. Sem isso o *timer* não funciona.