SensorCommArduino_SPI.hpp

Go to the documentation of this file.

 
#pragma once
 
#include "../SensorCommBase.hpp"
 
#ifdef ARDUINO
 
 
#if (defined(ARDUINO_ARCH_RP2040) || defined(ARDUINO_ARCH_STM32))  && !defined(ARDUINO_ARCH_MBED)
#define  __writeBytes(txBuf,size) spi.transfer(txBuf,nullptr,size)
#elif defined(ARDUINO_ARCH_NRF52)
#define  __writeBytes(txBuf,size) spi.transfer(txBuf,nullptr,size)
#elif defined(ARDUINO_ARCH_MBED) || defined(ARDUINO_ARCH_ZEPHYR)
#define  __writeBytes(txBuf,size) spi.transfer((void*)txBuf,size)
#else
#define  __writeBytes(txBuf,size) spi.writeBytes(txBuf,size)
#endif
 
 
class SensorCommSPI : public SensorCommBase
{
public:
    SensorCommSPI(SPIClass &spi, uint8_t csPin, SensorHal *hal) : spi(spi), csPin(csPin), hal(hal) {}
    SensorCommSPI(SPIClass &spi, uint8_t csPin, int mosi, int miso, int sck, SensorHal *hal) : spi(spi),
        csPin(csPin), hal(hal), mosi(mosi), miso(miso), sck(sck) {}
 
    bool init() override
    {
        if (!hal) {
            setError(SENSOR_ERR_INVALID_ARG);
            return false;
        }
        if (mosi != -1 && miso != -1 && sck != -1) {
#if   defined(ARDUINO_ARCH_NRF52)
            spi.setPins(miso, sck, mosi);
            spi.begin();
#elif defined(ARDUINO_ARCH_ESP32)
            spi.begin(sck, miso, mosi);
#elif defined(ARDUINO_ARCH_RP2040)
#if !defined(ARDUINO_ARCH_MBED)
            spi.setSCK(sck);
            spi.setRX(miso);
            spi.setTX(mosi);
#endif  /*ARDUINO_ARCH_MBED*/
            spi.begin();
#elif defined(ARDUINO_ARCH_STM32)
            spi.setMISO(miso);
            spi.setMOSI(mosi);
            spi.setSCLK(sck);
            spi.begin();
#else
#warning "SPI custom GPIO mapping function is not implemented"
#endif
        } else {
            // Use default pins
            spi.begin();
        }
        hal->pinMode(csPin, OUTPUT);
        hal->digitalWrite(csPin, HIGH);
        return true;
    }
 
    void deinit() override
    {
        // Do not destroy spi bus
        // spi.end();
    }
 
    int writeRegister(const uint8_t reg, uint8_t *buf, size_t len) override
    {
        if (hal == nullptr) {
            return SENSOR_ERR_INVALID_ARG;
        }
        hal->digitalWrite(csPin, LOW);
        spi.beginTransaction(setting);
        spi.transfer(reg);
        for (size_t i = 0; i < len; ++i) {
            spi.transfer(buf[i]);
        }
        spi.endTransaction();
        hal->digitalWrite(csPin, HIGH);
        return SENSOR_OK;
    }
 
    int readBuffer(uint8_t *buf, size_t len) override
    {
        if (hal == nullptr) {
            return SENSOR_ERR_INVALID_ARG;
        }
        hal->digitalWrite(csPin, LOW);
        spi.beginTransaction(setting);
        spi.transfer(0x00);
        for (size_t i = 0; i < len; ++i) {
            buf[i] = spi.transfer(0x00);
        }
        spi.endTransaction();
        hal->digitalWrite(csPin, HIGH);
        return SENSOR_OK;
    }
 
    int writeBuffer(uint8_t *buffer, size_t len) override
    {
        if (hal == nullptr) {
            return SENSOR_ERR_INVALID_ARG;
        }
        hal->digitalWrite(csPin, LOW);
        spi.beginTransaction(setting);
        if (buffer && len > 0) {
            // spi.writeBytes(buffer, len);
            __writeBytes(buffer, len);
        }
        spi.endTransaction();
        hal->digitalWrite(csPin, HIGH);
        return SENSOR_OK;
    }
 
    int readRegister(const uint8_t reg, uint8_t *buf, size_t len) override
    {
        if (hal == nullptr) {
            return SENSOR_ERR_INVALID_ARG;
        }
        hal->digitalWrite(csPin, LOW);
        spi.beginTransaction(setting);
        spi.transfer(reg | 0x80);
#if defined(ARDUINO_ARCH_ESP32)
        spi.transferBytes(NULL, buf, len);
#else
        for (size_t i = 0; i < len; i++) {
            buf[i] = spi.transfer(0x00);
        }
#endif
        spi.endTransaction();
        hal->digitalWrite(csPin, HIGH);
        return SENSOR_OK;
    }
 
    int writeThenRead(const uint8_t *write_buffer, size_t write_len, uint8_t *read_buffer, size_t read_len) override
    {
        if (hal == nullptr) {
            return SENSOR_ERR_INVALID_ARG;
        }
        hal->digitalWrite(csPin, LOW);
        spi.beginTransaction(setting);
 
        // spi.writeBytes(write_buffer, write_len);
        __writeBytes(write_buffer, write_len);
 
        spi.endTransaction();
 
        spi.beginTransaction(setting);
        for (size_t i = 0; i < read_len; ++i) {
            read_buffer[i] = spi.transfer(0x00);
        }
        spi.endTransaction();
        hal->digitalWrite(csPin, HIGH);
        return SENSOR_OK;
    }
 
    void setParams(const CommParamsBase &params) override
    {
#if defined(__cpp_rtti)
        const auto pdat = dynamic_cast<const SPIParam *>(&params);
#else
        const auto pdat = static_cast<const SPIParam *>(&params);
#endif
        setting = pdat->getSetting();
    }
 
private:
    SPIClass &spi;
    uint8_t csPin;
    SensorHal *hal;
    SPISettings setting;
    int mosi, miso, sck;
};
 
#undef __writeBytes
 
#endif  //*ARDUINO