multi_timer.hpp

Go to the documentation of this file.

 
#ifndef MULTI_TIMER_HPP__
#define MULTI_TIMER_HPP__
 
//#include <functional> // Has std::invoke but is only available from C++17..
//#include <type_traits> // C++20 version has the std::type_identity_t built in
#include "freertos/semphr.h"
#include <Ticker.h>
 
// Allows calling a ordinary (non-static) class member function by inserting a
// lambda function taking the instance pointer as an argument..
// .. which because of creating a bound function should even perform better
// than indirecting a member function pointer call?
#define TICKER_MEMBER_CALL(NON_STATIC_MEMBER_FN) \
    [](decltype(this) self){self->NON_STATIC_MEMBER_FN();}, this
#define TICKER_MEMBER_CALL_WITH_COUNT(NON_STATIC_MEMBER_FN) \
    [](decltype(this) self, uint32_t i){self->NON_STATIC_MEMBER_FN(i);}, this
 
class MultiTimer : private Ticker
{
public:
    // std::type_identity_t is part of C++20 but current toolchain uses C++11.
    // The following block is backporting the feature and will be obsolete soon.
    // When this is the case, include <type_traits> and use std::type_indentity_t
    template<typename T>
    struct type_identity {using type = T;};
    template<class T>
    using type_identity_t = typename type_identity<T>::type;
 
    using callback_with_arg_and_count_t = void (*)(void*, uint32_t);
 
    MultiTimer() {
        // When starting the timer with first_tick_nodelay=true, the first
        // invocation of the timer callback is from the application task.
        // Because any successive call is made from the high-priority esp_timer
        // task, we need a mutex to prevent the timer task to proceed before
        // the very first callback invocation has finished...
        _reentry_mutex = xSemaphoreCreateMutex();
        assert(_reentry_mutex);
    }
 
 
    template <typename TArg>
    esp_err_t attach_static_ms(uint32_t milliseconds,
                               uint32_t total_repeat_count,
                               void (*callback)(type_identity_t<TArg>, uint32_t),
                               TArg arg,
                               bool first_tick_nodelay=false) {
        static_assert(sizeof(TArg) <= sizeof(uint32_t),
                      "attach_ms() callback argument size must be <= 4 bytes");
        _interval_ms = milliseconds;
        _repeat_count_requested = total_repeat_count;
        _callback = reinterpret_cast<callback_t>(callback);
        _orig_arg = (uint32_t)arg;
        _first_tick_nodelay = first_tick_nodelay;
        _cb_lambda = [](void *_this){
            auto self = static_cast<decltype(this)>(_this);
            self->_mutex_take();
            auto repeat_count = ++self->_repeat_count;
            if (repeat_count < self->_repeat_count_requested) {
                esp_timer_start_once(self->_timer, self->_interval_ms*1000ull);
            } else {
                self->_repeat_count = 0;
            }
            auto cb = reinterpret_cast<callback_with_arg_and_count_t>(self->_callback);
            auto arg = (TArg)(self->_orig_arg);
            cb(arg, repeat_count);
            self->_mutex_give();
            };
        return _attach_ms((uint32_t)this);
    }
 
    template <typename TArg>
    esp_err_t attach_static_ms(uint32_t milliseconds,
                               uint32_t total_repeat_count,
                               void (*callback)(type_identity_t<TArg>),
                               TArg arg,
                               bool first_tick_nodelay=false) {
        static_assert(sizeof(TArg) <= sizeof(uint32_t),
                      "attach_ms() callback argument size must be <= 4 bytes");
        _interval_ms = milliseconds;
        _repeat_count_requested = total_repeat_count;
        _callback = reinterpret_cast<callback_t>(callback);
        _orig_arg = (uint32_t)arg;
        _first_tick_nodelay = first_tick_nodelay;
        _cb_lambda = [](void *_this){
            auto self = static_cast<decltype(this)>(_this);
            self->_mutex_take();
            auto repeat_count = ++self->_repeat_count;
            if (repeat_count < self->_repeat_count_requested) {
                esp_timer_start_once(self->_timer, self->_interval_ms*1000ull);
            } else {
                self->_repeat_count = 0;
            }
            auto cb = reinterpret_cast<callback_with_arg_t>(self->_callback);
            auto arg = (TArg)(self->_orig_arg);
            cb(arg);
            self->_mutex_give();
            };
        return _attach_ms((uint32_t)this);
    }
 
    esp_err_t attach_static_ms(uint32_t milliseconds,
                               uint32_t total_repeat_count,
                               callback_t callback,
                               bool first_tick_nodelay=false) {
        _interval_ms = milliseconds;
        _repeat_count_requested = total_repeat_count;
        _callback = reinterpret_cast<callback_t>(callback);
        _first_tick_nodelay = first_tick_nodelay;
        _cb_lambda = [](void *_this){
            auto self = static_cast<decltype(this)>(_this);
            self->_mutex_take();
            auto repeat_count = ++self->_repeat_count;
            if (repeat_count < self->_repeat_count_requested) {
                esp_timer_start_once(self->_timer, self->_interval_ms*1000ull);
            } else {
                self->_repeat_count = 0;
            }
            self->_callback();
            self->_mutex_give();
            };
        return _attach_ms((uint32_t)this);
    }
 
    void start() {
        if (_first_tick_nodelay && _cb_lambda) {
            _cb_lambda(this);
        } else {
            esp_timer_start_once(_timer, _interval_ms*1000ull);
        }
    }
    void start(uint32_t interval_ms) {
        _interval_ms = interval_ms;
        if (_first_tick_nodelay && _cb_lambda) {
            _cb_lambda(this);
        } else {
            esp_timer_start_once(_timer, _interval_ms*1000ull);
        }
    }
 
    void stop() {
        esp_timer_stop(_timer);
        _repeat_count = 0;
    }
    esp_err_t stop_return_errors() {
        auto errors = esp_timer_stop(_timer);
        _repeat_count = 0;
        return errors;
    }
 
    void pause() {
        esp_timer_stop(_timer);
    }
    esp_err_t pause_return_errors() {
        return esp_timer_stop(_timer);
    }
 
    void resume() {
        esp_timer_start_once(_timer, _interval_ms*1000ull);
    }
    esp_err_t resume_return_errors() {
        return esp_timer_start_once(_timer, _interval_ms*1000ull);
    }
 
    // The only other functions we make available again in this class
    using Ticker::detach;
    using Ticker::active;
 
protected:
    using Ticker::_timer;
    uint32_t _interval_ms;
    uint32_t _repeat_count_requested{1};
    uint32_t _repeat_count{0};
    // Original callback cast into a callback_t
    callback_t _callback;
    uint32_t _orig_arg{0};
    // Callback encapsulated into lambda function with repeat counter etc.
    callback_with_arg_t _cb_lambda{nullptr};
    bool _first_tick_nodelay{false};
    SemaphoreHandle_t _reentry_mutex = NULL;
 
    esp_err_t _attach_ms(uint32_t arg) {
        esp_timer_create_args_t _timerConfig;
        _timerConfig.callback = _cb_lambda;
        _timerConfig.arg = reinterpret_cast<void*>(arg);
        _timerConfig.dispatch_method = ESP_TIMER_TASK;
        _timerConfig.name = "MultiTimer";
        if (_timer) {
            esp_timer_stop(_timer);
            esp_timer_delete(_timer);
        }
        return esp_timer_create(&_timerConfig, &_timer);
    }
 
    inline void _mutex_take() {
        xSemaphoreTake(_reentry_mutex, portMAX_DELAY);
    }
 
    inline void _mutex_give() {
        xSemaphoreGive(_reentry_mutex);
    }
};
 
 
template<typename TClass>
class MultiTimerNonStatic : public MultiTimer
{
public:
    using mem_func_ptr_t = void (TClass::*)();
    using mem_func_ptr_with_count_t = void (TClass::*)(uint32_t);
 
    esp_err_t attach_mem_func_ptr_ms(uint32_t milliseconds,
                                     uint32_t total_repeat_count,
                                     mem_func_ptr_t mem_func_ptr,
                                     TClass *inst,
                                     bool first_tick_nodelay=false) {
        _interval_ms = milliseconds;
        _repeat_count_requested = total_repeat_count;
        _mem_func_ptr = mem_func_ptr;
        _orig_arg = reinterpret_cast<uint32_t>(inst);
        _first_tick_nodelay = first_tick_nodelay;
        _cb_lambda = [](void *_this){
            auto self = static_cast<decltype(this)>(_this);
            self->_mutex_take();
            auto repeat_count = ++self->_repeat_count;
            if (repeat_count < self->_repeat_count_requested) {
                esp_timer_start_once(self->_timer, self->_interval_ms*1000ull);
            } else {
                self->_repeat_count = 0;
            }
            auto inst = reinterpret_cast<TClass*>(self->_orig_arg);
            //std::invoke(self->_mem_func_ptr, *inst);
            auto mfp = self->_mem_func_ptr;
            (inst->*mfp)();
            self->_mutex_give();
            };
        return _attach_ms((uint32_t)this);
    }
 
    esp_err_t attach_mem_func_ptr_ms(uint32_t milliseconds,
                                     uint32_t total_repeat_count,
                                     mem_func_ptr_with_count_t mem_func_ptr,
                                     TClass *inst,
                                     bool first_tick_nodelay=false) {                   
        _interval_ms = milliseconds;
        _repeat_count_requested = total_repeat_count;
        _mem_func_ptr = reinterpret_cast<mem_func_ptr_t>(mem_func_ptr);
        //_mem_func_ptr_with_count = mem_func_ptr;
        _orig_arg = reinterpret_cast<uint32_t>(inst);
        _first_tick_nodelay = first_tick_nodelay;
        _cb_lambda = [](void *_this){
            auto self = static_cast<decltype(this)>(_this);
            self->_mutex_take();
            auto repeat_count = ++self->_repeat_count;
            if (repeat_count < self->_repeat_count_requested) {
                esp_timer_start_once(self->_timer, self->_interval_ms*1000ull);
            } else {
                self->_repeat_count = 0;
            }
            auto inst = reinterpret_cast<TClass*>(self->_orig_arg);
            //std::invoke(self->_mem_func_ptr, *inst, self->_repeat_count);
            auto mfp = reinterpret_cast<mem_func_ptr_with_count_t>(self->_mem_func_ptr);
            //auto mfp = self->_mem_func_ptr_with_count;
            (inst->*mfp)(repeat_count);
            self->_mutex_give();
            };
        return _attach_ms((uint32_t)this);
    }
 
protected:
    mem_func_ptr_t _mem_func_ptr;
    //mem_func_ptr_with_count_t _mem_func_ptr_with_count;
};
 
 
#endif