CallbackTimer.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.
 *
 * CallbackTimer.h - Template classes to implement callback timers
 *
 ****/

#pragma once

#include "Interrupts.h"
#include "NanoTime.h"

typedef void (*TimerCallback)(void* arg); 
using TimerDelegate = Delegate<void()>;   

template <typename ApiDef> struct CallbackTimerApi {
    static constexpr const char* typeName()
    {
        return ApiDef::typeName();
    }

    String name() const
    {
        String s;
        s += typeName();
        s += '@';
        s += String(uint32_t(this), HEX);
        return s;
    }

    String toString() const
    {
        String s;
        s += name();
        s += ": interval = ";
        s += static_cast<const ApiDef*>(this)->getInterval();
        s += ", ticks = ";
        s += static_cast<const ApiDef*>(this)->ticks();
        //      s += ApiDef::Clock::ticks();
        return s;
    }

    operator String() const
    {
        return toString();
    }
};

template <typename TimerApi> class CallbackTimer : protected TimerApi
{
public:
    using typename TimerApi::Clock;
    using typename TimerApi::TickType;
    using typename TimerApi::TimeType;
    using Millis = NanoTime::TimeSource<Clock, NanoTime::Milliseconds, uint32_t>;
    using Micros = NanoTime::TimeSource<Clock, NanoTime::Microseconds, TimeType>;

    using TimerApi::maxTicks;
    using TimerApi::minTicks;
    using TimerApi::toString;
    using TimerApi::typeName;
    using TimerApi::operator String;

    static constexpr Millis millis()
    {
        return Millis();
    }

    static constexpr Micros micros()
    {
        return Micros();
    }

    template <uint64_t us> static constexpr uint64_t usToTicks()
    {
        return Micros::template timeToTicks<us>();
    }

    static TickType usToTicks(TimeType time)
    {
        return Micros::timeToTicks(time);
    }

    template <uint64_t ticks> static constexpr uint64_t ticksToUs()
    {
        return Micros::template ticksToTime<ticks>();
    }

    static TimeType ticksToUs(TickType ticks)
    {
        return Micros::ticksToTime(ticks);
    }

    template <NanoTime::Unit unit, TimeType time>
    CallbackTimer& IRAM_ATTR initialize(TimerCallback callback, void* arg = nullptr)
    {
        setCallback(callback, arg);
        setInterval<unit, time>();
        return *this;
    }

    template <NanoTime::Unit unit>
    CallbackTimer& IRAM_ATTR initialize(TimeType time, TimerCallback callback, void* arg = nullptr)
    {
        setCallback(callback, arg);
        setInterval<unit>(time);
        return *this;
    }

    template <TimeType microseconds>
    __forceinline CallbackTimer& IRAM_ATTR initializeUs(TimerCallback callback, void* arg = nullptr)
    {
        return initialize<NanoTime::Microseconds, microseconds>(callback, arg);
    }

    template <TimeType microseconds>
    __forceinline CallbackTimer& IRAM_ATTR initializeUs(InterruptCallback callback = nullptr)
    {
        return initializeUs<microseconds>(TimerCallback(callback));
    }

    __forceinline CallbackTimer& IRAM_ATTR initializeUs(TimeType microseconds, TimerCallback callback,
                                                        void* arg = nullptr)
    {
        return initialize<NanoTime::Microseconds>(microseconds, callback, arg);
    }

    __forceinline CallbackTimer& IRAM_ATTR initializeUs(TimeType microseconds, InterruptCallback callback = nullptr)
    {
        return initializeUs(microseconds, TimerCallback(callback));
    }

    template <uint32_t milliseconds>
    __forceinline CallbackTimer& IRAM_ATTR initializeMs(TimerCallback callback, void* arg = nullptr)
    {
        return initialize<NanoTime::Milliseconds, milliseconds>(callback, arg);
    }

    template <uint32_t milliseconds>
    __forceinline CallbackTimer& IRAM_ATTR initializeMs(InterruptCallback callback = nullptr)
    {
        return initializeMs<milliseconds>(TimerCallback(callback));
    }

    __forceinline CallbackTimer& IRAM_ATTR initializeMs(uint32_t milliseconds, TimerCallback callback,
                                                        void* arg = nullptr)
    {
        return initialize<NanoTime::Milliseconds>(milliseconds, callback, arg);
    }

    __forceinline CallbackTimer& IRAM_ATTR initializeMs(uint32_t milliseconds, InterruptCallback callback = nullptr)
    {
        return initializeMs(milliseconds, TimerCallback(callback));
    }

    IRAM_ATTR bool start(bool repeating = true);

    __forceinline bool IRAM_ATTR startOnce()
    {
        return start(false);
    }

    __forceinline void IRAM_ATTR stop()
    {
        if(started) {
            TimerApi::disarm();
            started = false;
        }
    }

    __forceinline bool IRAM_ATTR restart()
    {
        return start(repeating);
    }

    __forceinline bool isStarted() const
    {
        return started;
    }

    NanoTime::Time<TimeType> getIntervalUs() const
    {
        return Micros::ticksToTime(getInterval());
    }

    NanoTime::Time<uint32_t> getIntervalMs() const
    {
        return Millis::ticksToTime(getInterval());
    }

    __forceinline TickType getInterval() const
    {
        return TimerApi::getInterval();
    }

    bool IRAM_ATTR checkInterval(TickType ticks) const
    {
        return ticks >= minTicks() && ticks <= maxTicks();
    }

    template <uint64_t ticks> static constexpr void checkInterval()
    {
        static_assert(ticks >= minTicks() && ticks <= maxTicks(), "Timer interval out of range");
    }

    template <NanoTime::Unit unit, uint64_t time> static constexpr void checkInterval()
    {
        checkInterval<Clock::template TimeConst<unit, time>::ticks()>();
    }

    template <uint64_t milliseconds> static constexpr void checkIntervalMs()
    {
        checkInterval<NanoTime::Milliseconds, milliseconds>();
    }

    template <uint64_t microseconds> static constexpr void checkIntervalUs()
    {
        checkInterval<NanoTime::Microseconds, microseconds>();
    }

    __forceinline bool IRAM_ATTR setInterval(TickType ticks)
    {
        if(checkInterval(ticks)) {
            internalSetInterval(ticks);
        } else {
            stop();
            intervalSet = false;
        }
        return started;
    }

    template <TimeType ticks> __forceinline void IRAM_ATTR setInterval()
    {
        checkInterval<ticks>();
        internalSetInterval(ticks);
    }

    template <NanoTime::Unit unit, TimeType time> __forceinline void IRAM_ATTR setInterval()
    {
        setInterval<Clock::template TimeConst<unit, time>::ticks()>();
    }

    template <NanoTime::Unit unit> __forceinline bool IRAM_ATTR setInterval(TimeType time)
    {
        return setInterval(Clock::template timeToTicks<unit>(time));
    }

    __forceinline bool IRAM_ATTR setIntervalUs(TimeType microseconds)
    {
        return setInterval<NanoTime::Microseconds>(microseconds);
    }

    template <TimeType microseconds> __forceinline void IRAM_ATTR setIntervalUs()
    {
        return setInterval<NanoTime::Microseconds, microseconds>();
    }

    __forceinline bool IRAM_ATTR setIntervalMs(uint32_t milliseconds)
    {
        return setInterval<NanoTime::Milliseconds>(milliseconds);
    }

    template <uint32_t milliseconds> __forceinline void IRAM_ATTR setIntervalMs()
    {
        return setInterval<NanoTime::Milliseconds, milliseconds>();
    }

    __forceinline void IRAM_ATTR setCallback(TimerCallback callback, void* arg = nullptr)
    {
        // Always disarm before setting the callback
        stop();
        TimerApi::setCallback(callback, arg);
        callbackSet = (callback != nullptr);
    }

    __forceinline void IRAM_ATTR setCallback(InterruptCallback callback)
    {
        setCallback(reinterpret_cast<TimerCallback>(callback), nullptr);
    }

private:
    __forceinline void IRAM_ATTR internalSetInterval(TickType ticks)
    {
        TimerApi::disarm();
        TimerApi::setInterval(ticks);
        intervalSet = true;
        if(started) {
            TimerApi::arm(repeating);
        }
    }

protected:
    bool callbackSet = false; 
    bool intervalSet = false; 
    bool repeating = false;   
    bool started = false;    
};

template <typename TimerApi> IRAM_ATTR bool CallbackTimer<TimerApi>::start(bool repeating)
{
    stop();
    if(!callbackSet || !intervalSet) {
        return false;
    }

    TimerApi::arm(repeating);
    started = true;
    this->repeating = repeating;
    return true;
}