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;
  
  uint32_t bandwidth;

  uint8_t codingRate;
};

struct FSKRate_t {
  uint32_t bitRate;
  
  uint32_t 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 LoRaPacketConfig_t {
  uint16_t preambleLength;

  bool implicitHeader;

  bool crcEnabled;

  bool ldrOptimize;
};
 
struct FSKPacketConfig_t {
  uint16_t preambleLength;

  uint8_t syncWordLength;

  uint8_t crcLength;
};
 
struct LrFhssPacketConfig_t {
  uint8_t hdrCount;
};

union PacketConfig_t {
  LoRaPacketConfig_t lora;
  FSKPacketConfig_t fsk;
  LrFhssPacketConfig_t lrFhss;
};

struct CADScanConfig_t {
  uint8_t symNum;
  
  uint8_t detPeak;
  
  uint8_t detMin;
  
  uint8_t exitMode;
  
  RadioLibTime_t rxTimeout;

  RadioLibTime_t rxSymbols;

  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;

  uint16_t syncSymbols;

  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,
  RADIOLIB_MODEM_NONE,  // last entry
};

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,
};
 
#define RADIOLIB_LORA_SYNC_WORD_PRIVATE                         (0x12UL << 0)   //  7     0     LoRa sync word: private network
#define RADIOLIB_LORA_SYNC_WORD_PUBLIC                          (0x34UL << 0)   //  7     0                     public network (LoRaWAN)
 
#define RADIOLIB_LR_FHSS_CR_5_6                                 (0x00UL << 0)   //  7     0     LR-FHSS coding rate: 5/6
#define RADIOLIB_LR_FHSS_CR_2_3                                 (0x01UL << 0)   //  7     0                          2/3
#define RADIOLIB_LR_FHSS_CR_1_2                                 (0x02UL << 0)   //  7     0                          1/2
#define RADIOLIB_LR_FHSS_CR_1_3                                 (0x03UL << 0)   //  7     0                          1/3
#define RADIOLIB_LR_FHSS_BW_39_06                               (0x00UL << 0)   //  7     0     LR-FHSS bandwidth: 39.06 kHz
#define RADIOLIB_LR_FHSS_BW_85_94                               (0x01UL << 0)   //  7     0                        85.94 kHz
#define RADIOLIB_LR_FHSS_BW_136_72                              (0x02UL << 0)   //  7     0                        136.72 kHz
#define RADIOLIB_LR_FHSS_BW_183_59                              (0x03UL << 0)   //  7     0                        183.59 kHz
#define RADIOLIB_LR_FHSS_BW_335_94                              (0x04UL << 0)   //  7     0                        335.94 kHz
#define RADIOLIB_LR_FHSS_BW_386_72                              (0x05UL << 0)   //  7     0                        386.72 kHz
#define RADIOLIB_LR_FHSS_BW_722_66                              (0x06UL << 0)   //  7     0                        722.66 kHz
#define RADIOLIB_LR_FHSS_BW_773_44                              (0x07UL << 0)   //  7     0                        773.44 kHz
#define RADIOLIB_LR_FHSS_BW_1523_4                              (0x08UL << 0)   //  7     0                        1523.4 kHz
#define RADIOLIB_LR_FHSS_BW_1574_2                              (0x09UL << 0)   //  7     0                        1574.2 kHz
 
#define RADIOLIB_FLRC_BR_2600                                   (0x00UL << 0)   //  7     0     bitrate/bandwidth: 2600 kbps, 2666 kHz
#define RADIOLIB_FLRC_BR_2080                                   (0x01UL << 0)   //  7     0                        2080 kbps, 2222 kHz
#define RADIOLIB_FLRC_BR_1300                                   (0x02UL << 0)   //  7     0                        1300 kbps, 1333 kHz
#define RADIOLIB_FLRC_BR_1040                                   (0x03UL << 0)   //  7     0                        1040 kbps, 1333 kHz
#define RADIOLIB_FLRC_BR_650                                    (0x04UL << 0)   //  7     0                        650 kbps, 888 kHz
#define RADIOLIB_FLRC_BR_520                                    (0x05UL << 0)   //  7     0                        520 kbps, 769 kHz
#define RADIOLIB_FLRC_BR_325                                    (0x06UL << 0)   //  7     0                        325 kbps, 444 kHz
#define RADIOLIB_FLRC_BR_260                                    (0x07UL << 0)   //  7     0                        260 kbps, 444 kHz
#define RADIOLIB_FLRC_CR_1_2                                    (0x00UL << 0)   //  7     0     coding rate: 1/2
#define RADIOLIB_FLRC_CR_3_4                                    (0x01UL << 0)   //  7     0                  3/4
#define RADIOLIB_FLRC_CR_1_0                                    (0x02UL << 0)   //  7     0                  1 (un-coded)
#define RADIOLIB_FLRC_CR_2_3                                    (0x03UL << 0)   //  7     0                  2/3
 
#define RADIOLIB_LR_FHSS_BIT_RATE                               (488.28215f)    //  31    0     LR FHSS bit rate: 488.28215 bps
#define RADIOLIB_LR_FHSS_HEADER_BITS                            (114)           //  7     0     LR FHSS packet bit widths: header
#define RADIOLIB_LR_FHSS_FRAG_BITS                              (48)            //  7     0                                payload fragment
#define RADIOLIB_LR_FHSS_BLOCK_PREAMBLE_BITS                    (2)             //  7     0                                block preamble
#define RADIOLIB_LR_FHSS_BLOCK_BITS                             (RADIOLIB_LR_FHSS_FRAG_BITS + RADIOLIB_LR_FHSS_BLOCK_PREAMBLE_BITS)
 
struct ConfigLoRa_t {
  uint32_t frequency = RADIOLIB_UNIT_MEGA(434);
  uint32_t bandwidth = RADIOLIB_UNIT_KILO(125);
  uint8_t spreadingFactor = 9;
  uint8_t codingRate = 7;
  uint8_t syncWord = RADIOLIB_LORA_SYNC_WORD_PRIVATE;
  int8_t power = 10;
  uint16_t preambleLength = 8;
};
 
struct ConfigFSK_t {
  uint32_t frequency = RADIOLIB_UNIT_MEGA(434);
  uint32_t bitRate = 4800;
  uint32_t frequencyDeviation = RADIOLIB_UNIT_KILO(5);
  uint32_t receiverBandwidth = RADIOLIB_UNIT_KILO(125);
  int8_t power = 10;
  uint16_t preambleLength = 16;
};
 
struct ConfigBPSK_t {
  uint32_t frequency = RADIOLIB_UNIT_MEGA(434);
  uint32_t bitRate = 4800;
  int8_t power = 10;
};
 
struct ConfigOOK_t {
  uint32_t frequency = RADIOLIB_UNIT_MEGA(434);
  uint32_t bitRate = 4800;
  uint32_t receiverBandwidth = RADIOLIB_UNIT_KILO(125);
  int8_t power = 10;
  uint16_t preambleLength = 16;
};
 
struct ConfigLRFHSS_t {
  uint32_t frequency = RADIOLIB_UNIT_MEGA(434);
  uint8_t bandwidth = RADIOLIB_LR_FHSS_BW_722_66;
  uint8_t codingRate = RADIOLIB_LR_FHSS_CR_2_3;
  bool narrowGrid = true;
  int8_t power = 10;
};
 
struct ConfigFLRC_t {
  uint32_t frequency = RADIOLIB_UNIT_MEGA(434);
  uint32_t bitRate = RADIOLIB_UNIT_KILO(650);
  uint8_t codingRate = RADIOLIB_FLRC_CR_2_3;
  int8_t power = 10;
  uint16_t preambleLength = 16;
  uint8_t dataShaping = RADIOLIB_SHAPING_0_5;
};
 
struct ConfigBLE_t {
  uint32_t frequency = RADIOLIB_UNIT_MEGA(2400);
  uint16_t bitRate = 800;
  uint32_t frequencyDeviation = RADIOLIB_UNIT_KILO(400);
  int8_t power = 10;
  uint8_t dataShaping = RADIOLIB_SHAPING_0_5;
};


class PhysicalLayer {
  public:

    float freqStep;

    size_t maxPacketLength;

    bool resetOnStartup = true;
 
    // constructor

    PhysicalLayer();

    virtual ~PhysicalLayer() = default;
 
    // 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, RadioLibTime_t timeout = 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, RadioLibTime_t timeout = 0);
 
    #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();

    virtual int16_t finishReceive();
 
    #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(uint32_t freq);

    virtual int16_t setBitRate(uint32_t br);

    virtual int16_t setFrequencyDeviation(uint32_t freqDev);

    virtual int16_t setSpreadingFactor(uint8_t sf);

    virtual int16_t setBandwidth(uint32_t bw);

    virtual int16_t setCodingRate(uint8_t cr, bool longInterleave = false);

    virtual int16_t setLrFhssConfig(uint8_t bw, uint8_t cr, bool narrowGrid, uint8_t hdrCount = 3, uint16_t hopSeed = 0x13A);

    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);

    int16_t setOutputPowerOffset(int8_t offset);

    int16_t setOutputPowerOffset(const int8_t* lut, size_t steps);

    virtual int16_t setSyncWord(uint8_t* sync, size_t len);

    virtual int16_t setPreambleLength(size_t len, size_t detLen = 0xFFFFFFFF);
    
    virtual int16_t setDataRate(DataRate_t dr, ModemType_t modem = RADIOLIB_MODEM_NONE);

    virtual int16_t checkDataRate(DataRate_t dr, ModemType_t modem = RADIOLIB_MODEM_NONE);

    virtual size_t getPacketLength(bool update = true);

    virtual float getRSSI();

    virtual float getSNR();

    static float getNumSymbols(DataRate_t dr, PacketConfig_t pc, size_t len);
    
    virtual RadioLibTime_t calculateTimeOnAir(ModemType_t modem, DataRate_t dr, PacketConfig_t pc, size_t len);

    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 void setIrqAction(void (*func)(void), bool rising = true);

    virtual void clearIrqAction();

    virtual int16_t setModem(ModemType_t modem);

    virtual int16_t getModem(ModemType_t* modem);

    virtual int16_t getMode(RadioModeType_t* mode);

    virtual int16_t stageMode(RadioModeType_t mode, RadioModeConfig_t* cfg);

    virtual int16_t launchMode();

    virtual int16_t writeTxBuffer(const uint8_t* data, size_t len);

    virtual int16_t clearTxBuffer();
 
    #if RADIOLIB_INTERRUPT_TIMING

    void setInterruptSetup(void (*func)(uint32_t));

    void setTimerFlag();
 
    #endif

    int16_t calculateRxDutyCycle(size_t txPreLen, size_t rxPreLen, uint16_t minSymbols, DataRate_t* dr, uint32_t* wakePeriod, uint32_t* sleepPeriod);

    int8_t getOutputPowerMin() const { return(powerMin); }
    
    int8_t getOutputPowerMax() const { return(powerMax); }
 
#if !RADIOLIB_GODMODE
  protected:
#endif
    int8_t powerMin = 0, powerMax = 0;
    uint8_t paSteps = 0;
    
    uint32_t irqMap[10] = { 0 };
    RadioModeType_t stagedMode = RADIOLIB_RADIO_MODE_NONE;
    
    int16_t applyOutputPowerOffset(int8_t base, const int8_t* pwrReq, int8_t* pwrRadio);
    int16_t findRxBw(uint32_t rxBw, const uint32_t* rxBwAvg, const uint8_t* lut, size_t lutSize, uint32_t rxBwMax, uint8_t* val);
 
#if !RADIOLIB_EXCLUDE_DIRECT_RECEIVE
    void updateDirectBuffer(uint8_t bit);
#endif
 
#if !RADIOLIB_GODMODE
  private:
#endif
 
    #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;
 
    int8_t paOffsetLut[48] = { 0 };
};
 
#endif