Module.h

#if !defined(_RADIOLIB_MODULE_H)
#define _RADIOLIB_MODULE_H
 
#include "TypeDef.h"
#include "Hal.h"
#include "utils/Utils.h"
 
#if defined(RADIOLIB_BUILD_ARDUINO)
  #include <SPI.h>
#endif
 
#if defined(STM32WLxx)
  #include <SubGhz.h>
#endif
 
#define END_OF_MODE_TABLE    { Module::MODE_END_OF_TABLE, {} }
 
#define RFSWITCH_PIN_FLAG                                       (0x01UL << 31)
 
#define RADIOLIB_MODULE_SPI_COMMAND_READ                        (0)
 
#define RADIOLIB_MODULE_SPI_COMMAND_WRITE                       (1)
 
#define RADIOLIB_MODULE_SPI_COMMAND_NOP                         (2)
 
#define RADIOLIB_MODULE_SPI_COMMAND_STATUS                      (3)
 
#define RADIOLIB_MODULE_SPI_WIDTH_ADDR                          (0)
 
#define RADIOLIB_MODULE_SPI_WIDTH_CMD                           (1)
 
#define RADIOLIB_MODULE_SPI_WIDTH_STATUS                        (2)
 
class Module {
  public:
    static const size_t RFSWITCH_MAX_PINS = 5;
 
    struct RfSwitchMode_t {
      uint8_t mode;
 
      uint32_t values[RFSWITCH_MAX_PINS];
    };
 
    enum OpMode_t {
      MODE_END_OF_TABLE = 0,
 
      MODE_IDLE,
 
      MODE_RX,
 
      MODE_TX,
    };
 
    #if defined(RADIOLIB_BUILD_ARDUINO)
    Module(uint32_t cs, uint32_t irq, uint32_t rst, uint32_t gpio = RADIOLIB_NC);
 
    Module(uint32_t cs, uint32_t irq, uint32_t rst, uint32_t gpio, SPIClass& spi, SPISettings spiSettings = RADIOLIB_DEFAULT_SPI_SETTINGS);
    #endif
 
    Module(RadioLibHal *hal, uint32_t cs, uint32_t irq, uint32_t rst, uint32_t gpio = RADIOLIB_NC);
 
    Module(const Module& mod);
 
    Module& operator=(const Module& mod);
 
    // public member variables
    RadioLibHal* hal = NULL;
 
    typedef int16_t (*SPIparseStatusCb_t)(uint8_t in);
 
    typedef int16_t (*SPIcheckStatusCb_t)(Module* mod);
 
    enum BitWidth_t {
      BITS_0 = 0,
      BITS_8 = 8,
      BITS_16 = 16,
      BITS_24 = 24,
      BITS_32 = 32,
    };
 
    struct SPIConfig_t {
      bool stream;
 
      int16_t err;
 
      uint16_t cmds[4];
 
      BitWidth_t widths[3];
 
      uint8_t statusPos;
 
      SPIparseStatusCb_t parseStatusCb;
 
      SPIcheckStatusCb_t checkStatusCb;
 
      RadioLibTime_t timeout;
    };
 
    SPIConfig_t spiConfig = {
      .stream = false,
      .err = RADIOLIB_ERR_UNKNOWN,
      .cmds = { 0x00, 0x80, 0x00, 0x00 },
      .widths = { Module::BITS_8, Module::BITS_0, Module::BITS_8 },
      .statusPos = 0,
      .parseStatusCb = nullptr,
      .checkStatusCb = nullptr,
      .timeout = 1000,
    };
 
    #if RADIOLIB_INTERRUPT_TIMING
 
    typedef void (*TimerSetupCb_t)(uint32_t len);
 
    TimerSetupCb_t TimerSetupCb = nullptr;
 
    volatile bool TimerFlag = false;
 
    #endif
 
    // basic methods
 
    void init();
 
    void term();
 
    // SPI methods
 
    int16_t SPIgetRegValue(uint32_t reg, uint8_t msb = 7, uint8_t lsb = 0);
 
    int16_t SPIsetRegValue(uint32_t reg, uint8_t value, uint8_t msb = 7, uint8_t lsb = 0, uint8_t checkInterval = 2, uint8_t checkMask = 0xFF, bool force = false);
 
    void SPIreadRegisterBurst(uint32_t reg, size_t numBytes, uint8_t* inBytes);
 
    uint8_t SPIreadRegister(uint32_t reg);
 
    void SPIwriteRegisterBurst(uint32_t reg, const uint8_t* data, size_t numBytes);
 
    void SPIwriteRegister(uint32_t reg, uint8_t data);
 
    void SPItransfer(uint16_t cmd, uint32_t reg, const uint8_t* dataOut, uint8_t* dataIn, size_t numBytes);
 
    int16_t SPIcheckStream();
    
    int16_t SPIreadStream(uint16_t cmd, uint8_t* data, size_t numBytes, bool waitForGpio = true, bool verify = true);
    
    int16_t SPIreadStream(const uint8_t* cmd, uint8_t cmdLen, uint8_t* data, size_t numBytes, bool waitForGpio = true, bool verify = true);
    
    int16_t SPIwriteStream(uint16_t cmd, const uint8_t* data, size_t numBytes, bool waitForGpio = true, bool verify = true);
 
    int16_t SPIwriteStream(const uint8_t* cmd, uint8_t cmdLen, const uint8_t* data, size_t numBytes, bool waitForGpio = true, bool verify = true);
    
    int16_t SPItransferStream(const uint8_t* cmd, uint8_t cmdLen, bool write, const uint8_t* dataOut, uint8_t* dataIn, size_t numBytes, bool waitForGpio);
 
    // pin number access methods
    // getCs is omitted on purpose, as it can interfere when accessing the SPI in a concurrent environment
    // so it is considered to be part of the SPI pins and hence not accessible from outside
    // see https://github.com/jgromes/RadioLib/discussions/1364
 
    uint32_t getIrq() const { return(irqPin); }
 
    uint32_t getRst() const { return(rstPin); }
 
    uint32_t getGpio() const { return(gpioPin); }
 
    void setRfSwitchPins(uint32_t rxEn, uint32_t txEn);
 
    void setRfSwitchTable(const uint32_t (&pins)[RFSWITCH_MAX_PINS], const RfSwitchMode_t table[]);
 
    const RfSwitchMode_t *findRfSwitchMode(uint8_t mode) const;
 
    void setRfSwitchState(uint8_t mode);
 
    void waitForMicroseconds(RadioLibTime_t start, RadioLibTime_t len);
 
    #if RADIOLIB_DEBUG
    void regdump(const char* level, uint16_t start, size_t len);
    #endif
 
#if !RADIOLIB_GODMODE
  private:
#endif
    uint32_t csPin = RADIOLIB_NC;
    uint32_t irqPin = RADIOLIB_NC;
    uint32_t rstPin = RADIOLIB_NC;
    uint32_t gpioPin = RADIOLIB_NC;
 
    // RF switch pins and table
    uint32_t rfSwitchPins[RFSWITCH_MAX_PINS] = { RADIOLIB_NC, RADIOLIB_NC, RADIOLIB_NC, RADIOLIB_NC, RADIOLIB_NC };
    const RfSwitchMode_t *rfSwitchTable = nullptr;
 
    #if RADIOLIB_INTERRUPT_TIMING
    uint32_t prevTimingLen = 0;
    #endif
};
 
#endif