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 TIMER_HH
#define TIMER_HH
 
#include "boards/board_traits.h"
#include <avr/interrupt.h>
#include <stddef.h>
#include "interrupts.h"
#include "utilities.h"
 
// Generic macros to register ISR on Timer
//=========================================
#define REGISTER_TIMER_COMPARE_ISR_METHOD(TIMER_NUM, HANDLER, CALLBACK)    \
    ISR(CAT3(TIMER, TIMER_NUM, _COMPA_vect))                               \
    {                                                                      \
        timer::isr_handler::check_timer<TIMER_NUM>();                      \
        interrupt::CallbackHandler<void (HANDLER::*)(), CALLBACK>::call(); \
    }
 
#define REGISTER_TIMER_COMPARE_ISR_FUNCTION(TIMER_NUM, CALLBACK)  \
    ISR(CAT3(TIMER, TIMER_NUM, _COMPA_vect))                      \
    {                                                             \
        timer::isr_handler::check_timer<TIMER_NUM>();             \
        interrupt::CallbackHandler<void (*)(), CALLBACK>::call(); \
    }
 
#define REGISTER_TIMER_COMPARE_ISR_EMPTY(TIMER_NUM)                             \
    extern "C" void CAT3(TIMER, TIMER_NUM, _COMPA_vect)(void) NAKED_SIGNAL;     \
    void CAT3(TIMER, TIMER_NUM, _COMPA_vect)(void)                              \
    {                                                                           \
        timer::isr_handler::check_timer<TIMER_NUM>();                           \
        __asm__ __volatile__("reti" ::);                                        \
    }
 
#define REGISTER_TIMER_OVERFLOW_ISR_METHOD(TIMER_NUM, HANDLER, CALLBACK)   \
    ISR(CAT3(TIMER, TIMER_NUM, _OVF_vect))                                 \
    {                                                                      \
        timer::isr_handler::check_timer<TIMER_NUM>();                      \
        interrupt::CallbackHandler<void (HANDLER::*)(), CALLBACK>::call(); \
    }
 
#define REGISTER_TIMER_OVERFLOW_ISR_FUNCTION(TIMER_NUM, CALLBACK) \
    ISR(CAT3(TIMER, TIMER_NUM, _OVF_vect))                        \
    {                                                             \
        timer::isr_handler::check_timer<TIMER_NUM>();             \
        interrupt::CallbackHandler<void (*)(), CALLBACK>::call(); \
    }
 
#define REGISTER_TIMER_OVERFLOW_ISR_EMPTY(TIMER_NUM)                        \
    extern "C" void CAT3(TIMER, TIMER_NUM, _OVF_vect)(void) NAKED_SIGNAL;   \
    void CAT3(TIMER, TIMER_NUM, _OVF_vect)(void)                            \
    {                                                                       \
        timer::isr_handler::check_timer<TIMER_NUM>();                       \
        __asm__ __volatile__("reti" ::);                                    \
    }
 
#define REGISTER_TIMER_CAPTURE_ISR_METHOD(TIMER_NUM, HANDLER, CALLBACK)           \
    ISR(CAT3(TIMER, TIMER_NUM, _CAPT_vect))                                       \
    {                                                                             \
        timer::isr_handler::timer_capture_method<TIMER_NUM, HANDLER, CALLBACK>(); \
    }
 
#define REGISTER_TIMER_CAPTURE_ISR_FUNCTION(TIMER_NUM, CALLBACK)           \
    ISR(CAT3(TIMER, TIMER_NUM, _CAPT_vect))                                \
    {                                                                      \
        timer::isr_handler::timer_capture_function<TIMER_NUM, CALLBACK>(); \
    }
 
#define REGISTER_TIMER_CAPTURE_ISR_EMPTY(TIMER_NUM)                         \
    extern "C" void CAT3(TIMER, TIMER_NUM, _CAPT_vect)(void) NAKED_SIGNAL;  \
    void CAT3(TIMER, TIMER_NUM, _CAPT_vect)(void)                           \
    {                                                                       \
        timer::isr_handler::check_timer_capture<TIMER_NUM>();               \
        __asm__ __volatile__("reti" ::);                                    \
    }
 
#define DECL_TIMER_ISR_HANDLERS_FRIEND \
    friend struct timer::isr_handler;  \
    DECL_TIMER_COMP_FRIENDS            \
    DECL_TIMER_OVF_FRIENDS             \
    DECL_TIMER_CAPT_FRIENDS
 
namespace timer
{
    enum class TimerMode : uint8_t
    {
        NORMAL,
        CTC,
        FAST_PWM,
        PHASE_CORRECT_PWM
    };
 
    enum class TimerInterrupt : uint8_t
    {
        OVERFLOW = board_traits::TimerInterrupt::OVERFLOW,
        OUTPUT_COMPARE_A = board_traits::TimerInterrupt::OUTPUT_COMPARE_A,
        OUTPUT_COMPARE_B = board_traits::TimerInterrupt::OUTPUT_COMPARE_B,
        OUTPUT_COMPARE_C = board_traits::TimerInterrupt::OUTPUT_COMPARE_C,
        INPUT_CAPTURE = board_traits::TimerInterrupt::INPUT_CAPTURE
    };
 
    constexpr TimerInterrupt operator|(TimerInterrupt i1, TimerInterrupt i2)
    {
        return TimerInterrupt(uint8_t(i1) | uint8_t(i2));
    }
 
    enum class TimerOutputMode : uint8_t
    {
        DISCONNECTED,
        TOGGLE,
        NON_INVERTING,
        INVERTING
    };
 
    enum class TimerInputCapture : uint8_t
    {
        RISING_EDGE,
        FALLING_EDGE
    };
 
    template<board::Timer NTIMER_> struct Calculator
    {
    public:
        static constexpr const board::Timer NTIMER = NTIMER_;
 
    private:
        using TRAIT = board_traits::Timer_trait<NTIMER>;
        using PRESCALERS_TRAIT = typename TRAIT::PRESCALERS_TRAIT;
 
    public:
        using TYPE = typename TRAIT::TYPE;
        using PRESCALER = typename PRESCALERS_TRAIT::TYPE;
        static constexpr const TYPE PWM_MAX = TRAIT::MAX_PWM;
 
        static constexpr PRESCALER tick_prescaler(uint32_t us_per_tick)
        {
            return best_tick_prescaler(PRESCALERS_TRAIT::ALL_PRESCALERS, us_per_tick);
        }
 
        static constexpr uint32_t ticks_to_us(PRESCALER prescaler, TYPE ticks)
        {
            return uint32_t(ticks) * bits::BV16(uint8_t(prescaler)) / INST_PER_US;
        }
 
        static constexpr TYPE us_to_ticks(PRESCALER prescaler, uint32_t us)
        {
            return TYPE(us * INST_PER_US / bits::BV16(uint8_t(prescaler)));
        }
 
        static constexpr PRESCALER CTC_prescaler(uint32_t us)
        {
            return best_prescaler(PRESCALERS_TRAIT::ALL_PRESCALERS, us);
        }
 
        static constexpr uint32_t CTC_frequency(PRESCALER prescaler)
        {
            return F_CPU / bits::BV16(uint8_t(prescaler));
        }
 
        static constexpr TYPE CTC_counter(PRESCALER prescaler, uint32_t us)
        {
            return (TYPE) prescaler_quotient(prescaler, us) - 1;
        }
 
        static constexpr bool is_adequate_for_CTC(PRESCALER prescaler, uint32_t us)
        {
            return prescaler_is_adequate(prescaler_quotient(prescaler, us));
        }
 
        static constexpr PRESCALER FastPWM_prescaler(uint16_t pwm_frequency)
        {
            return best_frequency_prescaler(PRESCALERS_TRAIT::ALL_PRESCALERS, pwm_frequency * (PWM_MAX + 1UL));
        }
 
        static constexpr uint16_t FastPWM_frequency(PRESCALER prescaler)
        {
            return F_CPU / bits::BV16(uint8_t(prescaler)) / (PWM_MAX + 1UL);
        }
 
        static constexpr PRESCALER PhaseCorrectPWM_prescaler(uint16_t pwm_frequency)
        {
            return best_frequency_prescaler(PRESCALERS_TRAIT::ALL_PRESCALERS, pwm_frequency * (2UL * PWM_MAX));
        }
 
        static constexpr uint16_t PhaseCorrectPWM_frequency(PRESCALER prescaler)
        {
            return F_CPU / bits::BV16(uint8_t(prescaler)) / (2UL * PWM_MAX);
        }
 
        static constexpr PRESCALER PulseTimer_prescaler(uint16_t max_pulse_width_us, uint16_t pulse_frequency)
        {
            return TRAIT::IS_16BITS ? PWM_ICR_prescaler(pulse_frequency) : CTC_prescaler(max_pulse_width_us);
        }
 
        static constexpr TYPE PulseTimer_value(PRESCALER prescaler, uint16_t period_us)
        {
            return CTC_counter(prescaler, period_us);
        }
 
        static constexpr PRESCALER PWM_ICR_prescaler(uint16_t pwm_frequency)
        {
            return best_frequency_prescaler(PRESCALERS_TRAIT::ALL_PRESCALERS, pwm_frequency * (TRAIT::MAX_PWM + 1UL));
        }
 
        static constexpr uint16_t PWM_ICR_frequency(PRESCALER prescaler, uint16_t counter)
        {
            return F_CPU / bits::BV16(uint8_t(prescaler)) / counter;
        }
 
        static constexpr uint16_t PWM_ICR_counter(PRESCALER prescaler, uint16_t pwm_frequency)
        {
            return F_CPU / bits::BV16(uint8_t(prescaler)) / pwm_frequency;
        }
 
    private:
        static constexpr uint32_t prescaler_quotient(PRESCALER prescaler, uint32_t us)
        {
            return (INST_PER_US * us) / bits::BV16(uint8_t(prescaler));
        }
 
        static constexpr uint32_t prescaler_remainder(PRESCALER prescaler, uint32_t us)
        {
            return (INST_PER_US * us) % bits::BV16(uint8_t(prescaler));
        }
 
        static constexpr bool prescaler_is_adequate(uint32_t quotient)
        {
            return (quotient > 1) && (quotient < TRAIT::MAX_COUNTER);
        }
 
        template<size_t N> static constexpr PRESCALER best_prescaler(const PRESCALER (&prescalers)[N], uint32_t us)
        {
            // Find the best prescaler:
            // - quotient is in ]1; MAX_COUNTER[
            // - smallest remainder
            // - largest quotient
            uint32_t smallest_remainder = UINT32_MAX;
            uint32_t largest_quotient = 0;
            PRESCALER current = prescalers[N - 1];
            for (size_t i = 0; i < N; ++i)
            {
                PRESCALER prescaler = prescalers[i];
                uint32_t quotient = prescaler_quotient(prescaler, us);
                if (prescaler_is_adequate(quotient))
                {
                    uint32_t remainder = prescaler_remainder(prescaler, us);
                    if (remainder > smallest_remainder) continue;
                    if ((remainder == smallest_remainder) && (quotient <= largest_quotient)) continue;
                    current = prescaler;
                    smallest_remainder = remainder;
                    largest_quotient = quotient;
                }
            }
            return current;
        }
 
        static constexpr bool prescaler_is_adequate_for_frequency(PRESCALER prescaler, uint32_t freq)
        {
            return (F_CPU / (uint32_t) bits::BV16(uint8_t(prescaler))) > freq;
        }
 
        template<size_t N>
        static constexpr PRESCALER best_frequency_prescaler(const PRESCALER (&prescalers)[N], uint32_t freq)
        {
            // Best prescaler is biggest possible divider, hence try all prescalers from largest to smallest
            for (size_t i = 0; i < N; ++i)
            {
                PRESCALER prescaler = prescalers[N - 1 - i];
                if (prescaler_is_adequate_for_frequency(prescaler, freq)) return prescaler;
            }
            // If no prescaler is adequate then return largest divider
            return prescalers[N - 1];
        }
 
        static constexpr bool prescaler_is_adequate_for_tick(PRESCALER prescaler, uint32_t us)
        {
            return (prescaler_quotient(prescaler, us) >= 1);
        }
 
        template<size_t N> static constexpr PRESCALER best_tick_prescaler(const PRESCALER (&prescalers)[N], uint32_t us)
        {
            // Best prescaler is biggest possible divider, hence try all prescalers from largest to smallest
            for (size_t i = 0; i < N; ++i)
            {
                PRESCALER prescaler = prescalers[N - 1 - i];
                if (prescaler_is_adequate_for_tick(prescaler, us)) return prescaler;
            }
            // If no prescaler is adequate then return largest divider
            return prescalers[N - 1];
        }
    };
 
    template<board::Timer NTIMER_> class Timer
    {
    public:
        static constexpr const board::Timer NTIMER = NTIMER_;
 
    protected:
        using TRAIT = board_traits::Timer_trait<NTIMER>;
        using PRESCALERS_TRAIT = typename TRAIT::PRESCALERS_TRAIT;
 
    public:
        Timer(const Timer&) = delete;
        Timer& operator=(const Timer&) = delete;
        
        using TYPE = typename TRAIT::TYPE;
 
        using CALCULATOR = Calculator<NTIMER>;
 
        using PRESCALER = typename PRESCALERS_TRAIT::TYPE;
 
        static constexpr const TYPE TIMER_MAX = TRAIT::MAX_COUNTER - 1;
 
        static constexpr const TYPE PWM_MAX = TRAIT::MAX_PWM;
 
        static constexpr const board::DigitalPin ICP_PIN = TRAIT::ICP_PIN;
 
        Timer(TimerMode timer_mode, PRESCALER prescaler, TimerInterrupt interrupts = TimerInterrupt(0))
            : tccra_{timer_mode_TCCRA(timer_mode)},
              tccrb_{uint8_t(timer_mode_TCCRB(timer_mode) | TRAIT::TCCRB_prescaler(prescaler))},
              timsk_{TRAIT::TIMSK_int_mask(uint8_t(interrupts))}
        {}
 
        void set_interrupts(TimerInterrupt interrupts = TimerInterrupt(0))
        {
            timsk_ = TRAIT::TIMSK_int_mask(uint8_t(interrupts));
            // Check if timer is currently running
            if (TRAIT::TCCRB) utils::set_mask((volatile uint8_t&) TRAIT::TIMSK_, TRAIT::TIMSK_MASK, timsk_);
        }
 
        void enable_interrupts(TimerInterrupt interrupts)
        {
            timsk_ |= TRAIT::TIMSK_int_mask(uint8_t(interrupts));
            // Check if timer is currently running
            if (TRAIT::TCCRB) utils::set_mask((volatile uint8_t&) TRAIT::TIMSK_, TRAIT::TIMSK_MASK, timsk_);
        }
 
        void disable_interrupts(TimerInterrupt interrupts)
        {
            timsk_ &= bits::COMPL(TRAIT::TIMSK_int_mask(uint8_t(interrupts)));
            // Check if timer is currently running
            if (TRAIT::TCCRB) utils::set_mask((volatile uint8_t&) TRAIT::TIMSK_, TRAIT::TIMSK_MASK, timsk_);
        }
 
        bool are_interrupts_enabled(TimerInterrupt interrupts) const
        {
            uint8_t mask = TRAIT::TIMSK_int_mask(uint8_t(interrupts));
            return (TRAIT::TIMSK_ & mask) == mask;
        }
 
        void set_input_capture(TimerInputCapture input_capture)
        {
            static_assert(TRAIT::ICES_TCCRB != 0, "TIMER must support Input Capture");
            utils::set_mask(tccrb_, TRAIT::ICES_TCCRB, input_capture_TCCRB(input_capture));
            // Check if timer is currently running
            if (TRAIT::TCCRB) TRAIT::TCCRB = tccrb_;
        }
 
        TimerInputCapture input_capture() const
        {
            static_assert(TRAIT::ICES_TCCRB != 0, "TIMER must support Input Capture");
            return TRAIT::TCCRB & TRAIT::ICES_TCCRB ? TimerInputCapture::RISING_EDGE : TimerInputCapture::FALLING_EDGE;
        }
 
        void set_capture_noise_canceller(bool cancel_noise)
        {
            static_assert(TRAIT::ICNC_TCCRB != 0, "TIMER must support Input Capture");
            if (cancel_noise)
                tccrb_ |= TRAIT::ICNC_TCCRB;
            else
                tccrb_ &= ~TRAIT::ICNC_TCCRB;
            // Check if timer is currently running
            if (TRAIT::TCCRB) TRAIT::TCCRB = tccrb_;
        }
 
        bool has_capture_noise_canceller() const
        {
            static_assert(TRAIT::ICNC_TCCRB != 0, "TIMER must support Input Capture");
            return TRAIT::TCCRB & TRAIT::ICNC_TCCRB;
        }
 
        void set_timer_mode(TimerMode timer_mode)
        {
            utils::set_mask(tccra_, TRAIT::MODE_MASK_TCCRA, timer_mode_TCCRA(timer_mode));
            utils::set_mask(tccrb_, TRAIT::MODE_MASK_TCCRB, timer_mode_TCCRB(timer_mode));
            // Check if timer is currently running
            if (TRAIT::TCCRB)
            {
                if (!TRAIT::TCCRA.is_no_reg()) TRAIT::TCCRA = tccra_;
                TRAIT::TCCRB = tccrb_;
            }
        }
 
        TimerMode get_timer_mode() const
        {
            return timer_mode(tccra_, tccrb_);
        }
 
        void set_prescaler(PRESCALER prescaler)
        {
            utils::set_mask(tccrb_, TRAIT::CS_MASK_TCCRB, TRAIT::TCCRB_prescaler(prescaler));
            // Check if timer is currently running
            if (TRAIT::TCCRB) TRAIT::TCCRB = tccrb_;
        }
 
        void begin(TYPE max = 0)
        {
            synchronized begin_(max);
        }
 
        void begin_(TYPE max = 0)
        {
            if (!TRAIT::TCCRA.is_no_reg()) TRAIT::TCCRA = tccra_;
            TRAIT::TCCRB = tccrb_;
            // Set timer counter compare match
            TRAIT::OCRA = max;
            if (!TRAIT::CTC_MAX.is_no_reg()) TRAIT::CTC_MAX = max;
            TRAIT::TCNT = 0;
            // Set timer interrupt mode (set interrupt on OCRnA compare match)
            utils::set_mask((volatile uint8_t&) TRAIT::TIMSK_, TRAIT::TIMSK_MASK, timsk_);
        }
 
        void reset(TYPE ticks = 0)
        {
            if (sizeof(TYPE) > 1)
                synchronized reset_(ticks);
            else
                reset_(ticks);
        }
 
        void reset_(TYPE ticks = 0)
        {
            TRAIT::TCNT = ticks;
        }
 
        TYPE ticks()
        {
            if (sizeof(TYPE) > 1)
                synchronized return ticks_();
            else
                return ticks_();
        }
 
        TYPE ticks_()
        {
            return TRAIT::TCNT;
        }
 
        void suspend_interrupts()
        {
            synchronized suspend_interrupts_();
        }
 
        void suspend_interrupts_()
        {
            // Clear timer interrupt mode
            utils::set_mask((volatile uint8_t&) TRAIT::TIMSK_, TRAIT::TIMSK_MASK, uint8_t(0));
        }
 
        void resume_interrupts()
        {
            synchronized resume_interrupts_();
        }
 
        void resume_interrupts_()
        {
            // Reset timer counter
            TRAIT::TCNT = 0;
            // Set timer interrupt mode (set interrupt on OCRnA compare match)
            utils::set_mask((volatile uint8_t&) TRAIT::TIMSK_, TRAIT::TIMSK_MASK, timsk_);
        }
 
        bool is_interrupt_suspended()
        {
            return (TRAIT::TIMSK_ & TRAIT::TIMSK_MASK) == 0;
        }
 
        void suspend_timer()
        {
            synchronized suspend_timer_();
        }
 
        void suspend_timer_()
        {
            // Check if timer is currently running, and force clock select to 0 (timer stopped)
            if (TRAIT::TCCRB) TRAIT::TCCRB = tccrb_ & uint8_t(~TRAIT::CS_MASK_TCCRB);
        }
 
        void resume_timer()
        {
            synchronized resume_timer_();
        }
 
        void resume_timer_()
        {
            // Check if timer is currently running
            TRAIT::TCCRB = tccrb_;
        }
 
        void end()
        {
            synchronized end_();
        }
 
        void end_()
        {
            // Stop timer
            TRAIT::TCCRB = 0;
            // Clear timer interrupt mode (set interrupt on OCRnA compare match)
            utils::set_mask((volatile uint8_t&) TRAIT::TIMSK_, TRAIT::TIMSK_MASK, uint8_t(0));
        }
 
        template<uint8_t COM> void set_output_mode(TimerOutputMode mode)
        {
            static_assert(COM < TRAIT::COM_COUNT, "COM must exist for TIMER");
            using COM_TRAIT = board_traits::Timer_COM_trait<NTIMER, COM>;
            utils::set_mask(tccra_, COM_TRAIT::COM_MASK, convert_COM<COM>(mode));
        }
 
        template<uint8_t COM> void set_max(TYPE max)
        {
            static_assert(COM < TRAIT::COM_COUNT, "COM must exist for TIMER");
            using COM_TRAIT = board_traits::Timer_COM_trait<NTIMER, COM>;
            synchronized
            {
                if (max)
                    utils::set_mask((volatile uint8_t&) TRAIT::TCCRA, COM_TRAIT::COM_MASK, tccra_);
                else
                    utils::set_mask((volatile uint8_t&) TRAIT::TCCRA, COM_TRAIT::COM_MASK,
                                    convert_COM<COM>(TimerOutputMode::DISCONNECTED));
                COM_TRAIT::OCR = max;
            }
        }
 
    protected:
        Timer(uint8_t tccra, uint8_t tccrb, uint8_t timsk = 0) : tccra_{tccra}, tccrb_{tccrb}, timsk_{timsk} {}
 
        template<uint8_t COM> static constexpr uint8_t convert_COM(TimerOutputMode output_mode)
        {
            using COM_TRAIT = board_traits::Timer_COM_trait<NTIMER, COM>;
            if (output_mode == TimerOutputMode::TOGGLE) return COM_TRAIT::COM_TOGGLE;
            if (output_mode == TimerOutputMode::INVERTING) return COM_TRAIT::COM_SET;
            if (output_mode == TimerOutputMode::NON_INVERTING) return COM_TRAIT::COM_CLEAR;
            return COM_TRAIT::COM_NORMAL;
        }
 
        static constexpr bool TIMSK_int_mask_IS_SUPPORTED(TimerInterrupt interrupt)
        {
            return (TRAIT::TIMSK_int_mask(UINT8_MAX) & TRAIT::TIMSK_int_mask(uint8_t(interrupt)))
                   == TRAIT::TIMSK_int_mask(uint8_t(interrupt));
        }
 
        static constexpr uint8_t timer_mode_TCCRA(TimerMode timer_mode)
        {
            if (timer_mode == TimerMode::CTC) return TRAIT::CTC_TCCRA;
            if (timer_mode == TimerMode::FAST_PWM) return TRAIT::F_PWM_TCCRA;
            if (timer_mode == TimerMode::PHASE_CORRECT_PWM) return TRAIT::PC_PWM_TCCRA;
            return 0;
        }
        static constexpr uint8_t timer_mode_TCCRB(TimerMode timer_mode)
        {
            if (timer_mode == TimerMode::CTC) return TRAIT::CTC_TCCRB;
            if (timer_mode == TimerMode::FAST_PWM) return TRAIT::F_PWM_TCCRB;
            if (timer_mode == TimerMode::PHASE_CORRECT_PWM) return TRAIT::PC_PWM_TCCRB;
            return 0;
        }
 
        static constexpr bool is_timer_mode(TimerMode mode, uint8_t TCCRA, uint8_t TCCRB)
        {
            return utils::is_mask_equal(TCCRA, TRAIT::MODE_MASK_TCCRA, timer_mode_TCCRA(mode))
                   && utils::is_mask_equal(TCCRB, TRAIT::MODE_MASK_TCCRB, timer_mode_TCCRB(mode));
        }
        static constexpr TimerMode timer_mode(uint8_t TCCRA, uint8_t TCCRB)
        {
            if (is_timer_mode(TimerMode::CTC, TCCRA, TCCRB)) return TimerMode::CTC;
            if (is_timer_mode(TimerMode::FAST_PWM, TCCRA, TCCRB)) return TimerMode::FAST_PWM;
            if (is_timer_mode(TimerMode::PHASE_CORRECT_PWM, TCCRA, TCCRB)) return TimerMode::PHASE_CORRECT_PWM;
            return TimerMode::NORMAL;
        }
 
        static constexpr uint8_t input_capture_TCCRB(TimerInputCapture input_capture)
        {
            return (input_capture == TimerInputCapture::RISING_EDGE ? TRAIT::ICES_TCCRB : 0);
        }
 
        uint8_t tccra_;
        uint8_t tccrb_;
        uint8_t timsk_;
    };
 
 
    // All PCI-related methods called by pre-defined ISR are defined here
    //====================================================================
 
    struct isr_handler
    {
        template<board::Timer NTIMER_> static constexpr board::Timer check_timer()
        {
            using TRAIT = board_traits::Timer_trait<NTIMER_>;
            static_assert(TRAIT::PRESCALERS != board_traits::TimerPrescalers::PRESCALERS_NONE,
                          "TIMER_NUM must be an actual Timer in target MCU");
            return NTIMER_;
        }
 
        template<uint8_t TIMER_NUM_> static constexpr board::Timer check_timer()
        {
            constexpr board::Timer NTIMER = (board::Timer) TIMER_NUM_;
            return check_timer<NTIMER>();
        }
 
        template<uint8_t TIMER_NUM_> static constexpr board::Timer check_timer_capture()
        {
            constexpr board::Timer NTIMER = check_timer<TIMER_NUM_>();
            static_assert(board_traits::Timer_trait<NTIMER>::ICES_TCCRB != 0,
                          "TIMER_NUM must be Timer supporting capture");
            return NTIMER;
        }
 
        template<uint8_t TIMER_NUM_, typename T, typename HANDLER_, void (HANDLER_::*CALLBACK_)(T)>
        static void timer_capture_method_helper()
        {
            static constexpr board::Timer NTIMER = check_timer_capture<TIMER_NUM_>();
            using TRAIT = board_traits::Timer_trait<NTIMER>;
            static_assert(sizeof(typename TRAIT::TYPE) == sizeof(T),
                          "CALLBACK argument is not the proper type (should be same as Timer bits size)");
            T capture = TRAIT::ICR;
            interrupt::CallbackHandler<void (HANDLER_::*)(T), CALLBACK_>::call(capture);
        }
 
        template<uint8_t TIMER_NUM_, typename HANDLER_, void (HANDLER_::*CALLBACK_)(uint8_t)>
        static void timer_capture_method()
        {
            timer_capture_method_helper<TIMER_NUM_, uint8_t, HANDLER_, CALLBACK_>();
        }
 
        template<uint8_t TIMER_NUM_, typename HANDLER_, void (HANDLER_::*CALLBACK_)(uint16_t)>
        static void timer_capture_method()
        {
            timer_capture_method_helper<TIMER_NUM_, uint16_t, HANDLER_, CALLBACK_>();
        }
 
        template<uint8_t TIMER_NUM_, typename T, void (*CALLBACK_)(T)> static void timer_capture_function_helper()
        {
            static constexpr board::Timer NTIMER = check_timer_capture<TIMER_NUM_>();
            using TRAIT = board_traits::Timer_trait<NTIMER>;
            static_assert(sizeof(typename TRAIT::TYPE) == sizeof(T),
                          "CALLBACK argument is not the proper type (should be same as Timer bits size)");
            T capture = TRAIT::ICR;
            CALLBACK_(capture);
        }
 
        template<uint8_t TIMER_NUM_, void (*CALLBACK_)(uint8_t)> static void timer_capture_function()
        {
            timer_capture_function_helper<TIMER_NUM_, uint8_t, CALLBACK_>();
        }
 
        template<uint8_t TIMER_NUM_, void (*CALLBACK_)(uint16_t)> static void timer_capture_function()
        {
            timer_capture_function_helper<TIMER_NUM_, uint16_t, CALLBACK_>();
        }
    };
}
 
#endif /* TIMER_HH */