expander/IoExpanderXL9555.hpp

Go to the documentation of this file.

 
#pragma once
 
#include "../SensorBuildOpt.h"
#if !SENSORLIB_EXCLUDE_IO_EXPANDER_XL9555
 
#include "platform/comm/I2CDeviceNoHal.hpp"
#include "IoExpanderBase.hpp"
 
static constexpr uint8_t  XL9555_UNKNOWN_ADDRESS = (0xFF);
 
static constexpr uint8_t  XL9555_SLAVE_ADDRESS0 = (0x20);
 
static constexpr uint8_t  XL9555_SLAVE_ADDRESS1 = (0x21);
 
static constexpr uint8_t  XL9555_SLAVE_ADDRESS2 = (0x22);
 
static constexpr uint8_t  XL9555_SLAVE_ADDRESS3 = (0x23);
 
static constexpr uint8_t  XL9555_SLAVE_ADDRESS4 = (0x24);
 
static constexpr uint8_t  XL9555_SLAVE_ADDRESS5 = (0x25);
 
static constexpr uint8_t  XL9555_SLAVE_ADDRESS6 = (0x26);
 
static constexpr uint8_t  XL9555_SLAVE_ADDRESS7 = (0x27);
 
 
 
#ifdef __GNUC__
#define DEPRECATED_ATTR __attribute__((deprecated("use XL9555_UNKNOWN_ADDRESS instead")))
#else
#define DEPRECATED_ATTR
#endif
 
static const int XL9555_UNKOWN_ADDRESS DEPRECATED_ATTR = XL9555_UNKNOWN_ADDRESS;
 
 
 
class IoExpanderXL9555 : public IoExpanderBase, public I2CDeviceNoHal
{
public:
    enum  Port {
        PORT0 = 0x00FF,
        PORT1 = 0xFF00,
        PORT_ALL = 0xFFFF
    };
 
    enum IoExpanderGPIO {
        IO0  __attribute__((deprecated("Use integer pin numbers (0-15) directly instead."))),
        IO1  __attribute__((deprecated("Use integer pin numbers (0-15) directly instead."))),
        IO2  __attribute__((deprecated("Use integer pin numbers (0-15) directly instead."))),
        IO3  __attribute__((deprecated("Use integer pin numbers (0-15) directly instead."))),
        IO4  __attribute__((deprecated("Use integer pin numbers (0-15) directly instead."))),
        IO5  __attribute__((deprecated("Use integer pin numbers (0-15) directly instead."))),
        IO6  __attribute__((deprecated("Use integer pin numbers (0-15) directly instead."))),
        IO7  __attribute__((deprecated("Use integer pin numbers (0-15) directly instead."))),
        IO8  __attribute__((deprecated("Use integer pin numbers (0-15) directly instead."))),
        IO9  __attribute__((deprecated("Use integer pin numbers (0-15) directly instead."))),
        IO10 __attribute__((deprecated("Use integer pin numbers (0-15) directly instead."))),
        IO11 __attribute__((deprecated("Use integer pin numbers (0-15) directly instead."))),
        IO12 __attribute__((deprecated("Use integer pin numbers (0-15) directly instead."))),
        IO13 __attribute__((deprecated("Use integer pin numbers (0-15) directly instead."))),
        IO14 __attribute__((deprecated("Use integer pin numbers (0-15) directly instead."))),
        IO15 __attribute__((deprecated("Use integer pin numbers (0-15) directly instead."))),
    };
 
    IoExpanderXL9555() : IoExpanderBase(XL9555_PINS_COUNT) {}
 
    ~IoExpanderXL9555() = default;
 
    void digitalWritePort(uint16_t mask, uint16_t values) override
    {
        uint8_t lowByte = values & 0xFF;
        uint8_t highByte = (values >> 8) & 0xFF;
        if (!_outputStates) {
            SENSORLIB_LOG_E("Output states array not initialized");
            return;
        }
        if (mask & 0x00FF) {
            writeReg(XL9555_CTRL_OUTP0, lowByte);
        }
        if (mask & 0xFF00) {
            writeReg(XL9555_CTRL_OUTP1, highByte);
        }
        for (uint8_t i = 0; i < XL9555_PINS_COUNT; i++) {
            if (mask & (1UL << i)) {
                _outputStates[i] = (values >> i) & 1;
            }
        }
    }
 
    uint16_t digitalReadPort() override
    {
        uint16_t result = 0;
        uint8_t lowByte = readReg(XL9555_CTRL_INP0);
        uint8_t highByte = readReg(XL9555_CTRL_INP1);
        result = (highByte << 8) | lowByte;
        return result;
    }
 
protected:
    void pinModeImpl(uint8_t pin, uint8_t mode) override
    {
        if (pin >= XL9555_PINS_COUNT) {
            SENSORLIB_LOG_E("Invalid pin number, pin range is 0-%d", XL9555_PINS_COUNT - 1);
            return;
        }
        uint8_t reg = (pin < 8) ? XL9555_CTRL_CFG0 : XL9555_CTRL_CFG1;
        uint8_t bit = pin % 8;
        if (mode == OUTPUT) {
            clrRegBit(reg, bit);
        } else {
            setRegBit(reg, bit);
        }
    }
 
 
    void configPinsImpl(uint16_t pinMask, uint8_t mode) override
    {
        uint8_t lowMask  = pinMask & 0xFF;          // Bits for Port 0 (pins 0‑7)
        uint8_t highMask = (pinMask >> 8) & 0xFF;   // Bits for Port 1 (pins 8‑15)
 
        // --- Configure Port 0 (CFG0) ---
        if (lowMask) {
            // Read current configuration
            uint8_t cur = readReg(XL9555_CTRL_CFG0);
            // Modify only the bits specified in lowMask
            if (mode == INPUT) {
                cur |= lowMask;          // Set bits to 1 for INPUT
            } else {
                cur &= ~lowMask;         // Clear bits to 0 for OUTPUT
            }
            // Write back updated value
            writeReg(XL9555_CTRL_CFG0, cur);
 
            // Update the internal pin mode cache for Port 0 pins
            for (uint8_t i = 0; i < 8; i++) {
                if (lowMask & (1 << i)) {
                    _pinModes[i] = mode;
                }
            }
        }
 
        // --- Configure Port 1 (CFG1) ---
        if (highMask) {
            uint8_t cur = readReg(XL9555_CTRL_CFG1);
            if (mode == INPUT) {
                cur |= highMask;
            } else {
                cur &= ~highMask;
            }
            writeReg(XL9555_CTRL_CFG1, cur);
 
            // Update the internal pin mode cache for Port 1 pins
            for (uint8_t i = 0; i < 8; i++) {
                if (highMask & (1 << i)) {
                    _pinModes[i + 8] = mode;
                }
            }
        }
    }
 
    void digitalWriteImpl(uint8_t pin, bool value) override
    {
        if (pin >= XL9555_PINS_COUNT) {
            SENSORLIB_LOG_E("Invalid pin number, pin range is 0-%d", XL9555_PINS_COUNT - 1);
            return;
        }
        uint8_t reg = (pin < 8) ? XL9555_CTRL_OUTP0 : XL9555_CTRL_OUTP1;
        uint8_t bit = pin % 8;
        if (value) {
            setRegBit(reg, bit);
        } else {
            clrRegBit(reg, bit);
        }
    }
 
    bool digitalReadImpl(uint8_t pin) override
    {
        if (pin >= XL9555_PINS_COUNT) {
            SENSORLIB_LOG_E("Invalid pin number, pin range is 0-%d", XL9555_PINS_COUNT - 1);
            return false;
        }
        if (!ensureValid()) {
            return false;
        }
        uint8_t reg = (pin < 8) ? XL9555_CTRL_INP0 : XL9555_CTRL_INP1;
        uint8_t bit = pin % 8;
        uint8_t value = readReg(reg);
        return (value >> bit) & 1;
    }
 
    bool initImpl(uint8_t param) override
    {
        if (param == XL9555_UNKNOWN_ADDRESS) {
            SENSORLIB_LOG_D("Try to automatically discover the device");
            for (uint8_t address = XL9555_SLAVE_ADDRESS0; address <= XL9555_SLAVE_ADDRESS7; ++address) {
                setAddress(address);
                SENSORLIB_LOG_D("Try to use 0x%" PRIx8 " address.", address);
                if (readReg(XL9555_CTRL_INP0) >= 0) {
                    SENSORLIB_LOG_D("Found the xl9555 chip address is 0x%" PRIx8, address);
                    return true;
                }
            }
            SENSORLIB_LOG_E("No found xl9555 chip ...");
            return false;
        }
        if (readReg(XL9555_CTRL_INP0) < 0 ) {
            return false;
        }
        return true;
    }
 
private:
    // Register addresses (as per XL9555 datasheet)
    static constexpr uint8_t XL9555_CTRL_INP0   = (0x00);  
    static constexpr uint8_t XL9555_CTRL_INP1   = (0x01);  
    static constexpr uint8_t XL9555_CTRL_OUTP0  = (0x02);  
    static constexpr uint8_t XL9555_CTRL_OUTP1  = (0x03);  
    static constexpr uint8_t XL9555_CTRL_PIP0   = (0x04);  
    static constexpr uint8_t XL9555_CTRL_PIP1   = (0x05);  
    static constexpr uint8_t XL9555_CTRL_CFG0   = (0x06);  
    static constexpr uint8_t XL9555_CTRL_CFG1   = (0x07);  
    static constexpr uint8_t XL9555_PINS_COUNT  = 16;      
};
 
#endif