IoExpanderAW9523.hpp

Go to the documentation of this file.

 
#pragma once
 
#include "../SensorBuildOpt.h"
#if !SENSORLIB_EXCLUDE_IO_EXPANDER_AW9523
 
#include "platform/comm/I2CDeviceNoHal.hpp"
#include "IoExpanderBase.hpp"
 
static constexpr uint8_t AW9523_UNKNOWN_ADDRESS = 0xFF;
 
static constexpr uint8_t AW9523_SLAVE_ADDRESS0 = 0x58;
static constexpr uint8_t AW9523_SLAVE_ADDRESS1 = 0x59;
static constexpr uint8_t AW9523_SLAVE_ADDRESS2 = 0x5A;
static constexpr uint8_t AW9523_SLAVE_ADDRESS3 = 0x5B;
 
static constexpr uint8_t AW9523_DEFAULT_ADDRESS = AW9523_SLAVE_ADDRESS0;
 
class IoExpanderAW9523 : public IoExpanderBase, public I2CDeviceNoHal
{
public:
    enum Port : uint16_t {
        PORT0 = 0x00FF,
        PORT1 = 0xFF00,
        PORT_ALL = 0xFFFF
    };
 
    enum class LedCurrentRange : uint8_t {
        FULL = 0,
        THREE_QUARTERS = 1,
        HALF = 2,
        QUARTER = 3
    };
 
    IoExpanderAW9523() : IoExpanderBase(AW9523_PINS_COUNT) {}
    ~IoExpanderAW9523() = default;
 
    void digitalWritePort(uint16_t mask, uint16_t values) override
    {
        if (!_outputStates) {
            SENSORLIB_LOG_E("Output states array not initialized");
            return;
        }
 
        const uint8_t lowMask = mask & 0xFF;
        const uint8_t highMask = (mask >> 8) & 0xFF;
        bool lowWritten = false;
        bool highWritten = false;
 
        if (lowMask) {
            lowWritten = updateMaskedRegister(AW9523_REG_OUTPUT0, lowMask, values & 0xFF);
        }
        if (highMask) {
            highWritten = updateMaskedRegister(AW9523_REG_OUTPUT1, highMask, (values >> 8) & 0xFF);
        }
 
        for (uint8_t pin = 0; pin < AW9523_PINS_COUNT; ++pin) {
            const bool portWritten = pin < 8 ? lowWritten : highWritten;
            if (portWritten && (mask & (1UL << pin))) {
                _outputStates[pin] = (values >> pin) & 1;
            }
        }
    }
 
    uint16_t digitalReadPort() override
    {
        const int port0 = readReg(AW9523_REG_INPUT0);
        const int port1 = readReg(AW9523_REG_INPUT1);
        if (port0 < 0 || port1 < 0) {
            SENSORLIB_LOG_E("Failed to read AW9523 input ports");
            return 0;
        }
        return (static_cast<uint16_t>(port1) << 8) | static_cast<uint8_t>(port0);
    }
 
    bool setPort0PushPull(bool pushPull)
    {
        const int control = readReg(AW9523_REG_GLOBAL_CONTROL);
        if (control < 0) {
            return false;
        }
        const uint8_t value = (control & AW9523_GLOBAL_CURRENT_MASK) |
                              (pushPull ? AW9523_GLOBAL_PUSH_PULL : 0);
        return writeReg(AW9523_REG_GLOBAL_CONTROL, value) >= 0;
    }
 
    bool setLedCurrentRange(LedCurrentRange range)
    {
        const uint8_t rangeValue = static_cast<uint8_t>(range);
        if (rangeValue > static_cast<uint8_t>(LedCurrentRange::QUARTER)) {
            SENSORLIB_LOG_E("Invalid AW9523 LED current range");
            return false;
        }
 
        const int control = readReg(AW9523_REG_GLOBAL_CONTROL);
        if (control < 0) {
            return false;
        }
        const uint8_t value = (control & AW9523_GLOBAL_PUSH_PULL) | rangeValue;
        return writeReg(AW9523_REG_GLOBAL_CONTROL, value) >= 0;
    }
 
    bool setLedMode(uint8_t pin, bool enable = true)
    {
        if (!isValidPin(pin)) {
            return false;
        }
        return setLedModes(static_cast<uint16_t>(1UL << pin), enable);
    }
 
    bool setLedModes(uint16_t pinMask, bool enable = true)
    {
        const uint8_t lowMask = pinMask & 0xFF;
        const uint8_t highMask = (pinMask >> 8) & 0xFF;
 
        // LED channels are outputs. Configure direction before changing mode.
        if (enable && !setDirections(pinMask, OUTPUT)) {
            return false;
        }
        if (lowMask && !updateMaskedRegister(AW9523_REG_LED_MODE0, lowMask, enable ? 0 : lowMask)) {
            return false;
        }
        if (highMask && !updateMaskedRegister(AW9523_REG_LED_MODE1, highMask, enable ? 0 : highMask)) {
            return false;
        }
        return true;
    }
 
    bool analogWrite(uint8_t pin, uint8_t value)
    {
        if (!isValidPin(pin)) {
            return false;
        }
        return writeReg(ledCurrentRegister(pin), value) >= 0;
    }
 
    bool enableInterrupt(uint8_t pin, bool enable = true)
    {
        if (!isValidPin(pin)) {
            return false;
        }
        return enableInterrupts(static_cast<uint16_t>(1UL << pin), enable);
    }
 
    bool enableInterrupts(uint16_t pinMask, bool enable = true)
    {
        const uint8_t lowMask = pinMask & 0xFF;
        const uint8_t highMask = (pinMask >> 8) & 0xFF;
        if (lowMask && !updateMaskedRegister(AW9523_REG_INTERRUPT0, lowMask, enable ? 0 : lowMask)) {
            return false;
        }
        if (highMask && !updateMaskedRegister(AW9523_REG_INTERRUPT1, highMask, enable ? 0 : highMask)) {
            return false;
        }
        return true;
    }
 
    bool softwareReset()
    {
        if (writeReg(AW9523_REG_SOFTWARE_RESET, 0x00) < 0) {
            return false;
        }
        return syncGpioState();
    }
 
protected:
    void pinModeImpl(uint8_t pin, uint8_t mode) override
    {
        const uint8_t bit = pin % 8;
        const uint8_t modeReg = pin < 8 ? AW9523_REG_LED_MODE0 : AW9523_REG_LED_MODE1;
        const uint8_t configReg = pin < 8 ? AW9523_REG_CONFIG0 : AW9523_REG_CONFIG1;
 
        // A digital pin operation always selects GPIO mode.
        if (!updateMaskedRegister(modeReg, 1U << bit, 1U << bit)) {
            SENSORLIB_LOG_E("Failed to select AW9523 GPIO mode for pin %u", pin);
            return;
        }
        if (!updateMaskedRegister(configReg, 1U << bit, mode == INPUT ? 1U << bit : 0)) {
            SENSORLIB_LOG_E("Failed to configure AW9523 pin %u", pin);
        }
    }
 
    void configPinsImpl(uint16_t pinMask, uint8_t mode) override
    {
        const uint8_t lowMask = pinMask & 0xFF;
        const uint8_t highMask = (pinMask >> 8) & 0xFF;
 
        // A digital pin operation always selects GPIO mode.
        if (lowMask && !updateMaskedRegister(AW9523_REG_LED_MODE0, lowMask, lowMask)) {
            SENSORLIB_LOG_E("Failed to select AW9523 P0 GPIO mode");
            return;
        }
        if (highMask && !updateMaskedRegister(AW9523_REG_LED_MODE1, highMask, highMask)) {
            SENSORLIB_LOG_E("Failed to select AW9523 P1 GPIO mode");
            return;
        }
        if (!setDirections(pinMask, mode)) {
            SENSORLIB_LOG_E("Failed to configure AW9523 pin directions");
        }
    }
 
    void digitalWriteImpl(uint8_t pin, bool value) override
    {
        const uint8_t reg = pin < 8 ? AW9523_REG_OUTPUT0 : AW9523_REG_OUTPUT1;
        const uint8_t bitMask = 1U << (pin % 8);
        if (!updateMaskedRegister(reg, bitMask, value ? bitMask : 0)) {
            SENSORLIB_LOG_E("Failed to write AW9523 pin %u", pin);
        }
    }
 
    bool digitalReadImpl(uint8_t pin) override
    {
        const uint8_t reg = pin < 8 ? AW9523_REG_INPUT0 : AW9523_REG_INPUT1;
        const int value = readReg(reg);
        if (value < 0) {
            SENSORLIB_LOG_E("Failed to read AW9523 pin %u", pin);
            return false;
        }
        return (value >> (pin % 8)) & 1;
    }
 
    bool initImpl(uint8_t address) override
    {
        if (address == AW9523_UNKNOWN_ADDRESS) {
            for (uint8_t candidate = AW9523_SLAVE_ADDRESS0; candidate <= AW9523_SLAVE_ADDRESS3; ++candidate) {
                setAddress(candidate);
                if (readReg(AW9523_REG_CHIP_ID) == AW9523_CHIP_ID) {
                    _addr = candidate;
                    SENSORLIB_LOG_D("Found AW9523 at address 0x%" PRIx8, candidate);
                    return syncGpioState();
                }
            }
            SENSORLIB_LOG_E("Failed to find AW9523");
            return false;
        }
 
        if (address < AW9523_SLAVE_ADDRESS0 || address > AW9523_SLAVE_ADDRESS3) {
            SENSORLIB_LOG_E("Invalid AW9523 address 0x%" PRIx8, address);
            return false;
        }
        if (readReg(AW9523_REG_CHIP_ID) != AW9523_CHIP_ID) {
            SENSORLIB_LOG_E("AW9523 chip ID mismatch");
            return false;
        }
        return syncGpioState();
    }
 
private:
    bool isValidPin(uint8_t pin) const
    {
        if (pin >= AW9523_PINS_COUNT) {
            SENSORLIB_LOG_E("Invalid pin number, pin range is 0-%u", AW9523_PINS_COUNT - 1);
            return false;
        }
        return true;
    }
 
    bool updateMaskedRegister(uint8_t reg, uint8_t mask, uint8_t value)
    {
        const int current = readReg(reg);
        if (current < 0) {
            return false;
        }
        const uint8_t updated = (static_cast<uint8_t>(current) & ~mask) | (value & mask);
        return updated == static_cast<uint8_t>(current) || writeReg(reg, updated) >= 0;
    }
 
    bool setDirections(uint16_t pinMask, uint8_t mode)
    {
        if (!_pinModes) {
            SENSORLIB_LOG_E("Pin modes array not initialized");
            return false;
        }
        const uint8_t lowMask = pinMask & 0xFF;
        const uint8_t highMask = (pinMask >> 8) & 0xFF;
        if (lowMask && !updateMaskedRegister(AW9523_REG_CONFIG0, lowMask, mode == INPUT ? lowMask : 0)) {
            return false;
        }
        if (highMask && !updateMaskedRegister(AW9523_REG_CONFIG1, highMask, mode == INPUT ? highMask : 0)) {
            return false;
        }
        for (uint8_t pin = 0; pin < AW9523_PINS_COUNT; ++pin) {
            if (pinMask & (1UL << pin)) {
                _pinModes[pin] = mode;
            }
        }
        return true;
    }
 
    bool syncGpioState()
    {
        if (!_pinModes || !_outputStates) {
            SENSORLIB_LOG_E("AW9523 state arrays not initialized");
            return false;
        }
        const int config0 = readReg(AW9523_REG_CONFIG0);
        const int config1 = readReg(AW9523_REG_CONFIG1);
        const int output0 = readReg(AW9523_REG_OUTPUT0);
        const int output1 = readReg(AW9523_REG_OUTPUT1);
        if (config0 < 0 || config1 < 0 || output0 < 0 || output1 < 0) {
            SENSORLIB_LOG_E("Failed to synchronize AW9523 GPIO state");
            return false;
        }
 
        const uint16_t configs = (static_cast<uint16_t>(config1) << 8) | static_cast<uint8_t>(config0);
        const uint16_t outputs = (static_cast<uint16_t>(output1) << 8) | static_cast<uint8_t>(output0);
        for (uint8_t pin = 0; pin < AW9523_PINS_COUNT; ++pin) {
            _pinModes[pin] = (configs & (1UL << pin)) ? INPUT : OUTPUT;
            _outputStates[pin] = (outputs >> pin) & 1;
        }
        return true;
    }
 
    static uint8_t ledCurrentRegister(uint8_t pin)
    {
        if (pin < 8) {
            return AW9523_REG_DIM_P0_BASE + pin;
        }
        if (pin < 12) {
            return AW9523_REG_DIM_P1_LOW_BASE + pin - 8;
        }
        return AW9523_REG_DIM_P1_HIGH_BASE + pin - 12;
    }
 
    static constexpr uint8_t AW9523_PINS_COUNT = 16;
    static constexpr uint8_t AW9523_CHIP_ID = 0x23;
 
    static constexpr uint8_t AW9523_REG_INPUT0 = 0x00;
    static constexpr uint8_t AW9523_REG_INPUT1 = 0x01;
    static constexpr uint8_t AW9523_REG_OUTPUT0 = 0x02;
    static constexpr uint8_t AW9523_REG_OUTPUT1 = 0x03;
    static constexpr uint8_t AW9523_REG_CONFIG0 = 0x04;
    static constexpr uint8_t AW9523_REG_CONFIG1 = 0x05;
    static constexpr uint8_t AW9523_REG_INTERRUPT0 = 0x06;
    static constexpr uint8_t AW9523_REG_INTERRUPT1 = 0x07;
    static constexpr uint8_t AW9523_REG_CHIP_ID = 0x10;
    static constexpr uint8_t AW9523_REG_GLOBAL_CONTROL = 0x11;
    static constexpr uint8_t AW9523_REG_LED_MODE0 = 0x12;
    static constexpr uint8_t AW9523_REG_LED_MODE1 = 0x13;
    static constexpr uint8_t AW9523_REG_DIM_P1_LOW_BASE = 0x20;
    static constexpr uint8_t AW9523_REG_DIM_P0_BASE = 0x24;
    static constexpr uint8_t AW9523_REG_DIM_P1_HIGH_BASE = 0x2C;
    static constexpr uint8_t AW9523_REG_SOFTWARE_RESET = 0x7F;
 
    static constexpr uint8_t AW9523_GLOBAL_CURRENT_MASK = 0x03;
    static constexpr uint8_t AW9523_GLOBAL_PUSH_PULL = 0x10;
};
 
#endif