PhysicalLayer.h

#if !defined(_RADIOLIB_PHYSICAL_LAYER_H)
#define _RADIOLIB_PHYSICAL_LAYER_H
 
#include "../../TypeDef.h"
#include "../../Module.h"
 
// common IRQ values - the IRQ flags in RadioLibIrqFlags_t arguments are offset by this value
enum RadioLibIrqType_t {
  RADIOLIB_IRQ_TX_DONE = 0x00,
  RADIOLIB_IRQ_RX_DONE = 0x01,
  RADIOLIB_IRQ_PREAMBLE_DETECTED = 0x02,
  RADIOLIB_IRQ_SYNC_WORD_VALID = 0x03,
  RADIOLIB_IRQ_HEADER_VALID = 0x04,
  RADIOLIB_IRQ_HEADER_ERR = 0x05,
  RADIOLIB_IRQ_CRC_ERR = 0x06,
  RADIOLIB_IRQ_CAD_DONE = 0x07,
  RADIOLIB_IRQ_CAD_DETECTED = 0x08,
  RADIOLIB_IRQ_TIMEOUT = 0x09,
  RADIOLIB_IRQ_NOT_SUPPORTED = 0x1F, // this must be the last value, intentionally set to 31
};
 
// some commonly used default values - defined here to ensure all modules have the same default behavior
#define RADIOLIB_IRQ_RX_DEFAULT_FLAGS       ((1UL << RADIOLIB_IRQ_RX_DONE) | (1UL << RADIOLIB_IRQ_TIMEOUT) | (1UL << RADIOLIB_IRQ_CRC_ERR) | (1UL << RADIOLIB_IRQ_HEADER_VALID) | (1UL << RADIOLIB_IRQ_HEADER_ERR))
#define RADIOLIB_IRQ_RX_DEFAULT_MASK        ((1UL << RADIOLIB_IRQ_RX_DONE))
#define RADIOLIB_IRQ_CAD_DEFAULT_FLAGS      ((1UL << RADIOLIB_IRQ_CAD_DETECTED) | (1UL << RADIOLIB_IRQ_CAD_DONE))
#define RADIOLIB_IRQ_CAD_DEFAULT_MASK       ((1UL << RADIOLIB_IRQ_CAD_DETECTED) | (1UL << RADIOLIB_IRQ_CAD_DONE))
 
struct LoRaRate_t {
  uint8_t spreadingFactor;
  
  float bandwidth;
  
  uint8_t codingRate;
};
 
struct FSKRate_t {
  float bitRate;
  
  float freqDev;
};
 
struct LrFhssRate_t {
  uint8_t bw;
 
  uint8_t cr;
 
  bool narrowGrid;
};
 
union DataRate_t {
  LoRaRate_t lora;
 
  FSKRate_t fsk;
 
  LrFhssRate_t lrFhss;
};
 
struct CADScanConfig_t {
  uint8_t symNum;
  
  uint8_t detPeak;
  
  uint8_t detMin;
  
  uint8_t exitMode;
  
  RadioLibTime_t timeout;
 
  RadioLibIrqFlags_t irqFlags;
 
  RadioLibIrqFlags_t irqMask;
};
 
struct RSSIScanConfig_t {
  float limit;
};
 
union ChannelScanConfig_t {
  CADScanConfig_t cad;
 
  RSSIScanConfig_t rssi;
};
 
struct StandbyConfig_t {
  uint8_t mode;
};
 
struct ReceiveConfig_t {
  uint32_t timeout;
  
  RadioLibIrqFlags_t irqFlags;
  
  RadioLibIrqFlags_t irqMask;
  
  size_t len;
};
 
struct TransmitConfig_t {
  const uint8_t* data;
 
  size_t len;
 
  uint8_t addr;
};
 
struct SleepConfig_t {
  uint8_t mode;
};
 
union RadioModeConfig_t {
  StandbyConfig_t standby;
 
  ReceiveConfig_t receive;
 
  TransmitConfig_t transmit;
 
  ChannelScanConfig_t scan;
 
  SleepConfig_t sleep;
};
 
enum ModemType_t {
  RADIOLIB_MODEM_FSK = 0,
  RADIOLIB_MODEM_LORA,
  RADIOLIB_MODEM_LRFHSS,
};
 
enum RadioModeType_t {
  RADIOLIB_RADIO_MODE_NONE = 0,
  RADIOLIB_RADIO_MODE_STANDBY,
  RADIOLIB_RADIO_MODE_RX,
  RADIOLIB_RADIO_MODE_TX,
  RADIOLIB_RADIO_MODE_SCAN,
  RADIOLIB_RADIO_MODE_SLEEP,
};
 
class PhysicalLayer {
  public:
 
    // constructor
 
    PhysicalLayer(float step, size_t maxLen);
 
    // basic methods
 
    #if defined(RADIOLIB_BUILD_ARDUINO)
    int16_t transmit(__FlashStringHelper* fstr, uint8_t addr = 0);
 
    int16_t transmit(String& str, uint8_t addr = 0);
    #endif
 
    int16_t transmit(const char* str, uint8_t addr = 0);
 
    virtual int16_t transmit(const uint8_t* data, size_t len, uint8_t addr = 0);
 
    #if defined(RADIOLIB_BUILD_ARDUINO)
    int16_t receive(String& str, size_t len = 0);
    #endif
 
    virtual int16_t sleep();
 
    virtual int16_t standby();
 
    virtual int16_t standby(uint8_t mode);
 
    virtual int16_t startReceive();
 
    virtual int16_t startReceive(uint32_t timeout, RadioLibIrqFlags_t irqFlags = RADIOLIB_IRQ_RX_DEFAULT_FLAGS, RadioLibIrqFlags_t irqMask = RADIOLIB_IRQ_RX_DEFAULT_MASK, size_t len = 0);
 
    virtual int16_t receive(uint8_t* data, size_t len);
 
    #if defined(RADIOLIB_BUILD_ARDUINO)
    int16_t startTransmit(String& str, uint8_t addr = 0);
    #endif
 
    int16_t startTransmit(const char* str, uint8_t addr = 0);
 
    virtual int16_t startTransmit(const uint8_t* data, size_t len, uint8_t addr = 0);
 
    virtual int16_t finishTransmit();
 
    #if defined(RADIOLIB_BUILD_ARDUINO)
    int16_t readData(String& str, size_t len = 0);
    #endif
 
    virtual int16_t readData(uint8_t* data, size_t len);
 
    virtual int16_t transmitDirect(uint32_t frf = 0);
 
    virtual int16_t receiveDirect();
 
    // configuration methods
 
    virtual int16_t setFrequency(float freq);
 
    virtual int16_t setBitRate(float br);
 
    virtual int16_t setFrequencyDeviation(float freqDev);
 
    virtual int16_t setDataShaping(uint8_t sh);
 
    virtual int16_t setEncoding(uint8_t encoding);
 
    virtual int16_t invertIQ(bool enable);
 
    virtual int16_t setOutputPower(int8_t power);
 
    virtual int16_t checkOutputPower(int8_t power, int8_t* clipped);
 
    virtual int16_t setSyncWord(uint8_t* sync, size_t len);
 
    virtual int16_t setPreambleLength(size_t len);
    
    virtual int16_t setDataRate(DataRate_t dr);
 
    virtual int16_t checkDataRate(DataRate_t dr);
 
    float getFreqStep() const;
 
    virtual size_t getPacketLength(bool update = true);
 
    virtual float getRSSI();
 
    virtual float getSNR();
 
    virtual RadioLibTime_t getTimeOnAir(size_t len);
 
    virtual RadioLibTime_t calculateRxTimeout(RadioLibTime_t timeoutUs);
 
    uint32_t getIrqMapped(RadioLibIrqFlags_t irq);
 
    int16_t checkIrq(RadioLibIrqType_t irq);
 
    int16_t setIrq(RadioLibIrqFlags_t irq);
 
    int16_t clearIrq(RadioLibIrqFlags_t irq);
 
    virtual uint32_t getIrqFlags();
 
    virtual int16_t setIrqFlags(uint32_t irq);
 
    virtual int16_t clearIrqFlags(uint32_t irq);
 
    virtual int16_t startChannelScan();
 
    virtual int16_t startChannelScan(const ChannelScanConfig_t &config);
 
    virtual int16_t getChannelScanResult();
 
    virtual int16_t scanChannel();
 
    virtual int16_t scanChannel(const ChannelScanConfig_t &config);
 
    int32_t random(int32_t max);
 
    int32_t random(int32_t min, int32_t max);
 
    virtual uint8_t randomByte();
 
    int16_t startDirect();
 
    #if !RADIOLIB_EXCLUDE_DIRECT_RECEIVE
    int16_t setDirectSyncWord(uint32_t syncWord, uint8_t len);
 
    virtual void setDirectAction(void (*func)(void));
 
    virtual void readBit(uint32_t pin);
 
    int16_t available();
 
    void dropSync();
 
    uint8_t read(bool drop = true);
    #endif
 
    virtual int16_t setDIOMapping(uint32_t pin, uint32_t value);
 
    virtual void setPacketReceivedAction(void (*func)(void));
 
    virtual void clearPacketReceivedAction();
 
    virtual void setPacketSentAction(void (*func)(void));
 
    virtual void clearPacketSentAction();
    
    virtual void setChannelScanAction(void (*func)(void));
 
    virtual void clearChannelScanAction();
 
    virtual int16_t setModem(ModemType_t modem);
 
    virtual int16_t getModem(ModemType_t* modem);
 
    virtual int16_t stageMode(RadioModeType_t mode, RadioModeConfig_t* cfg);
 
    virtual int16_t launchMode();
 
    #if RADIOLIB_INTERRUPT_TIMING
 
    void setInterruptSetup(void (*func)(uint32_t));
 
    void setTimerFlag();
 
    #endif
 
#if !RADIOLIB_GODMODE
  protected:
#endif
    uint32_t irqMap[10] = { 0 };
    RadioModeType_t stagedMode = RADIOLIB_RADIO_MODE_NONE;
 
#if !RADIOLIB_EXCLUDE_DIRECT_RECEIVE
    void updateDirectBuffer(uint8_t bit);
#endif
 
#if !RADIOLIB_GODMODE
  private:
#endif
    float freqStep;
    size_t maxPacketLength;
 
    #if !RADIOLIB_EXCLUDE_DIRECT_RECEIVE
    uint8_t bufferBitPos = 0;
    uint8_t bufferWritePos = 0;
    uint8_t bufferReadPos = 0;
    uint8_t buffer[RADIOLIB_STATIC_ARRAY_SIZE] = { 0 };
    uint32_t syncBuffer = 0;
    uint32_t directSyncWord = 0;
    uint8_t directSyncWordLen = 0;
    uint32_t directSyncWordMask = 0;
    bool gotSync = false;
    #endif
 
    virtual Module* getMod() = 0;
 
    // allow specific classes access the private getMod method
    friend class AFSKClient;
    friend class RTTYClient;
    friend class MorseClient;
    friend class HellClient;
    friend class SSTVClient;
    friend class AX25Client;
    friend class FSK4Client;
    friend class PagerClient;
    friend class BellClient;
    friend class FT8Client;
    friend class LoRaWANNode;
    friend class M17Client;
};
 
#endif