Module.h

#ifndef _RADIOLIB_MODULE_H
#define _RADIOLIB_MODULE_H
 
#include "TypeDef.h"
 
#include <SPI.h>
#ifndef RADIOLIB_SOFTWARE_SERIAL_UNSUPPORTED
#include <SoftwareSerial.h>
#endif
 
class Module {
  public:
    Module(RADIOLIB_PIN_TYPE cs, RADIOLIB_PIN_TYPE irq, RADIOLIB_PIN_TYPE rst);
 
    Module(RADIOLIB_PIN_TYPE cs, RADIOLIB_PIN_TYPE irq, RADIOLIB_PIN_TYPE rst, RADIOLIB_PIN_TYPE gpio);
 
    Module(RADIOLIB_PIN_TYPE cs, RADIOLIB_PIN_TYPE irq, RADIOLIB_PIN_TYPE rst, SPIClass& spi, SPISettings spiSettings);
 
    Module(RADIOLIB_PIN_TYPE cs, RADIOLIB_PIN_TYPE irq, RADIOLIB_PIN_TYPE rst, RADIOLIB_PIN_TYPE gpio, SPIClass& spi, SPISettings spiSettings = SPISettings(2000000, MSBFIRST, SPI_MODE0));
 
#ifdef RADIOLIB_SOFTWARE_SERIAL_UNSUPPORTED
    Module(RADIOLIB_PIN_TYPE cs, RADIOLIB_PIN_TYPE irq, RADIOLIB_PIN_TYPE rst, RADIOLIB_PIN_TYPE rx, RADIOLIB_PIN_TYPE tx, SPIClass& spi = RADIOLIB_DEFAULT_SPI, SPISettings spiSettings = SPISettings(2000000, MSBFIRST, SPI_MODE0), HardwareSerial* serial = &RADIOLIB_HARDWARE_SERIAL_PORT);
#else
    Module(RADIOLIB_PIN_TYPE cs, RADIOLIB_PIN_TYPE irq, RADIOLIB_PIN_TYPE rst, RADIOLIB_PIN_TYPE rx, RADIOLIB_PIN_TYPE tx, SPIClass& spi = RADIOLIB_DEFAULT_SPI, SPISettings spiSettings = SPISettings(2000000, MSBFIRST, SPI_MODE0), HardwareSerial* serial = nullptr);
#endif
 
    Module(const Module& mod);
 
    Module& operator=(const Module& mod);
 
    // public member variables
 
#ifdef RADIOLIB_SOFTWARE_SERIAL_UNSUPPORTED
    HardwareSerial* ModuleSerial;
#else
    SoftwareSerial* ModuleSerial;
#endif
 
    uint32_t baudrate = 9600;
 
    char AtLineFeed[3] = {'\r', '\n'};
 
    uint8_t SPIreadCommand = 0b00000000;
 
    uint8_t SPIwriteCommand = 0b10000000;
 
    // basic methods
 
    void init(uint8_t interface);
 
    void term(uint8_t interface);
 
    // AT methods
 
    void ATemptyBuffer();
 
    bool ATgetResponse();
 
    bool ATsendCommand(const char* cmd);
 
    bool ATsendData(uint8_t* data, uint32_t len);
 
    // SPI methods
 
    int16_t SPIgetRegValue(uint8_t reg, uint8_t msb = 7, uint8_t lsb = 0);
 
    int16_t SPIsetRegValue(uint8_t reg, uint8_t value, uint8_t msb = 7, uint8_t lsb = 0, uint8_t checkInterval = 2, uint8_t checkMask = 0xFF);
 
    void SPIreadRegisterBurst(uint8_t reg, uint8_t numBytes, uint8_t* inBytes);
 
    uint8_t SPIreadRegister(uint8_t reg);
 
    void SPIwriteRegisterBurst(uint8_t reg, uint8_t* data, uint8_t numBytes);
 
    void SPIwriteRegister(uint8_t reg, uint8_t data);
 
    void SPItransfer(uint8_t cmd, uint8_t reg, uint8_t* dataOut, uint8_t* dataIn, uint8_t numBytes);
 
    // 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(_rx); }
 
    RADIOLIB_PIN_TYPE getRx() const { return(_rx); }
 
    RADIOLIB_PIN_TYPE getTx() const { return(_tx); }
 
    SPIClass* getSpi() const { return(_spi); }
 
    SPISettings getSpiSettings() const { return(_spiSettings); }
 
    void setRfSwitchPins(RADIOLIB_PIN_TYPE rxEn, RADIOLIB_PIN_TYPE txEn);
 
    void setRfSwitchState(RADIOLIB_PIN_STATUS rxPinState, RADIOLIB_PIN_STATUS txPinState);
 
    // Arduino core overrides
 
    static void pinMode(RADIOLIB_PIN_TYPE pin, RADIOLIB_PIN_MODE mode);
 
    static void digitalWrite(RADIOLIB_PIN_TYPE pin, RADIOLIB_PIN_STATUS value);
 
    static RADIOLIB_PIN_STATUS digitalRead(RADIOLIB_PIN_TYPE pin);
 
    static void tone(RADIOLIB_PIN_TYPE pin, uint16_t value);
 
    static void noTone(RADIOLIB_PIN_TYPE pin);
 
    static void attachInterrupt(RADIOLIB_PIN_TYPE interruptNum, void (*userFunc)(void), RADIOLIB_INTERRUPT_STATUS mode);
 
    static void detachInterrupt(RADIOLIB_PIN_TYPE interruptNum);
 
    static void yield();
 
    static void delay(uint32_t ms);
 
    static void delayMicroseconds(uint32_t us);
 
    static uint32_t millis();
 
    static uint32_t micros();
 
    static uint8_t flipBits(uint8_t b);
 
    static uint16_t flipBits16(uint16_t i);
 
#ifndef RADIOLIB_GODMODE
  private:
#endif
    // allow SerialModule class to access private members
    friend class SerialModule;
 
    // whether RadioLib should automatically initalize selected SPI or UART interface
    bool _initInterface = false;
 
    // pins
    RADIOLIB_PIN_TYPE _cs = RADIOLIB_NC;
    RADIOLIB_PIN_TYPE _irq = RADIOLIB_NC;
    RADIOLIB_PIN_TYPE _rst = RADIOLIB_NC;
    RADIOLIB_PIN_TYPE _rx = RADIOLIB_NC;
    RADIOLIB_PIN_TYPE _tx = RADIOLIB_NC;
 
    // SPI settings
    SPISettings _spiSettings = SPISettings(2000000, MSBFIRST, SPI_MODE0);
    SPIClass* _spi = NULL;
 
    // RF switch presence and pins
    bool _useRfSwitch = false;
    RADIOLIB_PIN_TYPE _rxEn = RADIOLIB_NC;
    RADIOLIB_PIN_TYPE _txEn = RADIOLIB_NC;
 
    // AT command timeout in milliseconds
    uint32_t _ATtimeout = 15000;
};
 
class SerialModule: public Module {
  public:
    #ifdef RADIOLIB_SOFTWARE_SERIAL_UNSUPPORTED
        SerialModule(RADIOLIB_PIN_TYPE rx, RADIOLIB_PIN_TYPE tx, RADIOLIB_PIN_TYPE rst = RADIOLIB_NC, HardwareSerial* serial = &RADIOLIB_HARDWARE_SERIAL_PORT);
    #else
        SerialModule(RADIOLIB_PIN_TYPE rx, RADIOLIB_PIN_TYPE tx, RADIOLIB_PIN_TYPE rst = RADIOLIB_NC, HardwareSerial* serial = nullptr);
    #endif
};
 
#endif