Callback_Watchdog.h

Go to the documentation of this file.

#ifndef Callback_Watchdog_h
#define Callback_Watchdog_h
 
// Local includes.
#include "Callback.h"
 
// Library includes.
#if THINGSBOARD_USE_ESP_TIMER
#include <esp_timer.h>
#else
#include <arduino-timer.h>
#endif // THINGSBOARD_USE_ESP_TIMER
 
 
#if THINGSBOARD_USE_ESP_TIMER
constexpr char WATCHDOG_TIMER_NAME[] = "watchdog_timer";
#endif // THINGSBOARD_USE_ESP_TIMER
 
 
class Callback_Watchdog : public Callback<void> {
  public:
    Callback_Watchdog() = default;
 
    explicit Callback_Watchdog(function callback)
      : Callback(callback)
#if THINGSBOARD_USE_ESP_TIMER
      , m_oneshot_timer(nullptr)
#else
      , m_oneshot_timer()
#endif // THINGSBOARD_USE_ESP_TIMER
    {
        // Nothing to do
    }
 
#if THINGSBOARD_USE_ESP_TIMER
    ~Callback_Watchdog() override {
        // Timer only has to deleted at the end of the lifetime of this object, to ensure no memory leak occurs.
        // But besides that the same timer can simply be stopped and restarted without needing to delete and create the timer again everytime.
        (void)esp_timer_delete(m_oneshot_timer);
        m_oneshot_timer = nullptr;
    }
 
    Callback_Watchdog(Callback_Watchdog const & other)
        : Callback(other)
        , m_oneshot_timer(nullptr)
    {
        // Nothing to do
    }
 
    Callback_Watchdog & operator=(Callback_Watchdog const & other) {
        if (&other != this) {
            Callback::operator=(other);
            detach();
            (void)esp_timer_delete(m_oneshot_timer);
            m_oneshot_timer = nullptr;
        }
        return *this;
    }
#endif // THINGSBOARD_USE_ESP_TIMER
 
    void once(uint64_t const & timeout_microseconds) {
#if THINGSBOARD_USE_ESP_TIMER
        create_timer();
        (void)esp_timer_start_once(m_oneshot_timer, timeout_microseconds);
#else
        m_oneshot_timer.in(timeout_microseconds, &Callback_Watchdog::oneshot_timer_callback, this);
#endif // THINGSBOARD_USE_ESP_TIMER
    }
 
    void detach() {
#if THINGSBOARD_USE_ESP_TIMER
        (void)esp_timer_stop(m_oneshot_timer);
#else
        m_oneshot_timer.cancel();
#endif // THINGSBOARD_USE_ESP_TIMER
    }
 
#if !THINGSBOARD_USE_ESP_TIMER
    void update() {
        m_oneshot_timer.tick<void>();
    }
#endif // !THINGSBOARD_USE_ESP_TIMER
 
  private:
#if THINGSBOARD_USE_ESP_TIMER
    void create_timer() {
        // Timer has already been created previously there is no need to create it again
        if (m_oneshot_timer != nullptr) {
            return;
        }
 
        const esp_timer_create_args_t oneshot_timer_args = {
            .callback = &oneshot_timer_callback,
            .arg = this,
            .dispatch_method = esp_timer_dispatch_t::ESP_TIMER_TASK,
            .name = WATCHDOG_TIMER_NAME,
            .skip_unhandled_events = false
        };
 
        const esp_err_t error = esp_timer_create(&oneshot_timer_args, &m_oneshot_timer);
        if (error != ESP_OK) {
            return;
        }
    }
#endif // THINGSBOARD_USE_ESP_TIMER
 
#if THINGSBOARD_USE_ESP_TIMER
    static void
#else
    static  bool
#endif // THINGSBOARD_USE_ESP_TIMER
    oneshot_timer_callback(void *arg) {
        if (arg == nullptr) {
#if THINGSBOARD_USE_ESP_TIMER
            return;
#else
            return false;
#endif // THINGSBOARD_USE_ESP_TIMER
        }
 
        auto instance = static_cast<Callback_Watchdog *>(arg);
        instance->Call_Callback();
#if !THINGSBOARD_USE_ESP_TIMER
        return false;
#endif // !THINGSBOARD_USE_ESP_TIMER
    }
 
#if THINGSBOARD_USE_ESP_TIMER
    esp_timer_handle_t m_oneshot_timer = {}; // ESP Timer handle that is used to start and stop the oneshot timer
#else
    Timer<1, micros>   m_oneshot_timer = {}; // Ticker instance that handles the timer under the hood, if possible we directly use esp timer instead because it is more efficient
#endif // THINGSBOARD_USE_ESP_TIMER
};
 
#endif // Argument_Cache_h