Timer.h

Go to the documentation of this file.

/****
 * Sming Framework Project - Open Source framework for high efficiency native ESP8266 development.
 * Created 2015 by Skurydin Alexey
 * http://github.com/SmingHub/Sming
 * All files of the Sming Core are provided under the LGPL v3 license.
 *
 * Timer.h
 *
 ****/
 
#pragma once
 
#include "Interrupts.h"
#include "SimpleTimer.h"
 
template <class TimerClass> class OsTimer64Api : public CallbackTimerApi<OsTimer64Api<TimerClass>>
{
public:
    using Clock = OsTimerApi::Clock;
    using TickType = uint64_t;
    using TimeType = uint64_t;
 
    static constexpr const char* typeName()
    {
        return "OsTimer64Api";
    }
 
    static constexpr TickType minTicks()
    {
        return 1;
    }
 
    static constexpr TickType maxTicks()
    {
        return Clock::maxTicks() * 0xFFFF;
    }
 
    OsTimer64Api()
    {
#ifndef ARCH_ESP32
        initCallback();
#endif
    }
 
    ~OsTimer64Api()
    {
        disarm();
    }
 
    __forceinline bool IRAM_ATTR isArmed() const
    {
        return osTimer.isArmed();
    }
 
    TickType ticks() const
    {
        TickType remain = osTimer.ticks();
        if(longIntervalCounterLimit != 0) {
            remain += TickType(longIntervalCounterLimit - longIntervalCounter) * osTimer.getInterval();
        }
        return remain;
    }
 
    __forceinline void IRAM_ATTR setCallback(TimerCallback callback, void* arg)
    {
        this->callback.func = callback;
        this->callback.arg = arg;
    }
 
    __forceinline void setCallback(TimerDelegate delegateFunction)
    {
        delegate = delegateFunction;
        this->callback.func = nullptr;
    }
 
    void IRAM_ATTR setInterval(TickType interval);
 
    TickType IRAM_ATTR getInterval() const
    {
        TickType interval = osTimer.getInterval();
        if(longIntervalCounterLimit != 0) {
            interval *= longIntervalCounterLimit;
        }
        return interval;
    }
 
    __forceinline void IRAM_ATTR arm(bool repeating)
    {
#ifdef ARCH_ESP32
        initCallback();
#endif
        this->repeating = repeating;
        osTimer.arm(longIntervalCounterLimit || repeating);
    }
 
    __forceinline void IRAM_ATTR disarm()
    {
        osTimer.disarm();
        longIntervalCounter = 0;
    }
 
protected:
    void longTick();
 
private:
    OsTimerApi osTimer;
    struct {
        TimerCallback func = nullptr;
        void* arg = nullptr;
    } callback;
    TimerDelegate delegate; 
    bool repeating = false;
    // Because of the limitation in Espressif SDK a workaround
    // was added to allow for longer timer intervals.
    uint16_t longIntervalCounter = 0;
    uint16_t longIntervalCounterLimit = 0;
 
    void initCallback()
    {
        osTimer.setCallback(
            [](void* arg) {
                auto self = static_cast<OsTimer64Api*>(arg);
                self->longTick();
            },
            this);
    }
};
 
template <class TimerClass> void OsTimer64Api<TimerClass>::setInterval(TickType interval)
{
    constexpr auto maxTicks = OsTimerApi::maxTicks();
    if(interval > maxTicks) {
        // interval too large, calculate a good divider
        uint32_t div = (interval / (maxTicks + 1)) + 1; // integer division, intended
 
        // We will lose some precision here but its so small it won't matter.
        // Error will be microseconds mod div which can at most be div-1.
        // For small intervals (and thus small values of div) we are talking a few us.
 
        interval /= div;
        longIntervalCounterLimit = div;
    } else {
        longIntervalCounterLimit = 0;
    }
    longIntervalCounter = 0;
    osTimer.setInterval(interval);
}
 
template <class TimerClass> void OsTimer64Api<TimerClass>::longTick()
{
    if(longIntervalCounterLimit != 0) {
        longIntervalCounter++;
 
        if(longIntervalCounter < longIntervalCounterLimit) {
            return;
        }
 
        // For long intervals os_timer is set to repeating.
        // Stop timer if it was not a repeating timer.
        if(repeating) {
            longIntervalCounter = 0;
        } else {
            osTimer.disarm();
        }
    }
 
    if(callback.func != nullptr) {
        callback.func(callback.arg);
    } else if(delegate) {
        delegate();
    }
 
    static_cast<TimerClass*>(this)->expired();
}
 
template <typename TimerApi> class DelegateCallbackTimer : public CallbackTimer<TimerApi>
{
public:
    using typename TimerApi::TickType;
    using typename TimerApi::TimeType;
    using CallbackTimer<TimerApi>::initializeUs;
    using CallbackTimer<TimerApi>::initializeMs;
    using CallbackTimer<TimerApi>::setCallback;
 
    template <TimeType microseconds> DelegateCallbackTimer& IRAM_ATTR initializeUs(TimerDelegate delegateFunction)
    {
        setCallback(delegateFunction);
        this->template setIntervalUs<microseconds>();
        return *this;
    }
 
    template <uint32_t milliseconds> DelegateCallbackTimer& IRAM_ATTR initializeMs(TimerDelegate delegateFunction)
    {
        setCallback(delegateFunction);
        this->template setIntervalMs<milliseconds>();
        return *this;
    }
 
    DelegateCallbackTimer& initializeMs(uint32_t milliseconds, TimerDelegate delegateFunction)
    {
        setCallback(delegateFunction);
        this->setIntervalMs(milliseconds);
        return *this;
    }
 
    DelegateCallbackTimer& initializeUs(uint32_t microseconds, TimerDelegate delegateFunction)
    {
        setCallback(delegateFunction);
        this->setIntervalUs(microseconds);
        return *this;
    }
 
    void setCallback(TimerDelegate delegateFunction)
    {
        // Always disarm before setting the callback
        this->stop();
        TimerApi::setCallback(delegateFunction);
        this->callbackSet = bool(delegateFunction);
    }
};
 
class Timer : public DelegateCallbackTimer<OsTimer64Api<Timer>>
{
protected:
    friend OsTimer64Api<Timer>;
 
    void expired()
    {
    }
};
 
class AutoDeleteTimer : public DelegateCallbackTimer<OsTimer64Api<AutoDeleteTimer>>
{
protected:
    friend OsTimer64Api<AutoDeleteTimer>;
 
    // Ensures object may only be created on the heap
    ~AutoDeleteTimer() = default;
 
    void expired()
    {
        delete this;
    }
};