sfTkIBus.h

Go to the documentation of this file.

 
#pragma once
 
#include "sfToolkit.h"
#include <stddef.h>
 
const sfTkError_t ksfTkErrBusNotInit = ksfTkErrFail * (ksfTkErrBaseBus + 1);
 
const sfTkError_t ksfTkErrBusTimeout = ksfTkErrFail * (ksfTkErrBaseBus + 2);
 
const sfTkError_t ksfTkErrBusNoResponse = ksfTkErrFail * (ksfTkErrBaseBus + 3);
 
const sfTkError_t ksfTkErrBusDataTooLong = ksfTkErrFail * (ksfTkErrBaseBus + 4);
 
const sfTkError_t ksfTkErrBusNullSettings = ksfTkErrFail * (ksfTkErrBaseBus + 5);
 
const sfTkError_t ksfTkErrBusNullBuffer = ksfTkErrFail * (ksfTkErrBaseBus + 6);
 
const sfTkError_t ksfTkErrBusUnderRead = ksfTkErrBaseBus + 7;
 
const sfTkError_t ksfTkErrBusNotEnabled = ksfTkErrBaseBus + 8;
 
class sfTkIBus
{
  public:
    sfTkIBus()
    {
        _byteOrder = sftk_system_byteorder();
    }
 
    virtual sfTkError_t writeRegister(uint8_t *devReg, size_t regLength, const uint8_t *data, size_t length) = 0;
 
    virtual sfTkError_t writeData(uint8_t data)
    {
        return writeRegister(nullptr, 0, &data, sizeof(uint8_t));
    }
 
    sfTkError_t writeUInt8(uint8_t data)
    {
        return writeData(data);
    }
 
    virtual sfTkError_t writeData(uint16_t data)
    {
        // byte swap?
        if (sftk_system_byteorder() != _byteOrder)
            data = sftk_byte_swap(data);
 
        return writeRegister(nullptr, 0, (uint8_t *)&data, sizeof(uint16_t));
    }
 
    sfTkError_t writeUInt16(uint16_t data)
    {
        return writeData(data);
    }
 
    virtual sfTkError_t writeData(uint32_t data)
    {
        // byte swap?
        if (sftk_system_byteorder() != _byteOrder)
            data = sftk_byte_swap(data);
 
        return writeRegister(nullptr, 0, (uint8_t *)&data, sizeof(uint32_t));
    }
 
    sfTkError_t writeUInt32(uint32_t data)
    {
        return writeData(data);
    }
    virtual sfTkError_t writeData(const uint8_t *data, size_t length)
    {
        return writeRegister(nullptr, 0, data, length);
    }
 
    sfTkError_t writeRegister(uint8_t devReg, uint8_t data)
    {
        return writeRegister(&devReg, sizeof(devReg), &data, sizeof(uint8_t));
    }
 
    sfTkError_t writeRegisterUInt8(uint8_t reg, uint8_t data)
    {
        return writeRegister(reg, data);
    }
 
    virtual sfTkError_t writeRegister(uint8_t devReg, const uint16_t data)
    {
        // swap the data?
        uint16_t value = data;
        if (sftk_system_byteorder() != _byteOrder)
            value = sftk_byte_swap(value);
 
        return writeRegister(&devReg, sizeof(devReg), (uint8_t *)&value, sizeof(value));
    }
 
    sfTkError_t writeRegisterUInt16(uint8_t reg, uint16_t data)
    {
        return writeRegister(reg, data);
    }
 
    virtual sfTkError_t writeRegister(uint8_t devReg, const uint32_t data)
    {
        uint32_t value = data;
        // swap the data?
        if (sftk_system_byteorder() != _byteOrder)
            value = sftk_byte_swap(value);
 
        return writeRegister(&devReg, sizeof(devReg), (uint8_t *)&value, sizeof(data));
    }
 
    sfTkError_t writeRegisterUInt32(uint8_t reg, uint32_t data)
    {
        return writeRegister(reg, data);
    }
 
    virtual sfTkError_t writeRegister(uint8_t devReg, const uint8_t *data, size_t length)
    {
        return writeRegister(&devReg, sizeof(devReg), data, length);
    }
 
    virtual sfTkError_t writeRegister(uint16_t devReg, const uint8_t *data, size_t length)
    {
        if (sftk_system_byteorder() != _byteOrder)
            devReg = sftk_byte_swap(devReg);
 
        return writeRegister((uint8_t *)&devReg, sizeof(devReg), data, length);
    }
 
    virtual sfTkError_t writeRegister(uint16_t devReg, const uint8_t data)
    {
        return writeRegister(devReg, &data, 1);
    }
 
    sfTkError_t writeRegisterUInt8(uint16_t reg, const uint8_t data)
    {
        return writeRegister(reg, data);
    }
    virtual sfTkError_t writeRegister(uint16_t devReg, const uint16_t data)
    {
        return writeRegister(devReg, &data, sizeof(data));
    }
 
    sfTkError_t writeRegisterUInt16(uint16_t reg, const uint16_t data)
    {
        return writeRegister(reg, data);
    }
 
    virtual sfTkError_t writeRegister(uint16_t devReg, const uint32_t data)
    {
        uint32_t value = data;
        // do we need to swap the data value? Note the address is swapped in the called writeReg16 method
        if (sftk_system_byteorder() != _byteOrder)
            value = sftk_byte_swap(data);
 
        return writeRegister(devReg, (const uint8_t *)&value, sizeof(uint32_t));
    }
 
    sfTkError_t writeRegisterUInt32(uint16_t reg, const uint32_t data)
    {
        return writeRegister(reg, data);
    }
    virtual sfTkError_t writeRegister(uint16_t devReg, const uint16_t *data, size_t length)
    {
        // if the system byte order is the same as the desired order, just send the buffer
        if (sftk_system_byteorder() == _byteOrder)
            return writeRegister(devReg, (const uint8_t *)data, length * sizeof(uint16_t));
 
        // swap data
        uint16_t data16[length];
 
        for (size_t i = 0; i < length; i++)
            data16[i] = sftk_byte_swap(data[i]);
        return writeRegister(devReg, (const uint8_t *)data16, length * sizeof(uint16_t));
    }
 
    //---------------------------------------------------------------------------
    // Read Methods
    //---------------------------------------------------------------------------
 
    // The method that must be implemented - at a minimum.
    virtual sfTkError_t readRegister(uint8_t *devReg, size_t regLength, uint8_t *data, size_t numBytes,
                                     size_t &readBytes, uint32_t read_delay = 0) = 0;
    virtual sfTkError_t readRegister(uint8_t devReg, uint8_t &data)
    {
        size_t nRead;
        sfTkError_t retVal = readRegister(&devReg, sizeof(devReg), &data, sizeof(data), nRead);
 
        return (retVal == ksfTkErrOk && nRead == sizeof(uint8_t) ? ksfTkErrOk : retVal);
    }
 
    sfTkError_t readRegisterUInt8(uint8_t devReg, uint8_t &data)
    {
        return readRegister(devReg, data);
    }
 
    virtual sfTkError_t readRegister(uint8_t devReg, uint16_t &data)
    {
        size_t nRead;
        sfTkError_t retVal = readRegister(&devReg, sizeof(devReg), (uint8_t *)&data, sizeof(data), nRead);
 
        // The data is a uint16 - byte swap the result?
        if (retVal == ksfTkErrOk && sftk_system_byteorder() != _byteOrder)
            data = sftk_byte_swap(data);
 
        return (retVal == ksfTkErrOk && nRead == sizeof(uint16_t) ? ksfTkErrOk : retVal);
    }
 
    sfTkError_t readRegisterUInt16(uint8_t devReg, uint16_t &data)
    {
        return readRegister(devReg, data);
    }
 
    virtual sfTkError_t readRegister(uint8_t devReg, uint32_t &data)
    {
        size_t nRead;
        sfTkError_t retVal = readRegister(&devReg, sizeof(devReg), (uint8_t *)&data, sizeof(data), nRead);
 
        // The data is a uint32 - byte swap the result?
        if (retVal == ksfTkErrOk && sftk_system_byteorder() != _byteOrder)
            data = sftk_byte_swap(data);
 
        return (retVal == ksfTkErrOk && nRead == sizeof(uint32_t) ? ksfTkErrOk : retVal);
    }
 
    sfTkError_t readRegisterUInt32(uint8_t devReg, uint32_t &data)
    {
        return readRegister(devReg, data);
    }
 
    virtual sfTkError_t readRegister(uint8_t devReg, uint8_t *data, size_t numBytes, size_t &readBytes)
    {
        return readRegister(&devReg, sizeof(devReg), data, numBytes, readBytes);
    }
 
    virtual sfTkError_t readRegister(uint16_t reg, uint8_t &value)
    {
        size_t readBytes = 0;
 
        // this is a reg 16 address - so call the method to manage this. Note - it manages the
        // byte swapping of the address.
        sfTkError_t retValue = readRegister(reg, (uint8_t *)&value, sizeof(value), readBytes);
 
        return retValue;
    }
 
    sfTkError_t readRegisterUInt8(uint16_t devReg, uint8_t &data)
    {
        return readRegister(devReg, data);
    }
 
    virtual sfTkError_t readRegister(uint16_t reg, uint16_t &value)
    {
        size_t readBytes = 0;
 
        // this is a reg 16 address - so call the method to manage this. Note - it manages the
        // byte swapping of the address.
        sfTkError_t retValue = readRegister(reg, (uint8_t *)&value, sizeof(value), readBytes);
 
        // The data is a uint16 - byte swap the result?
        if (retValue == ksfTkErrOk && sftk_system_byteorder() != _byteOrder)
            value = sftk_byte_swap(value);
 
        return retValue;
    }
 
    sfTkError_t readRegisterUInt16(uint16_t devReg, uint16_t &data)
    {
        return readRegister(devReg, data);
    }
 
    virtual sfTkError_t readRegister(uint16_t reg, uint32_t &value)
    {
        size_t readBytes = 0;
 
        // this is a reg 16 address - so call the method to manage this. Note - it manages the
        // byte swapping of the address.
        sfTkError_t retValue = readRegister(reg, (uint8_t *)&value, sizeof(uint32_t), readBytes);
 
        // The data is a uint32 - byte swap the result?
        if (retValue == ksfTkErrOk && sftk_system_byteorder() != _byteOrder)
            value = sftk_byte_swap(value);
 
        return retValue;
    }
 
    sfTkError_t readRegisterUInt32(uint16_t devReg, uint32_t &data)
    {
        return readRegister(devReg, data);
    }
 
    // Overload version
    sfTkError_t readRegister(uint16_t devReg, uint8_t *data, size_t numBytes, size_t &readBytes)
    {
        // The address is a uint16 - byte swap?
        if (sftk_system_byteorder() != _byteOrder)
            devReg = sftk_byte_swap(devReg);
 
        return readRegister((uint8_t *)&devReg, sizeof(devReg), data, numBytes, readBytes);
    }
 
    virtual sfTkError_t readRegister(uint16_t reg, uint16_t *data, size_t length, size_t &read16)
    {
        sfTkError_t retValue = readRegister(reg, (uint8_t *)data, length * 2, read16);
 
        // Do we need to flip the byte order?
        if (retValue == ksfTkErrOk && sftk_system_byteorder() != _byteOrder)
        {
            for (size_t i = 0; i < length; i++)
                data[i] = sftk_byte_swap(data[i]);
        }
        read16 = read16 / 2; // convert to words
        return retValue;     // added return statement to return status
    }
 
    virtual uint8_t type(void)
    {
        return 0;
    }
    void setByteOrder(sfTkByteOrder order)
    {
        _byteOrder = order;
    }
 
    sfTkByteOrder byteOrder(void)
    {
        return _byteOrder;
    }
 
  protected:
    sfTkByteOrder _byteOrder;
};