interrupts.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 INTERRUPTS_HH
#define INTERRUPTS_HH
 
#include "boards/io.h"
#include <avr/interrupt.h>
 
// Macro found on https://tty1.net/blog/2008/avr-gcc-optimisations_en.html
// This allows processing pointers to SRAM data be performed directly from Y, Z registers
// this may optimize code size on some circumstances
#define FIX_BASE_POINTER(_ptr) __asm__ __volatile__("" : "=b"(_ptr) : "0"(_ptr))
 
namespace interrupt
{
    template<typename Handler> void register_handler(Handler&);
    template<typename Handler> void unregister_handler(Handler&);
 
    template<typename Handler> class HandlerHolder
    {
    public:
        static Handler* handler()
        {
            return handler_;
        }
 
        using Holder = HandlerHolder<Handler>;
 
        template<typename Ret, typename... Args> struct ArgsHolder
        {
            template<Ret (Handler::*Callback)(Args...)> struct CallbackHolder
            {
                static Ret handle(Args... args)
                {
                    Handler* handler_instance = Holder::handler();
                    FIX_BASE_POINTER(handler_instance);
                    return (handler_instance->*Callback)(args...);
                }
                static Ret safe_handle(Args... args)
                {
                    Handler* handler_instance = Holder::handler();
                    if (handler_instance == nullptr)
                        return Ret{};
                    FIX_BASE_POINTER(handler_instance);
                    return (handler_instance->*Callback)(args...);
                }
            };
        };
 
    private:
        static Handler* handler_;
        friend void register_handler<Handler>(Handler&);
        friend void unregister_handler<Handler>(Handler&);
    };
 
    template<typename Handler> Handler* HandlerHolder<Handler>::handler_ = nullptr;
 
    // Used by ISR to perform a callback to a PTMF
    // Found great inspiration for this pattern there:
    // https://stackoverflow.com/questions/9779105/generic-member-function-pointer-as-a-template-parameter
    template<typename T, T> struct CallbackHandler;
    template<typename HANDLER, typename RET, typename... ARGS, RET (HANDLER::*CALLBACK)(ARGS...)>
    struct CallbackHandler<RET (HANDLER::*)(ARGS...), CALLBACK>
    {
        static RET call(ARGS... args)
        {
            // NOTE the following line does not compile, it must be broken down for the compiler to understand
            // return HandlerHolder<HANDLER>::ArgsHolder<RET, ARGS...>::CallbackHolder<CALLBACK>::handle(args...);
            using HOLDER = HandlerHolder<HANDLER>;
            using ARGS_HOLDER = typename HOLDER::template ArgsHolder<RET, ARGS...>;
            using CALLBACK_HOLDER = typename ARGS_HOLDER::template CallbackHolder<CALLBACK>;
            return CALLBACK_HOLDER::handle(args...);
        }
        static RET safe_call(ARGS... args)
        {
            // NOTE the following line does not compile, it must be broken down for the compiler to understand
            // return HandlerHolder<HANDLER>::ArgsHolder<RET, ARGS...>::CallbackHolder<CALLBACK>::handle(args...);
            using HOLDER = HandlerHolder<HANDLER>;
            using ARGS_HOLDER = typename HOLDER::template ArgsHolder<RET, ARGS...>;
            using CALLBACK_HOLDER = typename ARGS_HOLDER::template CallbackHolder<CALLBACK>;
            return CALLBACK_HOLDER::safe_handle(args...);
        }
    };
    template<typename RET, typename... ARGS, RET (*CALLBACK)(ARGS...)>
    struct CallbackHandler<RET (*)(ARGS...), CALLBACK>
    {
        static RET call(ARGS... args)
        {
            return CALLBACK(args...);
        }
        static RET safe_call(ARGS... args)
        {
            return CALLBACK(args...);
        }
    };
 
    template<typename Handler> void register_handler(Handler& handler)
    {
        HandlerHolder<Handler>::handler_ = &handler;
    }
 
    template<typename Handler> void unregister_handler(Handler& handler)
    {
        if (HandlerHolder<Handler>::handler_ == &handler)
            HandlerHolder<Handler>::handler_ = nullptr;
    }
}
 
 
// Macro often used to build vector names from parameters
#define CAT3(X, Y, Z) X##Y##Z
 
 
#endif /* INTERRUPTS_HH */