SensorCommBase.hpp

Go to the documentation of this file.

 
#pragma once
#include "SensorLib.h"
#include <memory>
#include "SensorErrorMixin.hpp"
 
//--------------------------------------------------------------------------
// C++11 compatibility: provide std::make_unique if not yet in the standard.
//--------------------------------------------------------------------------
#if __cplusplus == 201103L
namespace std
{
template<typename T, typename... Args>
std::unique_ptr<T> make_unique(Args &&... args)
{
    return std::unique_ptr<T>(new T(std::forward<Args>(args)...));
}
}
#endif
 
//--------------------------------------------------------------------------
// Compile‑time array size utility
//--------------------------------------------------------------------------
template <typename T, size_t N>
constexpr size_t arraySize(const T (&arr)[N])
{
    return N;
}
 
//============================================================================
// Communication parameter base classes
//============================================================================
 
class CommParamsBase
{
public:
    virtual ~CommParamsBase() = default;
};
 
//--------------------------------------------------------------------------
// I2C specific parameters
//--------------------------------------------------------------------------
class I2CParam : public CommParamsBase
{
public:
    enum I2CParamType {
        I2C_SET_ADDR,            
        I2C_SET_FLAG,            
        I2C_SET_CLOCK,           
        I2C_SET_WRITE_DELAY_US,  
        I2C_SET_READ_DELAY_US,   
    };
 
    I2CParam(I2CParamType type, uint32_t params) : type(type), params(params) {}
 
    uint32_t getParams() const
    {
        return params;
    }
 
    uint8_t getType() const
    {
        return type;
    }
 
protected:
    enum I2CParamType type;   
    uint32_t params;          
};
 
//--------------------------------------------------------------------------
// SPI settings emulation for non‑Arduino environments
//--------------------------------------------------------------------------
#if !defined(ARDUINO)
 
// Standard SPI mode constants (mirror Arduino's definitions)
#define SPI_MODE0 0   
#define SPI_MODE1 1   
#define SPI_MODE2 2   
#define SPI_MODE3 3   
 
#define SPI_LSB 0     
#define SPI_MSB 1     
 
class SPISettings
{
public:
    SPISettings() : clock(1000000), bitOrder(SPI_MSB), dataMode(SPI_MODE0) {}
    SPISettings(uint32_t clock, uint8_t bitOrder, uint8_t dataMode) :
        clock(clock), bitOrder(bitOrder), dataMode(dataMode) {}
 
    uint32_t clock;    
    uint8_t  bitOrder; 
    uint8_t  dataMode; 
};
#endif
 
//--------------------------------------------------------------------------
// SPI specific parameters
//--------------------------------------------------------------------------
class SPIParam : public CommParamsBase
{
private:
    SPISettings setting;   
 
public:
    SPIParam(SPISettings setting) : setting(setting) {}
 
    SPISettings getSetting() const
    {
        return setting;
    }
};
 
//============================================================================
// Abstract sensor communication interface
//============================================================================
// Note: SensorErrorMixin is assumed to be defined elsewhere and provides
//       error handling / status reporting.
 
class SensorCommBase : public SensorErrorMixin
{
public:
    //----------------------------------------------------------------------
    // Initialisation / deinitialisation
    //----------------------------------------------------------------------
    virtual bool init() = 0;
 
    virtual void deinit() = 0;
 
    //----------------------------------------------------------------------
    // Read operations
    //----------------------------------------------------------------------
    virtual int readRegister(const uint8_t reg)
    {
        int err = 0;
        uint8_t value = 0x00;
        err = readRegister(reg, &value, 1);
        if (err < 0) {
            return err; // Propagate read error
        }
        return value;
    }
 
    virtual int readRegister(const uint8_t reg, uint8_t *buf, size_t len) = 0;
 
    virtual int readBuffer(uint8_t *buf, size_t len) = 0;
 
    //----------------------------------------------------------------------
    // Write operations
    //----------------------------------------------------------------------
    virtual int writeRegister(const uint8_t reg, uint8_t val)
    {
        return writeRegister(reg, &val, 1);
    }
 
    virtual int writeRegister(const uint8_t reg, uint8_t *buf, size_t len) = 0;
 
    virtual int writeRegister(const uint8_t reg, uint8_t norVal, uint8_t orVal)
    {
        int val = readRegister(reg);
        if (val < 0) {
            return val; // Propagate read error
        }
        val &= norVal;
        val |= orVal;
        return writeRegister(reg, reinterpret_cast<uint8_t *>(&val), 1);
    }
 
    virtual int writeBuffer(uint8_t *buffer, size_t len) = 0;
 
    //----------------------------------------------------------------------
    // Combined transactions
    //----------------------------------------------------------------------
    virtual int writeThenRead(const uint8_t *write_buffer, size_t write_len,
                              uint8_t *read_buffer, size_t read_len) = 0;
 
    //----------------------------------------------------------------------
    // Bit‑level register manipulation
    //----------------------------------------------------------------------
    virtual bool setRegisterBit(const uint8_t reg, uint8_t bit)
    {
        int value = readRegister(reg);
        if (value < 0)
            return false;
        value |= (1 << bit);
        return writeRegister(reg, reinterpret_cast<uint8_t *>(&value), 1) == 0;
    }
 
    virtual bool clrRegisterBit(const uint8_t reg, uint8_t bit)
    {
        int value = readRegister(reg);
        if (value < 0)
            return false;
        value &= ~(1 << bit);
        return writeRegister(reg, reinterpret_cast<uint8_t *>(&value), 1) == 0;
    }
 
    virtual bool getRegisterBit(const uint8_t reg, uint8_t bit)
    {
        int value = readRegister(reg);
        if (value < 0)
            return false;
        return (value & (1 << bit)) != 0;
    }
 
    virtual int updateBits(uint8_t reg, uint8_t mask, uint8_t value_shifted)
    {
        int cur = readRegister(reg);
        if (cur < 0) return cur; // Propagate read error
        uint8_t newv = (uint8_t(cur) & ~mask) | (value_shifted & mask);
        return writeRegister(reg, newv);
    }
 
    //----------------------------------------------------------------------
    // Parameter configuration
    //----------------------------------------------------------------------
    virtual void setParams(const CommParamsBase &params) = 0;
 
    //----------------------------------------------------------------------
    // Destructor
    //----------------------------------------------------------------------
    virtual ~SensorCommBase() = default;
};
 
//============================================================================
// Hardware abstraction layers
//============================================================================
 
class SensorHalCustom
{
public:
    // Type aliases for callback signatures
    using CustomWrite = void(*)(uint8_t pin, uint8_t level);   
    using CustomRead  = uint8_t(*)(uint8_t pin);               
    using CustomMode  = void(*)(uint8_t pin, uint8_t mode);    
 
    SensorHalCustom() : writeCallback(nullptr), readCallback(nullptr), modeCallback(nullptr) {}
 
    void setCustomWrite(CustomWrite callback)
    {
        writeCallback = callback;
    }
 
    void setCustomRead(CustomRead callback)
    {
        readCallback = callback;
    }
 
    void setCustomMode(CustomMode callback)
    {
        modeCallback = callback;
    }
 
protected:
    CustomWrite writeCallback;  
    CustomRead  readCallback;   
    CustomMode  modeCallback;   
};
 
class SensorHal : public SensorHalCustom
{
public:
    virtual void pinMode(uint8_t pin, uint8_t mode) = 0;
 
    virtual void digitalWrite(uint8_t pin, uint8_t level) = 0;
 
    virtual uint8_t digitalRead(uint8_t pin) = 0;
 
    virtual uint32_t millis() = 0;
 
    virtual void delay(uint32_t ms) = 0;
 
    virtual void delayMicroseconds(uint32_t us) = 0;
};