gpio.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 FASTIO_HH
#define FASTIO_HH
 
#include "boards/board_traits.h"
#include "int.h"
#include "pci.h"
#include "utilities.h"
 
namespace board
{
    template<DigitalPin PIN> constexpr uint8_t BIT() INLINE;
    template<DigitalPin PIN> constexpr uint8_t MASK() INLINE;
 
    template<DigitalPin PIN> constexpr uint8_t BIT()
    {
        return board_traits::DigitalPin_trait<PIN>::BIT;
    }
 
    template<DigitalPin PIN> constexpr uint8_t MASK()
    {
        return bits::BV8(board_traits::DigitalPin_trait<PIN>::BIT);
    }
};
 
namespace gpio
{
    enum class PinMode : uint8_t
    {
        INPUT,
        INPUT_PULLUP,
        OUTPUT,
    };
 
    template<board::Port PORT_, uint8_t BIT_> class FastPin
    {
    private:
        using TRAIT = board_traits::Port_trait<PORT_>;
 
    public:
        FastPin(const FastPin&) = default;
        FastPin& operator=(const FastPin&) = default;
 
        static constexpr const board::Port PORT = PORT_;
        static constexpr const uint8_t BIT = BIT_;
        static constexpr const uint8_t MASK = bits::BV8(BIT);
 
        FastPin() INLINE
        {
            static_assert(TRAIT::DPIN_MASK & bits::BV8(BIT), "BIT must be compatible with PORT available pins");
        }
 
        FastPin(PinMode mode, bool value = false) INLINE
        {
            static_assert(TRAIT::DPIN_MASK & bits::BV8(BIT), "BIT must be compatible with PORT available pins");
            set_mode(mode, value);
        }
 
        void set_mode(PinMode mode, bool value = false) INLINE
        {
            if (mode == PinMode::OUTPUT)
                TRAIT::DDR |= bits::BV8(BIT);
            else
                TRAIT::DDR &= bits::CBV8(BIT);
            if (value || (mode == PinMode::INPUT_PULLUP))
                TRAIT::PORT |= bits::BV8(BIT);
            else
                TRAIT::PORT &= bits::CBV8(BIT);
        }
 
        void set() INLINE
        {
            TRAIT::PORT |= bits::BV8(BIT);
        }
 
        void clear() INLINE
        {
            TRAIT::PORT &= bits::CBV8(BIT);
        }
 
        void toggle() INLINE
        {
            TRAIT::PIN |= bits::BV8(BIT);
        }
 
        bool value() INLINE
        {
            return TRAIT::PIN & bits::BV8(BIT);
        }
    };
 
    template<board::Port PORT_> class FastPort
    {
    private:
        using TRAIT = board_traits::Port_trait<PORT_>;
 
    public:
        FastPort(const FastPort&) = default;
        FastPort& operator=(const FastPort&) = default;
 
        static constexpr const board::Port PORT = PORT_;
 
        FastPort() = default;
 
        FastPort(uint8_t ddr, uint8_t port = 0) INLINE
        {
            set_DDR(ddr);
            set_PORT(port);
        }
 
        template<uint8_t BIT> FastPin<PORT, BIT> get_pin(PinMode mode, bool value = false)
        {
            return FastPin<PORT, BIT>{mode, value};
        }
 
        template<uint8_t BIT> FastPin<PORT, BIT> get_pin()
        {
            return FastPin<PORT, BIT>{};
        }
 
        void set_PORT(uint8_t port) INLINE
        {
            TRAIT::PORT = port;
        }
 
        uint8_t get_PORT() INLINE
        {
            return TRAIT::PORT;
        }
 
        void set_DDR(uint8_t ddr) INLINE
        {
            TRAIT::DDR = ddr;
        }
 
        uint8_t get_DDR() INLINE
        {
            return TRAIT::DDR;
        }
 
        void set_PIN(uint8_t pin) INLINE
        {
            TRAIT::PIN = pin;
        }
 
        uint8_t get_PIN() INLINE
        {
            return TRAIT::PIN;
        }
    };
 
    template<board::Port PORT_, uint8_t MASK_> class FastMaskedPort
    {
    private:
        using TRAIT = board_traits::Port_trait<PORT_>;
 
    public:
        FastMaskedPort(const FastMaskedPort&) = default;
        FastMaskedPort& operator=(const FastMaskedPort&) = default;
 
        static constexpr const board::Port PORT = PORT_;
 
        static constexpr const uint8_t MASK = MASK_;
 
        FastMaskedPort() = default;
 
        FastMaskedPort(uint8_t ddr, uint8_t port = 0)
        {
            set_DDR(ddr);
            set_PORT(port);
        }
 
        void set_PORT(uint8_t port) INLINE
        {
            TRAIT::PORT = uint8_t(TRAIT::PORT & bits::COMPL(MASK)) | uint8_t(port & MASK);
        }
 
        uint8_t get_PORT() INLINE
        {
            return TRAIT::PORT & MASK;
        }
 
        void set_DDR(uint8_t ddr) INLINE
        {
            TRAIT::DDR = uint8_t(TRAIT::DDR & bits::COMPL(MASK)) | uint8_t(ddr & MASK);
        }
 
        uint8_t get_DDR() INLINE
        {
            return TRAIT::DDR & MASK;
        }
 
        void set_PIN(uint8_t pin) INLINE
        {
            TRAIT::PIN = pin & MASK;
        }
 
        uint8_t get_PIN() INLINE
        {
            return TRAIT::PIN & MASK;
        }
    };
 
    template<board::DigitalPin DPIN_> class FastPinType
    {
    private:
        using TRAIT = board_traits::DigitalPin_trait<DPIN_>;
        using PTRAIT = board_traits::Port_trait<TRAIT::PORT>;
 
    public:
        FastPinType() = delete;
 
        static constexpr const board::DigitalPin DPIN = DPIN_;
        static constexpr const board::Port PORT = TRAIT::PORT;
        static constexpr const uint8_t BIT = TRAIT::BIT;
        static constexpr const uint8_t MASK = bits::BV8(BIT);
 
        using TYPE = FastPin<PORT, BIT>;
        using PORT_TYPE = FastPort<PORT>;
 
        static void set_mode(PinMode mode, bool value = false)
        {
            if (mode == PinMode::OUTPUT)
                PTRAIT::DDR |= bits::BV8(BIT);
            else
                PTRAIT::DDR &= bits::CBV8(BIT);
            if (value || (mode == PinMode::INPUT_PULLUP))
                PTRAIT::PORT |= bits::BV8(BIT);
            else
                PTRAIT::PORT &= bits::CBV8(BIT);
        }
 
        static void set()
        {
            PTRAIT::PORT |= bits::BV8(BIT);
        }
 
        static void clear()
        {
            PTRAIT::PORT &= bits::CBV8(BIT);
        }
 
        static void toggle()
        {
            PTRAIT::PIN |= bits::BV8(BIT);
        }
 
        static bool value()
        {
            return PTRAIT::PIN & bits::BV8(BIT);
        }
    };
 
    template<> class FastPinType<board::DigitalPin::NONE>
    {
    public:
        FastPinType() = delete;
 
        static constexpr const board::Port PORT = board::Port::NONE;
        static constexpr const uint8_t BIT = 0;
        static constexpr const uint8_t MASK = 0;
        using TYPE = FastPin<PORT, BIT>;
        using PORT_TYPE = FastPort<PORT>;
 
        static void set_mode(UNUSED PinMode mode, UNUSED bool value = false) {}
        static void set() {}
        static void clear() {}
        static void toggle() {}
        static bool value()
        {
            return false;
        }
    };
 
    template<> class FastPin<board::Port::NONE, 0>
    {
    public:
        FastPin(const FastPin&) = default;
        FastPin& operator=(const FastPin&) = default;
        FastPin() INLINE = default;
        FastPin(PinMode mode UNUSED, bool value UNUSED = false) INLINE {}
        void set() INLINE {}
        void clear() INLINE {}
        void toggle() INLINE {}
        bool value() INLINE
        {
            return false;
        }
    };
 
    template<board::DigitalPin DPIN_>
    using FAST_PIN = typename FastPinType<DPIN_>::TYPE;
 
    template<board::InterruptPin IPIN_>
    using FAST_INT_PIN = typename FastPinType<board::PCI_PIN<IPIN_>()>::TYPE;
 
    template<board::ExternalInterruptPin EPIN_>
    using FAST_EXT_PIN = typename FastPinType<board::EXT_PIN<EPIN_>()>::TYPE;
}
 
#endif /* FASTIO_HH */