watchdog.h

Go to the documentation of this file.

//   Copyright 2016-2023 Jean-Francois Poilpret
//
//   Licensed under the Apache License, Version 2.0 (the "License");
//   you may not use this file except in compliance with the License.
//   You may obtain a copy of the License at
//
//       http://www.apache.org/licenses/LICENSE-2.0
//
//   Unless required by applicable law or agreed to in writing, software
//   distributed under the License is distributed on an "AS IS" BASIS,
//   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
//   See the License for the specific language governing permissions and
//   limitations under the License.
 
 
#ifndef WATCHDOG_HH
#define WATCHDOG_HH
 
#include "boards/board.h"
#include "boards/board_traits.h"
#include <avr/interrupt.h>
#include "interrupts.h"
#include "events.h"
 
#define REGISTER_WATCHDOG_CLOCK_ISR(EVENT)              \
    ISR(WDT_vect)                                       \
    {                                                   \
        watchdog::isr_handler::watchdog_clock<EVENT>(); \
    }
 
#define REGISTER_WATCHDOG_RTT_ISR()            \
    ISR(WDT_vect)                              \
    {                                          \
        watchdog::isr_handler::watchdog_rtt(); \
    }
 
#define REGISTER_WATCHDOG_ISR_METHOD(HANDLER, CALLBACK)              \
    ISR(WDT_vect)                                                    \
    {                                                                \
        watchdog::isr_handler::watchdog_method<HANDLER, CALLBACK>(); \
    }
 
#define REGISTER_WATCHDOG_ISR_FUNCTION(CALLBACK)               \
    ISR(WDT_vect)                                              \
    {                                                          \
        watchdog::isr_handler::watchdog_function<CALLBACK>() : \
    }
 
#define REGISTER_WATCHDOG_ISR_EMPTY() EMPTY_INTERRUPT(WDT_vect)
 
#define DECL_WATCHDOG_ISR_HANDLERS_FRIEND \
    friend struct watchdog::isr_handler;  \
    friend void ::WDT_vect();
 
namespace watchdog
{
    enum class TimeOut : uint8_t
    {
        TO_16ms = 0,
        TO_32ms,
        TO_64ms,
        TO_125ms,
        TO_250ms,
        TO_500ms,
        TO_1s,
        TO_2s,
        TO_4s,
        TO_8s
    };
 
    class WatchdogSignal
    {
    public:
        WatchdogSignal() = default;
        WatchdogSignal(const WatchdogSignal&) = delete;
        WatchdogSignal& operator=(const WatchdogSignal&) = delete;
 
        void begin(TimeOut timeout = TimeOut::TO_16ms)
        {
            uint8_t config = bits::BV8(WDIE) | (uint8_t(timeout) & MASK_WDP012) |
                             ((uint8_t(timeout) & MASK_WDP3) ? bits::BV8(WDP3) : 0);
            synchronized begin_with_config(config);
        }
 
        void end()
        {
            synchronized
            {
                WDTCSR_ = bits::BV8(WDCE, WDE);
                WDTCSR_ = 0;
            }
        }
 
    protected:
        void begin_with_config(uint8_t config) INLINE
        {
            __asm__ __volatile__("wdr");
            MCUSR_ |= 1 << WDRF;
            WDTCSR_ = bits::BV8(WDCE, WDE);
            WDTCSR_ = config;
        }
 
        static constexpr const uint8_t MASK_WDP012 = bits::BV8(WDP0, WDP1, WDP2);
        static constexpr const uint8_t MASK_WDP3 = 0x08U;
 
    private:
        using REG8 = board_traits::REG8;
        static constexpr const REG8 MCUSR_{MCUSR};
        static constexpr const REG8 WDTCSR_{WDTCSR};
    };
 
    class WatchdogRTT : public WatchdogSignal
    {
    public:
        WatchdogRTT()
        {
            interrupt::register_handler(*this);
        }
 
        void begin(TimeOut timeout = TimeOut::TO_16ms)
        {
            uint16_t ms_per_tick = bits::BV16(uint8_t(timeout) + 4);
            uint8_t config = bits::BV8(WDIE) | (uint8_t(timeout) & MASK_WDP012) |
                             ((uint8_t(timeout) & MASK_WDP3) ? bits::BV8(WDP3) : 0);
 
            synchronized
            {
                begin_with_config(config);
                millis_per_tick_ = ms_per_tick;
                millis_ = 0;
            }
        }
 
        uint32_t millis() const
        {
            synchronized return millis_;
        }
 
        void reset()
        {
            synchronized millis_ = 0;
        }
 
        void delay(uint32_t ms)
        {
            uint32_t limit = millis() + ms;
            while (millis() < limit)
            {
                time::yield();
            }
        }
 
    protected:
        // This constructor is used by subclass to avoid calling register_handler()
        explicit WatchdogRTT(bool dummy UNUSED) {}
 
        void on_tick()
        {
            millis_ += millis_per_tick_;
        }
 
    private:
        volatile uint32_t millis_ = 0UL;
        uint16_t millis_per_tick_ = 0U;
 
        friend struct isr_handler;
    };
 
    template<typename EVENT> class Watchdog : public WatchdogRTT
    {
        static_assert(events::Event_trait<EVENT>::IS_EVENT, "EVENT type must be an events::Event<T>");
 
    public:
        explicit Watchdog(containers::Queue<EVENT>& event_queue) : WatchdogRTT{true}, event_queue_{event_queue}
        {
            interrupt::register_handler(*this);
        }
 
    private:
        void on_tick()
        {
            WatchdogRTT::on_tick();
            event_queue_.push_(EVENT{events::Type::WDT_TIMER});
        }
 
        containers::Queue<EVENT>& event_queue_;
 
        friend struct isr_handler;
    };
 
    struct isr_handler
    {
        template<typename EVENT> static void watchdog_clock()
        {
            interrupt::HandlerHolder<watchdog::Watchdog<EVENT>>::handler()->on_tick();
        }
 
        static void watchdog_rtt()
        {
            interrupt::HandlerHolder<watchdog::WatchdogRTT>::handler()->on_tick();
        }
 
        template<typename HANDLER, void (HANDLER::*CALLBACK)()> static void watchdog_method()
        {
            interrupt::CallbackHandler<void (HANDLER::*)(), CALLBACK>::call();
        }
 
        template<void (*CALLBACK)()> static void watchdog_function()
        {
            interrupt::CallbackHandler<void (*)(), CALLBACK>::call();
        }
    };
}
 
#endif /* WATCHDOG_HH */