Module.h

#if !defined(_RADIOLIB_MODULE_H)
#define _RADIOLIB_MODULE_H
 
#include "TypeDef.h"
#include "Hal.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, {} }
 
// default timeout for SPI transfers
#define RADIOLIB_MODULE_SPI_TIMEOUT                             (1000)
 
class Module {
  public:
    static const size_t RFSWITCH_MAX_PINS = 3;
 
    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;
 
    uint8_t SPIreadCommand = 0b00000000;
 
    uint8_t SPIwriteCommand = 0b10000000;
 
    uint8_t SPInopCommand = 0x00;
 
    uint8_t SPIstatusCommand = 0x00;
 
    uint8_t SPIaddrWidth = 8;
 
    bool SPIstreamType = false;
 
    int16_t SPIstreamError = RADIOLIB_ERR_UNKNOWN;
 
    typedef int16_t (*SPIparseStatusCb_t)(uint8_t in);
 
    SPIparseStatusCb_t SPIparseStatusCb = nullptr;
 
    #if defined(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(uint16_t reg, uint8_t msb = 7, uint8_t lsb = 0);
 
    int16_t SPIsetRegValue(uint16_t reg, uint8_t value, uint8_t msb = 7, uint8_t lsb = 0, uint8_t checkInterval = 2, uint8_t checkMask = 0xFF);
 
    void SPIreadRegisterBurst(uint16_t reg, size_t numBytes, uint8_t* inBytes);
 
    uint8_t SPIreadRegister(uint16_t reg);
 
    void SPIwriteRegisterBurst(uint16_t reg, uint8_t* data, size_t numBytes);
 
    void SPIwriteRegister(uint16_t reg, uint8_t data);
 
    void SPItransfer(uint8_t cmd, uint16_t reg, uint8_t* dataOut, uint8_t* dataIn, size_t numBytes);
 
    int16_t SPIcheckStream();
    
    int16_t SPIreadStream(uint8_t cmd, uint8_t* data, size_t numBytes, bool waitForGpio = true, bool verify = true);
    
    int16_t SPIreadStream(uint8_t* cmd, uint8_t cmdLen, uint8_t* data, size_t numBytes, bool waitForGpio = true, bool verify = true);
    
    int16_t SPIwriteStream(uint8_t cmd, uint8_t* data, size_t numBytes, bool waitForGpio = true, bool verify = true);
 
    int16_t SPIwriteStream(uint8_t* cmd, uint8_t cmdLen, uint8_t* data, size_t numBytes, bool waitForGpio = true, bool verify = true);
    
    int16_t SPItransferStream(uint8_t* cmd, uint8_t cmdLen, bool write, uint8_t* dataOut, uint8_t* dataIn, size_t numBytes, bool waitForGpio, uint32_t timeout);
 
    // pin number access methods
 
    uint32_t getCs() const { return(csPin); }
 
    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(uint32_t start, uint32_t len);
 
    static uint32_t reflect(uint32_t in, uint8_t bits);
 
    static void hexdump(uint8_t* data, size_t len, uint32_t offset = 0, uint8_t width = 1, bool be = false);
 
    void regdump(uint16_t start, size_t len);
 
    #if defined(RADIOLIB_DEBUG) and defined(RADIOLIB_BUILD_ARDUINO)
    static size_t serialPrintf(const char* format, ...);
    #endif
 
#if !defined(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 };
    const RfSwitchMode_t *rfSwitchTable = nullptr;
 
    #if defined(RADIOLIB_INTERRUPT_TIMING)
    uint32_t prevTimingLen = 0;
    #endif
};
 
#endif