IoExpanderPCA9570.hpp

Go to the documentation of this file.

 
#pragma once
 
#include "../SensorBuildOpt.h"
#if !SENSORLIB_EXCLUDE_IO_EXPANDER_PCA9570
 
#include "platform/comm/I2CDeviceNoHal.hpp"
#include "IoExpanderBase.hpp"
 
static constexpr uint8_t  PCA9570_SLAVE_ADDRESS = (0x24);
 
class IoExpanderPCA9570 : public IoExpanderBase, public I2CDeviceNoHal
{
public:
 
    enum Port {
        PORT_ALL = 0x0F
    };
 
    IoExpanderPCA9570() : IoExpanderBase(PCA9570_PINS_COUNT) {}
 
    ~IoExpanderPCA9570() = default;
 
    void digitalWritePort(uint16_t mask, uint16_t values) override
    {
        // Read current output state
        uint8_t current;
        if (readBuff(&current, 1) < 0) {
            SENSORLIB_LOG_E("Failed to read current output state");
            return;
        }
 
        // Update only the bits specified by mask (mask is 16-bit, but only low 4 bits used)
        uint8_t newVal = current;
        for (uint8_t i = 0; i < PCA9570_PINS_COUNT; i++) {
            if (mask & (1UL << i)) {
                if ((values >> i) & 1) {
                    newVal |= (1 << i);
                } else {
                    newVal &= ~(1 << i);
                }
            }
        }
 
        // Write back the new value
        if (writeRegBuff(newVal, nullptr, 0) < 0) {
            SENSORLIB_LOG_E("Failed to write output state");
            return;
        }
 
        // Update cache
        for (uint8_t i = 0; i < PCA9570_PINS_COUNT; i++) {
            if (mask & (1UL << i)) {
                _outputStates[i] = (values >> i) & 1;
            }
        }
    }
 
    uint16_t digitalReadPort() override
    {
        uint8_t state;
        if (readBuff(&state, 1) < 0) {
            SENSORLIB_LOG_E("Failed to read output state");
            return 0;
        }
        return state & 0x0F;  // Only low 4 bits are valid
    }
 
protected:
    void pinModeImpl(uint8_t pin, uint8_t mode) override
    {
        if (mode != OUTPUT) {
            SENSORLIB_LOG_E("Invalid pin mode, only OUTPUT is supported");
            return;
        }
        // No hardware configuration needed; all pins are fixed as outputs.
    }
 
    void configPinsImpl(uint16_t pinMask, uint8_t mode) override
    {
        // PCA9570 only supports output mode; ignore any input request
        if (mode != OUTPUT) {
            SENSORLIB_LOG_E("PCA9570 only supports OUTPUT mode");
            return;
        }
        // No hardware configuration needed; all pins are fixed as outputs.
        // Update the internal cache for all pins specified in the mask.
        for (uint8_t i = 0; i < PCA9570_PINS_COUNT; i++) {
            if (pinMask & (1UL << i)) {
                _pinModes[i] = OUTPUT;
            }
        }
    }
 
    void digitalWriteImpl(uint8_t pin, bool value) override
    {
        uint8_t current = digitalReadPort();  // Read current output state
        if (value) {
            current |= (1 << pin);
        } else {
            current &= ~(1 << pin);
        }
        writeRegBuff(current, nullptr, 0);  // Write back to output register
    }
 
    bool digitalReadImpl(uint8_t pin) override
    {
        uint8_t value = digitalReadPort();
        return (value >> pin) & 1;
    }
 
    bool initImpl(uint8_t param) override
    {
        uint8_t buffer[3] = {};
        if (readRegBuff(PCA9570_DEVICE_ID_READ, buffer, 3) < 0 ) {
            SENSORLIB_LOG_E("Failed to read device ID");
            return false;
        }
        uint16_t manufacturerID, partID;
        uint8_t revision;
        manufacturerID = (buffer[0] << 4) | ((buffer[1] >> 4) & 0x0F);  // 12‑bit manufacturer ID
        partID         = ((buffer[1] & 0x0F) << 5) | ((buffer[2] >> 3) & 0x1F); // 9‑bit part ID
        revision       = buffer[2] & 0x07;                               // 3‑bit revision
        (void)manufacturerID;
        (void)partID;
        (void)revision;
        SENSORLIB_LOG_D("ManufacturerID:0x%" PRIx16 ", PartID:0x%" PRIx16 ", Revision:0x%" PRIx8,
                        manufacturerID, partID, revision);
        return true;
    }
 
private:
    // Special addresses and commands (refer to PCA9570 datasheet)
    static constexpr uint8_t PCA9570_GENERAL_CALL_ADDR = 0x00;   
    static constexpr uint8_t PCA9570_DEVICE_ID_WRITE   = 0xF8;   
    static constexpr uint8_t PCA9570_DEVICE_ID_READ    = 0xF9;   
    static constexpr uint8_t PCA9570_SOFT_RESET_CMD    = 0x06;   
    static constexpr uint8_t PCA9570_PINS_COUNT        = 4;      
};
 
#endif