IoExpanderBase.hpp

Go to the documentation of this file.

 
#pragma once
 
#include "SensorPlatform.hpp"
 
class IoExpanderBase
{
public:
    IoExpanderBase(uint8_t pinCount) :  _pinCount(pinCount)
    {
        _pinModes = std::unique_ptr<uint8_t[]>(new (std::nothrow) uint8_t[pinCount]());
        _outputStates = std::unique_ptr<bool[]>(new (std::nothrow) bool[pinCount]());
        if (!_pinModes || !_outputStates) {
            _pinCount = 0;
        }
    }
 
    virtual ~IoExpanderBase() = default;
 
    virtual void deinit()
    {
    }
 
    void configPins(uint16_t pinMask, uint8_t mode)
    {
        if (_pinModes == nullptr) {
            SENSORLIB_LOG_E("Pin modes array not initialized");
            return;
        }
        if (mode != INPUT && mode != OUTPUT) {
            SENSORLIB_LOG_E("Invalid pin mode");
            return;
        }
        configPinsImpl(pinMask, mode);
    }
 
 
    void pinMode(uint8_t pin, uint8_t mode)
    {
        if (pin >= _pinCount) {
            SENSORLIB_LOG_E("Invalid pin number");
            return;
        }
        if (_pinModes == nullptr) {
            SENSORLIB_LOG_E("Pin modes array not initialized");
            return;
        }
        if (mode != INPUT && mode != OUTPUT) {
            SENSORLIB_LOG_E("Invalid pin mode");
            return;
        }
 
        _pinModes[pin] = mode;
        pinModeImpl(pin, mode);
    }
 
    void digitalWrite(uint8_t pin, bool value)
    {
        if (pin >= _pinCount) {
            SENSORLIB_LOG_E("Invalid pin number");
            return;
        }
        if (_pinModes == nullptr) {
            SENSORLIB_LOG_E("Pin modes array not initialized");
            return;
        }
        if (_outputStates == nullptr) {
            SENSORLIB_LOG_E("Output states array not initialized");
            return;
        }
        if (_pinModes[pin] != OUTPUT) {
            SENSORLIB_LOG_E("Pin %d is not configured as OUTPUT", pin);
            return;
        }
 
        _outputStates[pin] = value;
        digitalWriteImpl(pin, value);
    }
 
    bool digitalRead(uint8_t pin)
    {
        if (pin >= _pinCount) {
            SENSORLIB_LOG_E("Invalid pin number");
            return false;
        }
        if (_pinModes == nullptr) {
            SENSORLIB_LOG_E("Pin modes array not initialized");
            return false;
        }
        if (_pinModes[pin] != INPUT) {
            SENSORLIB_LOG_E("Pin %d is not configured as INPUT", pin);
            return false;
        }
 
        return digitalReadImpl(pin);
    }
 
    void digitalToggle(uint8_t pin)
    {
        if (!_pinModes || !_outputStates) {
            SENSORLIB_LOG_E("Expander not properly initialized");
            return;
        }
        if (_pinModes[pin] != OUTPUT) {
            SENSORLIB_LOG_E("Pin %d is not configured as OUTPUT", pin);
            return;
        }
        int state = 1 - _outputStates[pin];
        digitalWrite(pin, state);
    }
 
    virtual void digitalWritePort(uint16_t mask, uint16_t values)
    {
        for (uint8_t i = 0; i < _pinCount; i++) {
            if (mask & (1UL << i)) {
                digitalWrite(i, (values >> i) & 1);
            }
        }
    }
 
    virtual uint16_t digitalReadPort()
    {
        uint16_t result = 0;
        if (!_pinModes || !_outputStates) {
            SENSORLIB_LOG_E("Expander not properly initialized");
            return 0;
        }
        for (uint8_t i = 0; i < _pinCount; i++) {
            if (_pinModes[i] == INPUT) {
                result |= (digitalRead(i) ? (1UL << i) : 0);
            }
        }
        return result;
    }
 
    uint8_t pinCount() const
    {
        return _pinCount;
    }
 
 
    uint16_t pinToMask(uint8_t pin) const
    {
        if (pin >= _pinCount) {
            SENSORLIB_LOG_E("Invalid pin number");
            return 0;
        }
        return (1UL << pin);
    }
 
protected:
    virtual bool initImpl(uint8_t param) = 0;
 
    virtual void configPinsImpl(uint16_t pinMask, uint8_t mode) = 0;
 
    virtual void pinModeImpl(uint8_t pin, uint8_t mode) = 0;
 
    virtual void digitalWriteImpl(uint8_t pin, bool value) = 0;
 
    virtual bool digitalReadImpl(uint8_t pin) = 0;
 
    uint8_t _pinCount;                      
    std::unique_ptr<uint8_t[]> _pinModes;   
    std::unique_ptr<bool[]> _outputStates;  
};