mcp23008.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 MCP23008_H
#define MCP23008_H
 
#include "mcp230xx.h"
#include "../functors.h"
#include "../i2c_device.h"
#include "../i2c_device_utilities.h"
 
namespace devices::mcp230xx
{
    template<typename MANAGER>
    class MCP23008 : public i2c::I2CDevice<MANAGER>
    {
    private:
        using PARENT = i2c::I2CDevice<MANAGER>;
 
        // Forward declarations needed by compiler
        template<uint8_t REGISTER, typename T = uint8_t, typename FUNCTOR = functor::Identity<T>>
        using TReadRegisterFuture = i2c::TReadRegisterFuture<MANAGER, REGISTER, T, FUNCTOR>;
        template<uint8_t REGISTER, typename T = uint8_t, typename FUNCTOR = functor::Identity<T>>
        using TWriteRegisterFuture = i2c::TWriteRegisterFuture<MANAGER, REGISTER, T, FUNCTOR>;
        template<typename T, uint8_t... REGISTERS>
        using TWriteMultiRegisterFuture = i2c::TWriteMultiRegisterFuture<MANAGER, T, REGISTERS...>;
 
        static constexpr uint8_t compute_address(uint8_t address)
        {
            return uint8_t((uint8_t(BASE_ADDRESS) | uint8_t(address & 0x07U)) << 1);
        }
 
        // Base address of the device (actual address can be in 0x20-0x27)
        static constexpr const uint8_t BASE_ADDRESS = 0x20;
 
        // All registers addresses
        static constexpr const uint8_t IODIR = 0x00;
        static constexpr const uint8_t IPOL = 0x01;
 
        static constexpr const uint8_t GPINTEN = 0x02;
        static constexpr const uint8_t DEFVAL = 0x03;
        static constexpr const uint8_t INTCON = 0x04;
 
        static constexpr const uint8_t IOCON = 0x05;
 
        static constexpr const uint8_t GPPU = 0x06;
 
        static constexpr const uint8_t INTF = 0x07;
        static constexpr const uint8_t INTCAP = 0x08;
 
        static constexpr const uint8_t GPIO = 0x09;
        static constexpr const uint8_t OLAT = 0x0A;
 
        // IOCON bits (not all are used in this implementation)
        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);
 
        class IOCONConverter
        {
        public:
            using ARG_TYPE = InterruptPolarity;
            using RES_TYPE = uint8_t;
            uint8_t operator()(InterruptPolarity int_polarity) const
            {
                return (int_polarity == InterruptPolarity::ACTIVE_HIGH) ? IOCON_INTPOL : 0;
            }
        };
 
    public:
        MCP23008(MANAGER& manager, uint8_t address)
            : PARENT{manager, compute_address(address), i2c::I2C_FAST, true} {}
 
        // Asynchronous API
        //==================
        using BeginFuture = TWriteRegisterFuture<IOCON, uint8_t, IOCONConverter>;
 
        int begin(BeginFuture& future)
        {
            return this->async_write(future);
        }
 
        class ConfigureGPIOFuture : public TWriteMultiRegisterFuture<uint8_t, IODIR, IPOL, GPPU>
        {
            using PARENT = TWriteMultiRegisterFuture<uint8_t, IODIR, IPOL, GPPU>;
        public:
            ConfigureGPIOFuture(uint8_t direction, uint8_t pullup = 0, uint8_t polarity = 0)
                :   PARENT{direction, polarity, pullup} {}
        };
 
        int configure_gpio(ConfigureGPIOFuture& future)
        {
            return this->async_multi_write(future);
        }
 
        class ConfigureInterruptsFuture : public TWriteMultiRegisterFuture<uint8_t, GPINTEN, DEFVAL, INTCON>
        {
            using PARENT = TWriteMultiRegisterFuture<uint8_t, GPINTEN, DEFVAL, INTCON>;
        public:
            ConfigureInterruptsFuture(uint8_t int_pins, uint8_t ref = 0, uint8_t compare_ref = 0)
                :   PARENT{int_pins, ref, compare_ref} {}
        };
 
        int configure_interrupts(ConfigureInterruptsFuture& future)
        {
            return this->async_multi_write(future);
        }
 
        using SetValuesFuture = TWriteRegisterFuture<GPIO>;
 
        int values(SetValuesFuture& future)
        {
            return this->async_write(future);
        }
 
        using GetValuesFuture = TReadRegisterFuture<GPIO>;
 
        int values(GetValuesFuture& future)
        {
            return this->async_read(future);
        }
 
        using InterruptFlagsFuture = TReadRegisterFuture<INTF>;
 
        int interrupt_flags(InterruptFlagsFuture& future)
        {
            return this->async_read(future);
        }
 
        using CapturedValuesFuture = TReadRegisterFuture<INTCAP>;
 
        int captured_values(CapturedValuesFuture& future)
        {
            return this->async_read(future);
        }
 
        // Synchronous API
        //=================
        bool begin(InterruptPolarity interrupt_polarity = InterruptPolarity::ACTIVE_HIGH)
        {
            return this->template sync_write<BeginFuture, InterruptPolarity>(interrupt_polarity);
        }
 
        bool configure_gpio(uint8_t direction, uint8_t pullup = 0, uint8_t polarity = 0)
        {
            ConfigureGPIOFuture future{direction, pullup, polarity};
            if (configure_gpio(future) != 0) return false;
            return (future.await() == future::FutureStatus::READY);
        }
 
        bool configure_interrupts(uint8_t int_pins, uint8_t ref = 0, uint8_t compare_ref = 0)
        {
            ConfigureInterruptsFuture future{int_pins, ref, compare_ref};
            if (configure_interrupts(future) != 0) return false;
            return (future.await() == future::FutureStatus::READY);
        }
 
        bool values(uint8_t value)
        {
            return this->template sync_write<SetValuesFuture>(value);
        }
 
        uint8_t values()
        {
            return get_value<GetValuesFuture>();
        }
 
        uint8_t interrupt_flags()
        {
            return get_value<InterruptFlagsFuture>();
        }
 
        uint8_t captured_values()
        {
            return get_value<CapturedValuesFuture>();
        }
 
    private:
        template<typename F> uint8_t get_value()
        {
            uint8_t value = 0;
            this->template sync_read<F>(value);
            return value;
        }
 
        i2c::I2CLightCommand write_stop(uint8_t byte_count = 0) const
        {
            return this->write(byte_count, false, true);
        }
    };
}
 
#endif /* MCP23008_H */