realtime_timer.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 RTT_HH
#define RTT_HH
 
#include "boards/io.h"
#include <avr/interrupt.h>
#include "interrupts.h"
#include "timer.h"
#include "time.h"
#include "events.h"
 
#define REGISTER_RTT_ISR(TIMER_NUM)               \
    ISR(CAT3(TIMER, TIMER_NUM, _COMPA_vect))      \
    {                                             \
        timer::isr_handler_rtt::rtt<TIMER_NUM>(); \
    }
 
#define REGISTER_RTT_ISR_METHOD(TIMER_NUM, HANDLER, CALLBACK)               \
    ISR(CAT3(TIMER, TIMER_NUM, _COMPA_vect))                                \
    {                                                                       \
        timer::isr_handler_rtt::rtt_method<TIMER_NUM, HANDLER, CALLBACK>(); \
    }
 
#define REGISTER_RTT_ISR_FUNCTION(TIMER_NUM, CALLBACK)               \
    ISR(CAT3(TIMER, TIMER_NUM, _COMPA_vect))                         \
    {                                                                \
        timer::isr_handler_rtt::rtt_function<TIMER_NUM, CALLBACK>(); \
    }
 
#define REGISTER_RTT_EVENT_ISR(TIMER_NUM, EVENT, PERIOD)               \
    ISR(CAT3(TIMER, TIMER_NUM, _COMPA_vect))                           \
    {                                                                  \
        timer::isr_handler_rtt::rtt_event<TIMER_NUM, EVENT, PERIOD>(); \
    }
 
#define DECL_RTT_ISR_HANDLERS_FRIEND      \
    friend struct timer::isr_handler_rtt; \
    DECL_TIMER_COMP_FRIENDS
 
namespace timer
{
    template<typename T> class RTTRawTime
    {
    public:
        RTTRawTime(const RTTRawTime&) = default;
        RTTRawTime& operator=(const RTTRawTime&) = default;
 
        RTTRawTime(uint32_t millis, T counter, T max_counter)
            : millis_{millis}, counter_{counter}, max_counter_{max_counter}
        {}
 
        static constexpr RTTRawTime<T> EMPTY_TIME{};
 
        time::RTTTime as_real_time() const
        {
            return time::RTTTime{millis_, uint16_t(ONE_MILLI_32 * counter_ / (1UL + max_counter_))};
        }
 
    private:
        constexpr RTTRawTime() : buffer_{} {}
 
        // This union is an ugly hack to trick the compiler so that it understands
        // the default constructor just needs 0 initialization for EMPTY_TIME constant,
        // and thus can accept the fact EMPTY_TIME is a pure constexpr
        union
        {
            struct
            {
                uint32_t millis_;
                T counter_;
                T max_counter_;
            };
            uint8_t buffer_[sizeof(uint32_t) + 2 * sizeof(T)];
        };
    };
 
    template<board::Timer NTIMER_> class RTT : private Timer<NTIMER_>
    {
    public:
        static constexpr const board::Timer NTIMER = NTIMER_;
 
    private:
        using TRAIT = typename Timer<NTIMER>::TRAIT;
        using TYPE = typename Timer<NTIMER>::TYPE;
        using PRESCALER = typename Timer<NTIMER>::PRESCALER;
 
    public:
        using RAW_TIME = RTTRawTime<TYPE>;
 
        RTT() : Timer<NTIMER>{TimerMode::CTC, MILLI_PRESCALER, TimerInterrupt::OUTPUT_COMPARE_A}
        {
            interrupt::register_handler(*this);
        }
 
        uint32_t millis() const
        {
            synchronized return milliseconds_;
        }
 
        uint32_t millis_() const
        {
            return milliseconds_;
        }
 
        void delay(uint32_t ms) const
        {
            uint32_t end = millis() + ms + 1;
            while (millis() < end) time::yield();
        }
 
        uint16_t micros() const
        {
            synchronized return compute_micros();
        }
 
        uint16_t micros_() const
        {
            return compute_micros();
        }
 
        time::RTTTime time() const
        {
            synchronized return time_();
        }
 
        time::RTTTime time_() const
        {
            return time::RTTTime(milliseconds_, compute_micros());
        }
 
        RAW_TIME raw_time() const
        {
            synchronized return raw_time_();
        }
 
        RAW_TIME raw_time_() const
        {
            return RAW_TIME{milliseconds_, (volatile TYPE&) TRAIT::TCNT, (volatile TYPE&) TRAIT::OCRA};
        }
 
        void millis(uint32_t ms)
        {
            synchronized
            {
                milliseconds_ = ms;
                // Reset timer counter
                TRAIT::TCNT = 0;
            }
        }
 
        void begin()
        {
            synchronized begin_();
        }
 
        void begin_()
        {
            milliseconds_ = 0;
            Timer<NTIMER>::begin_(MILLI_COUNTER);
        }
 
        void end()
        {
            Timer<NTIMER>::end();
        }
 
        void end_()
        {
            Timer<NTIMER>::end_();
        }
 
        Timer<NTIMER>& timer()
        {
            return *this;
        }
 
    private:
        volatile uint32_t milliseconds_ = 0UL;
 
        void on_timer()
        {
            ++milliseconds_;
        }
 
        using CALC = Calculator<NTIMER>;
        static constexpr const PRESCALER MILLI_PRESCALER = CALC::CTC_prescaler(ONE_MILLI_32);
        static constexpr const TYPE MILLI_COUNTER = CALC::CTC_counter(MILLI_PRESCALER, ONE_MILLI_32);
 
        uint16_t compute_micros() const
        {
            return uint16_t(ONE_MILLI_32 * ((volatile TYPE&) TRAIT::TCNT) / (1UL + (volatile TYPE&) TRAIT::OCRA));
        }
 
        friend struct isr_handler_rtt;
    };
 
    template<typename EVENT, uint32_t PERIOD_MS = 1024> class RTTEventCallback
    {
        static_assert(events::Event_trait<EVENT>::IS_EVENT, "EVENT type must be an events::Event<T>");
        static_assert((PERIOD_MS & (PERIOD_MS - 1)) == 0, "PERIOD_MS must be a power of 2");
 
    public:
        RTTEventCallback(const RTTEventCallback&) = delete;
        RTTEventCallback& operator=(const RTTEventCallback&) = delete;
        
        //FIXME we should allow Queue<EVENT, ?>
        explicit RTTEventCallback(containers::Queue<EVENT>& event_queue) : event_queue_{event_queue} {}
 
    private:
        void on_rtt_change(uint32_t millis)
        {
            if ((millis & (PERIOD_MS - 1)) == 0) event_queue_.push_(EVENT{events::Type::RTT_TIMER});
        }
 
        containers::Queue<EVENT>& event_queue_;
 
        friend struct isr_handler_rtt;
    };
 
 
    // All RTT-related methods called by pre-defined ISR are defined here
    //====================================================================
 
    struct isr_handler_rtt
    {
        template<uint8_t TIMER_NUM_> static void rtt()
        {
            static constexpr board::Timer NTIMER = isr_handler::check_timer<TIMER_NUM_>();
            interrupt::HandlerHolder<RTT<NTIMER>>::handler()->on_timer();
        }
 
        template<uint8_t TIMER_NUM_, typename HANDLER_, void (HANDLER_::*CALLBACK_)(uint32_t)> static void rtt_method()
        {
            static constexpr board::Timer NTIMER = isr_handler::check_timer<TIMER_NUM_>();
            auto handler = interrupt::HandlerHolder<RTT<NTIMER>>::handler();
            handler->on_timer();
            interrupt::CallbackHandler<void (HANDLER_::*)(uint32_t), CALLBACK_>::call(handler->millis());
        }
 
        template<uint8_t TIMER_NUM_, void (*CALLBACK_)(uint32_t)> static void rtt_function()
        {
            static constexpr board::Timer NTIMER = isr_handler::check_timer<TIMER_NUM_>();
            auto handler = interrupt::HandlerHolder<RTT<NTIMER>>::handler();
            handler->on_timer();
            CALLBACK_(handler->millis());
        }
 
        template<uint8_t TIMER_NUM_, typename EVENT_, uint32_t PERIOD_> static void rtt_event()
        {
            static constexpr board::Timer NTIMER = isr_handler::check_timer<TIMER_NUM_>();
            auto handler = interrupt::HandlerHolder<RTT<NTIMER>>::handler();
            handler->on_timer();
            interrupt::HandlerHolder<RTTEventCallback<EVENT_, PERIOD_>>::handler()->on_rtt_change(handler->millis());
        }
    };
}
 
#endif /* RTT_HH */