task_timer.h

// ---------------------------------------------
//           This file is part of
//      _  _   __    _   _    __    __
//     ( \/ ) /__\  ( )_( )  /__\  (  )
//      \  / /(__)\  ) _ (  /(__)\  )(__
//      (__)(__)(__)(_) (_)(__)(__)(____)
//
//     Yet Another HW Abstraction Library
//      Copyright (C) Andreas Terstegge
//      BSD Licensed (see file LICENSE)
//
// ---------------------------------------------
//
// A simple timer_interface implementation based on
// the task class. The maximum timer resolution is
// the tick count period - typically 1ms.
//
#ifndef _TASK_TIMER_H_
#define _TASK_TIMER_H_
 
#include "timer_interface.h"
#include "task.h"
#include <cassert>
 
class task_timer : public task, public timer_interface {
public:
    explicit task_timer(const char *name,
                        uint16_t stack_size = DEFAULT_STACK_SIZE)
            : task(name, stack_size) {
 
        _mode     = TIMER::ONE_SHOT;
        _running  = false;
        _delta_ms = 0;
        _next_ms = 0;
 
        _callback = nullptr;
    }
 
    ~task_timer() override = default;
 
    // No copy, no assignment
    task_timer(const task_timer &) = delete;
    task_timer &operator=(const task_timer &) = delete;
 
    void setPeriod(uint32_t us, TIMER::timer_mode mode) override {
        assert((us % 1000) == 0);
        _delta_ms = us / 1000;
        _mode = mode;
    }
 
    uint32_t getPeriod() override {
        return _delta_ms * 1000;
    }
 
    void setCallback(function<void()> f) override {
        _callback = f;
    }
 
    void start() override {
        _running = true;
        reset();
        resume();
        yield();
    }
 
    void stop() override {
        suspend();
        yield();
    }
 
    bool isRunning() override {
        return getState() != state_t::SUSPENDED;
    }
 
    void reset() override {
        _next_ms = task::millis() + _delta_ms;
    }
 
    [[noreturn]] void run() override {
        while (true) {
            if (_running) {
                uint64_t now = task::millis();
                if (now < _next_ms) {
                    uint64_t diff = _next_ms - now;
                    sleep_ms(diff);
                } else {
                    _callback();
                    _next_ms += _delta_ms;
                    if (_mode == TIMER::ONE_SHOT) {
                        _running = false;
                    }
                }
            } else {
                suspend();
                yield();
            }
        }
    }
 
private:
 
    TIMER::timer_mode _mode;
    bool     _running;
    uint64_t _delta_ms;
    uint64_t _next_ms;
 
    function<void()> _callback;
};
 
#endif // _TASK_TIMER_H_