Module.h

#if !defined(_RADIOLIB_MODULE_H)
#define _RADIOLIB_MODULE_H
 
#include "TypeDef.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, {} }
 
class Module {
  public:
    static const size_t RFSWITCH_MAX_PINS = 3;
 
    struct RfSwitchMode_t {
      uint8_t mode;
      RADIOLIB_PIN_STATUS values[RFSWITCH_MAX_PINS];
    };
 
    enum OpMode_t {
      MODE_END_OF_TABLE = 0,
      MODE_IDLE,
      MODE_RX,
      MODE_TX,
    };
 
    #if defined(RADIOLIB_BUILD_ARDUINO)
 
    Module(RADIOLIB_PIN_TYPE cs, RADIOLIB_PIN_TYPE irq, RADIOLIB_PIN_TYPE rst, RADIOLIB_PIN_TYPE gpio = RADIOLIB_NC);
 
    Module(RADIOLIB_PIN_TYPE cs, RADIOLIB_PIN_TYPE irq, RADIOLIB_PIN_TYPE rst, RADIOLIB_PIN_TYPE gpio, SPIClass& spi, SPISettings spiSettings = RADIOLIB_DEFAULT_SPI_SETTINGS);
 
    #else
 
    Module(RADIOLIB_PIN_TYPE cs, RADIOLIB_PIN_TYPE irq, RADIOLIB_PIN_TYPE rst, RADIOLIB_PIN_TYPE gpio = RADIOLIB_NC);
 
    #endif
 
    Module(const Module& mod);
 
    Module& operator=(const Module& mod);
 
    // public member variables
 
    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
 
    RADIOLIB_PIN_TYPE getCs() const { return(_cs); }
 
    RADIOLIB_PIN_TYPE getIrq() const { return(_irq); }
 
    RADIOLIB_PIN_TYPE getRst() const { return(_rst); }
 
    RADIOLIB_PIN_TYPE getGpio() const { return(_gpio); }
 
    void setRfSwitchPins(RADIOLIB_PIN_TYPE rxEn, RADIOLIB_PIN_TYPE txEn);
 
    void setRfSwitchTable(const RADIOLIB_PIN_TYPE (&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);
 
    // Arduino core overrides
 
    void pinMode(RADIOLIB_PIN_TYPE pin, RADIOLIB_PIN_MODE mode);
 
    void digitalWrite(RADIOLIB_PIN_TYPE pin, RADIOLIB_PIN_STATUS value);
 
    RADIOLIB_PIN_STATUS digitalRead(RADIOLIB_PIN_TYPE pin);
 
    void tone(RADIOLIB_PIN_TYPE pin, uint16_t value, uint32_t duration = 0);
 
    void noTone(RADIOLIB_PIN_TYPE pin);
 
    void attachInterrupt(RADIOLIB_PIN_TYPE interruptNum, void (*userFunc)(void), RADIOLIB_INTERRUPT_STATUS mode);
 
    void detachInterrupt(RADIOLIB_PIN_TYPE interruptNum);
 
    void yield();
 
    void delay(uint32_t ms);
 
    void delayMicroseconds(uint32_t us);
 
    uint32_t millis();
 
    uint32_t micros();
 
    uint32_t pulseIn(RADIOLIB_PIN_TYPE pin, RADIOLIB_PIN_STATUS state, uint32_t timeout);
 
    void begin();
 
    void beginTransaction();
 
    uint8_t transfer(uint8_t b);
 
    void endTransaction();
 
    void end();
 
    // helper functions to set up SPI overrides on Arduino
    #if defined(RADIOLIB_BUILD_ARDUINO)
    void SPIbegin();
    void SPIend();
    virtual void SPIbeginTransaction();
    virtual uint8_t SPItransfer(uint8_t b);
    virtual void SPIendTransaction();
    #endif
 
    static uint8_t flipBits(uint8_t b);
 
    static uint16_t flipBits16(uint16_t i);
 
    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
 
    // pins
    RADIOLIB_PIN_TYPE _cs = RADIOLIB_NC;
    RADIOLIB_PIN_TYPE _irq = RADIOLIB_NC;
    RADIOLIB_PIN_TYPE _rst = RADIOLIB_NC;
    RADIOLIB_PIN_TYPE _gpio = RADIOLIB_NC;
 
    // SPI interface (Arduino only)
    #if defined(RADIOLIB_BUILD_ARDUINO)
    SPIClass* _spi = NULL;
    SPISettings _spiSettings = RADIOLIB_DEFAULT_SPI_SETTINGS;
    bool _initInterface = false;
    #endif
 
    // RF switch pins and table
    RADIOLIB_PIN_TYPE _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
 
    // hardware abstraction layer callbacks
    // this is placed at the end of Module class because the callback generator macros
    // screw with the private/public access specifiers
    RADIOLIB_GENERATE_CALLBACK(RADIOLIB_CB_ARGS_PIN_MODE);
    RADIOLIB_GENERATE_CALLBACK(RADIOLIB_CB_ARGS_DIGITAL_WRITE);
    RADIOLIB_GENERATE_CALLBACK(RADIOLIB_CB_ARGS_DIGITAL_READ);
    RADIOLIB_GENERATE_CALLBACK(RADIOLIB_CB_ARGS_TONE);
    RADIOLIB_GENERATE_CALLBACK(RADIOLIB_CB_ARGS_NO_TONE);
    RADIOLIB_GENERATE_CALLBACK(RADIOLIB_CB_ARGS_ATTACH_INTERRUPT);
    RADIOLIB_GENERATE_CALLBACK(RADIOLIB_CB_ARGS_DETACH_INTERRUPT);
    RADIOLIB_GENERATE_CALLBACK(RADIOLIB_CB_ARGS_YIELD);
    RADIOLIB_GENERATE_CALLBACK(RADIOLIB_CB_ARGS_DELAY);
    RADIOLIB_GENERATE_CALLBACK(RADIOLIB_CB_ARGS_DELAY_MICROSECONDS);
    RADIOLIB_GENERATE_CALLBACK(RADIOLIB_CB_ARGS_MILLIS);
    RADIOLIB_GENERATE_CALLBACK(RADIOLIB_CB_ARGS_MICROS);
    RADIOLIB_GENERATE_CALLBACK(RADIOLIB_CB_ARGS_PULSE_IN);
 
    #if defined(RADIOLIB_BUILD_ARDUINO)
    RADIOLIB_GENERATE_CALLBACK_SPI(RADIOLIB_CB_ARGS_SPI_BEGIN);
    RADIOLIB_GENERATE_CALLBACK_SPI(RADIOLIB_CB_ARGS_SPI_BEGIN_TRANSACTION);
    RADIOLIB_GENERATE_CALLBACK_SPI(RADIOLIB_CB_ARGS_SPI_TRANSFER);
    RADIOLIB_GENERATE_CALLBACK_SPI(RADIOLIB_CB_ARGS_SPI_END_TRANSACTION);
    RADIOLIB_GENERATE_CALLBACK_SPI(RADIOLIB_CB_ARGS_SPI_END);
    #else
    RADIOLIB_GENERATE_CALLBACK(RADIOLIB_CB_ARGS_SPI_BEGIN);
    RADIOLIB_GENERATE_CALLBACK(RADIOLIB_CB_ARGS_SPI_BEGIN_TRANSACTION);
    RADIOLIB_GENERATE_CALLBACK(RADIOLIB_CB_ARGS_SPI_TRANSFER);
    RADIOLIB_GENERATE_CALLBACK(RADIOLIB_CB_ARGS_SPI_END_TRANSACTION);
    RADIOLIB_GENERATE_CALLBACK(RADIOLIB_CB_ARGS_SPI_END);
    #endif
};
 
#endif