int.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 INT_HH
#define INT_HH
 
#include "boards/board_traits.h"
#include <avr/interrupt.h>
#include "interrupts.h"
#include "utilities.h"
 
#define REGISTER_INT_ISR_METHOD(INT_NUM, PIN, HANDLER, CALLBACK)                   \
    ISR(CAT3(INT, INT_NUM, _vect))                                                 \
    {                                                                              \
        interrupt::isr_handler_int::int_method<INT_NUM, PIN, HANDLER, CALLBACK>(); \
    }
 
#define REGISTER_INT_ISR_FUNCTION(INT_NUM, PIN, CALLBACK)                   \
    ISR(CAT3(INT, INT_NUM, _vect))                                          \
    {                                                                       \
        interrupt::isr_handler_int::int_function<INT_NUM, PIN, CALLBACK>(); \
    }
 
#define REGISTER_INT_ISR_EMPTY(INT_NUM, PIN)                        \
    extern "C" void CAT3(INT, INT_NUM, _vect)(void) NAKED_SIGNAL;   \
    void CAT3(INT, INT_NUM, _vect)(void)                            \
    {                                                               \
        interrupt::isr_handler_int::check_int_pin<INT_NUM, PIN>();  \
        __asm__ __volatile__("reti" ::);                            \
    }
 
#define DECL_INT_ISR_HANDLERS_FRIEND            \
    friend struct interrupt::isr_handler_int;   \
    DECL_INT_ISR_FRIENDS
 
namespace board
{
    template<ExternalInterruptPin EXT> constexpr DigitalPin EXT_PIN() INLINE;
    template<ExternalInterruptPin EXT> constexpr DigitalPin EXT_PIN()
    {
        return board_traits::ExternalInterruptPin_trait<EXT>::ACTUAL_PIN;
    }
};
 
namespace interrupt
{
    enum class InterruptTrigger : uint8_t
    {
        LOW_LEVEL = 0x00,
        ANY_CHANGE = 0x55,
        FALLING_EDGE = 0xAA,
        RISING_EDGE = 0xFF
    };
 
    template<board::ExternalInterruptPin EXTPIN_> class INTSignal
    {
    public:
        static constexpr const board::ExternalInterruptPin EXTPIN = EXTPIN_;
        static constexpr const board::DigitalPin PIN = board::EXT_PIN<EXTPIN>();
 
    private:
        using INT_TRAIT = board_traits::ExternalInterruptPin_trait<EXTPIN>;
 
    public:
        INTSignal(const INTSignal&) = delete;
        INTSignal& operator=(const INTSignal&) = delete;
        
        explicit INTSignal(InterruptTrigger trigger = InterruptTrigger::ANY_CHANGE)
        {
            set_trigger_(trigger);
        }
 
        void set_trigger(InterruptTrigger trigger)
        {
            synchronized INT_TRAIT::EICR_ =
                (INT_TRAIT::EICR_ & bits::COMPL(INT_TRAIT::EICR_MASK)) | (uint8_t(trigger) & INT_TRAIT::EICR_MASK);
        }
 
        void enable()
        {
            synchronized INT_TRAIT::EIMSK_ |= INT_TRAIT::EIMSK_MASK;
        }
 
        void disable()
        {
            synchronized INT_TRAIT::EIMSK_ &= bits::COMPL(INT_TRAIT::EIMSK_MASK);
        }
 
        void clear()
        {
            synchronized INT_TRAIT::EIFR_ |= INT_TRAIT::EIFR_MASK;
        }
 
        void set_trigger_(InterruptTrigger trigger)
        {
            INT_TRAIT::EICR_ = (INT_TRAIT::EICR_ & bits::COMPL(INT_TRAIT::EICR_MASK)) 
                               | (uint8_t(trigger) & INT_TRAIT::EICR_MASK);
        }
 
        void enable_()
        {
            INT_TRAIT::EIMSK_ |= INT_TRAIT::EIMSK_MASK;
        }
 
        void disable_()
        {
            INT_TRAIT::EIMSK_ &= bits::COMPL(INT_TRAIT::EIMSK_MASK);
        }
 
        void clear_()
        {
            INT_TRAIT::EIFR_ |= INT_TRAIT::EIFR_MASK;
        }
    };
 
 
    // All INT-related methods called by pre-defined ISR are defined here
    //====================================================================
 
    struct isr_handler_int
    {
        template<uint8_t INT_NUM_, board::ExternalInterruptPin INT_PIN_> static void check_int_pin()
        {
            static_assert(board_traits::ExternalInterruptPin_trait<INT_PIN_>::INT == INT_NUM_,
                          "PIN INT number must match INT_NUM");
        }
 
        template<uint8_t INT_NUM_, board::ExternalInterruptPin INT_PIN_, typename HANDLER_, void (HANDLER_::*CALLBACK_)()>
        static void int_method()
        {
            // Check pin is compliant
            check_int_pin<INT_NUM_, INT_PIN_>();
            // Call handler back
            interrupt::CallbackHandler<void (HANDLER_::*)(), CALLBACK_>::call();
        }
 
        template<uint8_t INT_NUM_, board::ExternalInterruptPin INT_PIN_, void (*CALLBACK_)()> static void int_function()
        {
            // Check pin is compliant
            check_int_pin<INT_NUM_, INT_PIN_>();
            // Call handler back
            CALLBACK_();
        }
    };
}
 
#endif /* INT_HH */