metro.h

Go to the documentation of this file.

#pragma once
 
#include "Arduino.h"
#include <inttypes.h>
 
class Metro
{
 
public:
    Metro(unsigned long interval_millis, uint8_t autoreset = 0);
 
    void interval(unsigned long interval_millis);
 
    bool check();
 
    bool checkWithoutReset() const;
 
    void reset();
 
private:
    uint8_t autoreset;             
    unsigned long previous_millis; 
    unsigned long interval_millis; 
};
 
inline Metro::Metro(unsigned long interval_millis, uint8_t autoreset)
{
    this->autoreset = autoreset; // Fix by Paul Bouchier
    interval(interval_millis);
    reset();
}
 
inline void Metro::interval(unsigned long interval_millis)
{
    this->interval_millis = interval_millis;
}
 
// Benjamin.soelberg's check behavior:
// When a check is true, add the interval to the internal counter.
// This should guarantee a better overall stability.
 
// Original check behavior:
// When a check is true, add the interval to the current millis() counter.
// This method can add a certain offset over time.
 
inline bool Metro::check()
{
    if (millis() - this->previous_millis >= this->interval_millis)
    {
        // As suggested by benjamin.soelberg@gmail.com, the following line
        // this->previous_millis = millis();
        // was changed to
        // this->previous_millis += this->interval_millis;
 
        // If the interval is set to 0 we revert to the original behavior
        if (this->interval_millis <= 0 || this->autoreset)
        {
            this->previous_millis = millis();
        }
        else
        {
            this->previous_millis += this->interval_millis;
        }
 
        return 1;
    }
 
    return 0;
}
 
inline bool Metro::checkWithoutReset() const
{
    if (millis() - this->previous_millis >= this->interval_millis)
    {
        return 1;
    }
    return 0;
}
 
void Metro::reset()
{
 
    this->previous_millis = millis();
}
 
class VolatileMetro
{
public:
    VolatileMetro(unsigned long interval_millis, uint8_t autoreset = 0);
 
    void interval(unsigned long interval_millis) volatile;
 
    bool check() volatile;
 
    bool checkWithoutReset() const volatile;
 
    void reset() volatile;
 
private:
    volatile uint8_t autoreset;             
    volatile unsigned long previous_millis; 
    volatile unsigned long interval_millis; 
};
 
inline VolatileMetro::VolatileMetro(unsigned long interval_millis, uint8_t autoreset)
{
    this->autoreset = autoreset;
    interval(interval_millis);
    reset();
}
 
inline void VolatileMetro::interval(unsigned long interval_millis) volatile
{
    this->interval_millis = interval_millis;
}
 
inline bool VolatileMetro::check() volatile
{
    if (millis() - this->previous_millis >= this->interval_millis)
    {
        if (this->interval_millis <= 0 || this->autoreset)
        {
            this->previous_millis = millis();
        }
        else
        {
            this->previous_millis += this->interval_millis;
        }
        return 1;
    }
    return 0;
}
 
inline bool VolatileMetro::checkWithoutReset() const volatile
{
    if (millis() - this->previous_millis >= this->interval_millis)
    {
        return 1;
    }
    return 0;
}
 
inline void VolatileMetro::reset() volatile
{
    this->previous_millis = millis();
}