mcp23017.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 MCP23017_H
#define MCP23017_H
 
#include "mcp230xx.h"
#include "../bits.h"
#include "../functors.h"
#include "../i2c_device.h"
#include "../i2c_device_utilities.h"
 
namespace devices::mcp230xx
{
    enum class MCP23017Port : uint8_t
    {
        PORT_A,
        PORT_B,
        PORT_AB
    };
 
    namespace mcp23017_traits
    {
        template<MCP23017Port PORT_> struct Port_trait
        {
            using TYPE = uint8_t;
            static constexpr uint8_t shift(uint8_t reg)
            {
                return reg;
            }
        };
 
        template<> struct Port_trait<MCP23017Port::PORT_A>
        {
            using TYPE = uint8_t;
            static constexpr uint8_t shift(uint8_t reg)
            {
                return reg;
            }
        };
 
        template<> struct Port_trait<MCP23017Port::PORT_B>
        {
            using TYPE = uint8_t;
            static constexpr uint8_t shift(uint8_t reg)
            {
                return reg + 1;
            }
        };
 
        template<> struct Port_trait<MCP23017Port::PORT_AB>
        {
            using TYPE = uint16_t;
            static constexpr uint8_t shift(uint8_t reg)
            {
                return reg;
            }
        };
    }
 
    template<typename MANAGER>
    class MCP23017 : public i2c::I2CDevice<MANAGER>
    {
    private:
        using PARENT = i2c::I2CDevice<MANAGER>;
        template<typename OUT, typename IN> using FUTURE = typename PARENT::template FUTURE<OUT, IN>;
 
        template<MCP23017Port P> using TRAIT = mcp23017_traits::Port_trait<P>;
        template<MCP23017Port P> using T = typename TRAIT<P>::TYPE;
 
        // Forward declarations needed by compiler
        template<MCP23017Port P, uint8_t REGISTER>
        using TReadRegisterFuture = i2c::TReadRegisterFuture<MANAGER, TRAIT<P>::shift(REGISTER), T<P>>;
        template<MCP23017Port P, uint8_t REGISTER>
        using TWriteRegisterFuture = i2c::TWriteRegisterFuture<MANAGER, TRAIT<P>::shift(REGISTER), T<P>>;
        template<MCP23017Port P, uint8_t... REGISTERS>
        using TWriteMultiRegisterFuture = i2c::TWriteMultiRegisterFuture<MANAGER, T<P>, TRAIT<P>::shift(REGISTERS)...>;
 
        // Base address of the device (actual address can be in 0x20-0x27)
        static constexpr const uint8_t BASE_ADDRESS = 0x20;
 
        // All registers addresses (in BANK 0 mode only)
        static constexpr const uint8_t IODIR_A = 0x00;
        static constexpr const uint8_t IODIR_B = 0x01;
        static constexpr const uint8_t IPOL_A = 0x02;
        static constexpr const uint8_t IPOL_B = 0x03;
 
        static constexpr const uint8_t GPINTEN_A = 0x04;
        static constexpr const uint8_t GPINTEN_B = 0x05;
        static constexpr const uint8_t DEFVAL_A = 0x06;
        static constexpr const uint8_t DEFVAL_B = 0x07;
        static constexpr const uint8_t INTCON_A = 0x08;
        static constexpr const uint8_t INTCON_B = 0x09;
 
        static constexpr const uint8_t IOCON = 0x0A;
 
        static constexpr const uint8_t GPPU_A = 0x0C;
        static constexpr const uint8_t GPPU_B = 0x0D;
 
        static constexpr const uint8_t INTF_A = 0x0E;
        static constexpr const uint8_t INTF_B = 0x0F;
        static constexpr const uint8_t INTCAP_A = 0x10;
        static constexpr const uint8_t INTCAP_B = 0x11;
 
        static constexpr const uint8_t GPIO_A = 0x12;
        static constexpr const uint8_t GPIO_B = 0x13;
        static constexpr const uint8_t OLAT_A = 0x14;
        static constexpr const uint8_t OLAT_B = 0x15;
 
        // IOCON bits (not all are used in this implementation)
        static constexpr const uint8_t IOCON_BANK = bits::BV8(7);
        static constexpr const uint8_t IOCON_MIRROR = bits::BV8(6);
        static constexpr const uint8_t IOCON_SEQOP = bits::BV8(5);
        static constexpr const uint8_t IOCON_DISSLW = bits::BV8(4);
        static constexpr const uint8_t IOCON_HAEN = bits::BV8(3);
        static constexpr const uint8_t IOCON_ODR = bits::BV8(2);
        static constexpr const uint8_t IOCON_INTPOL = bits::BV8(1);
 
        static constexpr uint8_t compute_address(uint8_t address)
        {
            return uint8_t((uint8_t(BASE_ADDRESS) | uint8_t(address & 0x07U)) << 1);
        }
 
    public:
        MCP23017(MANAGER& manager, uint8_t address)
            : PARENT{manager, compute_address(address), i2c::I2C_FAST, true} {}
 
        // Asynchronous API
        //==================
        class BeginFuture : public TWriteRegisterFuture<MCP23017Port::PORT_A, IOCON>
        {
            using PARENT = TWriteRegisterFuture<MCP23017Port::PORT_A, IOCON>;
        public:
            explicit BeginFuture(
                bool mirror_interrupts = false,
                InterruptPolarity interrupt_polarity = InterruptPolarity::ACTIVE_HIGH)
                :   PARENT{build_IOCON(
                        mirror_interrupts, interrupt_polarity == InterruptPolarity::ACTIVE_HIGH)} {}
        };
 
        int begin(BeginFuture& future)
        {
            return this->async_write(future);
        }
 
        template<MCP23017Port P_>
        class ConfigureGPIOFuture : public TWriteMultiRegisterFuture<P_, IODIR_A, IPOL_A, GPPU_A>
        {
            using PARENT = TWriteMultiRegisterFuture<P_, IODIR_A, IPOL_A, GPPU_A>;
        public:
            ConfigureGPIOFuture(T<P_> direction, T<P_> pullup = T<P_>{}, T<P_> polarity = T<P_>{})
                :   PARENT{direction, polarity, pullup} {}
        };
 
        template<MCP23017Port P_> int configure_gpio(ConfigureGPIOFuture<P_>& future)
        {
            return this->async_multi_write(future);
        }
 
        template<MCP23017Port P_>
        class ConfigureInterruptsFuture : public TWriteMultiRegisterFuture<P_, GPINTEN_A, DEFVAL_A, INTCON_A>
        {
            using PARENT = TWriteMultiRegisterFuture<P_, GPINTEN_A, DEFVAL_A, INTCON_A>;
        public:
            ConfigureInterruptsFuture(T<P_> int_pins, T<P_> ref = T<P_>{}, T<P_> compare_ref = T<P_>{})
                :   PARENT{int_pins, ref, compare_ref} {}
        };
 
        template<MCP23017Port P_>
        int configure_interrupts(ConfigureInterruptsFuture<P_>& future)
        {
            return this->async_multi_write(future);
        }
 
        template<MCP23017Port P_>
        using SetValuesFuture = TWriteRegisterFuture<P_, GPIO_A>;
 
        template<MCP23017Port P_> int values(SetValuesFuture<P_>& future)
        {
            return this->async_write(future);
        }
 
        template<MCP23017Port P_> 
        using GetValuesFuture = TReadRegisterFuture<P_, GPIO_A>;
 
        template<MCP23017Port P_> int values(GetValuesFuture<P_>& future)
        {
            return this->async_read(future);
        }
 
        template<MCP23017Port P_> 
        using InterruptFlagsFuture = TReadRegisterFuture<P_, INTF_A>;
 
        template<MCP23017Port P_> int interrupt_flags(InterruptFlagsFuture<P_>& future)
        {
            return this->async_read(future);
        }
 
        template<MCP23017Port P_>
        using CapturedValuesFuture = TReadRegisterFuture<P_, INTCAP_A>;
 
        template<MCP23017Port P_> int captured_values(CapturedValuesFuture<P_>& future)
        {
            return this->async_read(future);
        }
 
        // Synchronous API
        //=================
        bool begin(bool mirror_interrupts = false,
                   InterruptPolarity interrupt_polarity = InterruptPolarity::ACTIVE_HIGH)
        {
            BeginFuture future{mirror_interrupts, interrupt_polarity};
            if (begin(future) != 0) return false;
            return (future.await() == future::FutureStatus::READY);
        }
 
        template<MCP23017Port P_> bool configure_gpio(T<P_> direction, T<P_> pullup = T<P_>{}, T<P_> polarity = T<P_>{})
        {
            ConfigureGPIOFuture<P_> future{direction, pullup, polarity};
            if (configure_gpio(future) != 0) return false;
            return (future.await() == future::FutureStatus::READY);
        }
 
        template<MCP23017Port P_>
        bool configure_interrupts(T<P_> int_pins, T<P_> ref = T<P_>{}, T<P_> compare_ref = T<P_>{})
        {
            ConfigureInterruptsFuture<P_> future{int_pins, ref, compare_ref};
            if (configure_interrupts(future) != 0) return false;
            return (future.await() == future::FutureStatus::READY);
        }
 
        template<MCP23017Port P_> bool values(T<P_> value)
        {
            return this->template sync_write<SetValuesFuture<P_>>(value);
        }
 
        template<MCP23017Port P_> T<P_> values()
        {
            return get_value<GetValuesFuture<P_>, T<P_>>();
        }
 
        template<MCP23017Port P_> T<P_> interrupt_flags()
        {
            return get_value<InterruptFlagsFuture<P_>, T<P_>>();
        }
 
        template<MCP23017Port P_> T<P_> captured_values()
        {
            return get_value<CapturedValuesFuture<P_>, T<P_>>();
        }
 
    private:
        template<typename F, typename T> T get_value()
        {
            T value;
            if (this->template sync_read<F>(value))
                return value;
            else
                return T{};
        }
 
        i2c::I2CLightCommand write_stop(uint8_t byte_count = 0) const
        {
            return this->write(byte_count, false, true);
        }
 
        static constexpr uint8_t build_IOCON(bool mirror, bool int_polarity)
        {
            return bits::ORIF8(mirror, IOCON_MIRROR, int_polarity, IOCON_INTPOL);
        }
    };
}
 
#endif /* MCP23017_H */