SX126x.h

#if !defined(_RADIOLIB_SX126X_H)
#define _RADIOLIB_SX126X_H
 
#include "../../TypeDef.h"
 
#if !RADIOLIB_EXCLUDE_SX126X
 
#include "../../Module.h"
 
#include "../../protocols/PhysicalLayer/PhysicalLayer.h"
#include "../../utils/FEC.h"
#include "../../utils/CRC.h"
 
#include "SX126x_commands.h"
#include "SX126x_registers.h"
 
// SX126X physical layer properties
#define RADIOLIB_SX126X_FREQUENCY_STEP_SIZE                     0.9536743164
#define RADIOLIB_SX126X_MAX_PACKET_LENGTH                       255
#define RADIOLIB_SX126X_CRYSTAL_FREQ                            32.0f
#define RADIOLIB_SX126X_DIV_EXPONENT                            25
 
// LR-FHSS packet lengths
#define RADIOLIB_SX126X_LR_FHSS_MAX_ENC_SIZE                    (608)
#define RADIOLIB_SX126X_LR_FHSS_HEADER_BITS                     (114)
#define RADIOLIB_SX126X_LR_FHSS_HDR_BYTES                       (10)
#define RADIOLIB_SX126X_LR_FHSS_SYNC_WORD_BYTES                 (4)
#define RADIOLIB_SX126X_LR_FHSS_FRAG_BITS                       (48)
#define RADIOLIB_SX126X_LR_FHSS_BLOCK_PREAMBLE_BITS             (2)
#define RADIOLIB_SX126X_LR_FHSS_BLOCK_BITS                      (RADIOLIB_SX126X_LR_FHSS_FRAG_BITS + RADIOLIB_SX126X_LR_FHSS_BLOCK_PREAMBLE_BITS)
 
class SX126x: public PhysicalLayer {
  public:
    // introduce PhysicalLayer overloads
    using PhysicalLayer::transmit;
    using PhysicalLayer::receive;
    using PhysicalLayer::startTransmit;
    using PhysicalLayer::startReceive;
    using PhysicalLayer::readData;
 
    explicit SX126x(Module* mod);
 
    bool XTAL;
 
    bool standbyXOSC;
 
    // basic methods
 
    int16_t begin(uint8_t cr, uint8_t syncWord, uint16_t preambleLength, float tcxoVoltage, bool useRegulatorLDO = false);
 
    int16_t beginFSK(float br, float freqDev, float rxBw, uint16_t preambleLength, float tcxoVoltage, bool useRegulatorLDO = false);
 
    int16_t beginLRFHSS(uint8_t bw, uint8_t cr, bool narrowGrid, float tcxoVoltage, bool useRegulatorLDO = false);
 
    int16_t setLrFhssConfig(uint8_t bw, uint8_t cr, uint8_t hdrCount = 3, uint16_t hopSeqId = 0x100);
 
    int16_t reset(bool verify = true);
 
    int16_t transmit(const uint8_t* data, size_t len, uint8_t addr = 0) override;
 
    int16_t receive(uint8_t* data, size_t len, RadioLibTime_t timeout = 0) override;
 
    int16_t transmitDirect(uint32_t frf = 0) override;
 
    int16_t receiveDirect() override;
 
    int16_t scanChannel() override;
 
    int16_t scanChannel(const ChannelScanConfig_t &config) override;
 
    int16_t sleep() override; 
    
    int16_t sleep(bool retainConfig);
 
    int16_t standby() override;
 
    int16_t standby(uint8_t mode, bool wakeup = true);
 
    int16_t hopLRFHSS();
 
    // interrupt methods
 
    virtual void setDio1Action(void (*func)(void));
 
    virtual void clearDio1Action();
 
    void setPacketReceivedAction(void (*func)(void)) override;
 
    void clearPacketReceivedAction() override;
 
    void setPacketSentAction(void (*func)(void)) override;
 
    void clearPacketSentAction() override;
 
    void setChannelScanAction(void (*func)(void)) override;
 
    void clearChannelScanAction() override;
 
    int16_t finishTransmit() override;
 
    int16_t finishReceive() override;
    
    int16_t startReceive() override;
 
    int16_t startReceiveDutyCycle(uint32_t rxPeriod, uint32_t sleepPeriod, RadioLibIrqFlags_t irqFlags = RADIOLIB_IRQ_RX_DEFAULT_FLAGS, RadioLibIrqFlags_t irqMask = RADIOLIB_IRQ_RX_DEFAULT_MASK);
 
    int16_t startReceiveDutyCycleAuto(uint16_t senderPreambleLength = 0, uint16_t minSymbols = 0, RadioLibIrqFlags_t irqFlags = RADIOLIB_IRQ_RX_DEFAULT_FLAGS, RadioLibIrqFlags_t irqMask = RADIOLIB_IRQ_RX_DEFAULT_MASK);
 
    int16_t readData(uint8_t* data, size_t len) override;
    
    int16_t startChannelScan() override;
 
    int16_t startChannelScan(const ChannelScanConfig_t &config) override;
 
    int16_t getChannelScanResult() override;
 
    // configuration methods
 
    virtual int16_t setBandwidth(float bw);
 
    virtual int16_t setSpreadingFactor(uint8_t sf);
 
    int16_t setCodingRate(uint8_t cr, bool longInterleave = false);
 
    int16_t setSyncWord(uint8_t syncWord, uint8_t controlBits = 0x44);
 
    int16_t setCurrentLimit(float currentLimit);
 
    float getCurrentLimit();
 
    int16_t setPreambleLength(size_t preambleLength) override;
 
    int16_t setFrequencyDeviation(float freqDev) override;
 
    int16_t setBitRate(float br) override;
 
    int16_t setDataRate(DataRate_t dr, ModemType_t modem = RADIOLIB_MODEM_NONE) override;
 
    int16_t checkDataRate(DataRate_t dr, ModemType_t modem = RADIOLIB_MODEM_NONE) override;
 
    int16_t setRxBandwidth(float rxBw);
 
    int16_t setRxBoostedGainMode(bool rxbgm, bool persist = true);
 
    int16_t setDataShaping(uint8_t sh) override;
 
    int16_t setSyncWord(uint8_t* syncWord, size_t len) override;
 
    int16_t setSyncBits(uint8_t *syncWord, uint8_t bitsLen);
 
    int16_t setCRC(uint8_t len, uint16_t initial = 0x1D0F, uint16_t polynomial = 0x1021, bool inverted = true);
 
    int16_t setWhitening(bool enabled, uint16_t initial = 0x01FF);
 
    int16_t setTCXO(float voltage, uint32_t delay = 5000);
 
    int16_t setDio2AsRfSwitch(bool enable = true);
 
    float getDataRate() const;
 
    float getRSSI() override;
 
    float getRSSI(bool packet);
 
    float getSNR() override;
 
    float getFrequencyError();
 
    size_t getPacketLength(bool update = true) override;
 
    size_t getPacketLength(bool update, uint8_t* offset);
 
    int16_t getLoRaRxHeaderInfo(uint8_t* cr, bool* hasCRC);
 
    int16_t fixedPacketLengthMode(uint8_t len = RADIOLIB_SX126X_MAX_PACKET_LENGTH);
 
    int16_t variablePacketLengthMode(uint8_t maxLen = RADIOLIB_SX126X_MAX_PACKET_LENGTH);
 
    RadioLibTime_t calculateTimeOnAir(ModemType_t modem, DataRate_t dr, PacketConfig_t pc, size_t len) override;
 
    RadioLibTime_t getTimeOnAir(size_t len) override;
 
    RadioLibTime_t calculateRxTimeout(RadioLibTime_t timeoutUs) override;
 
    uint32_t getIrqFlags() override;
 
    int16_t setIrqFlags(uint32_t irq) override;
 
    int16_t clearIrqFlags(uint32_t irq) override;
 
    int16_t implicitHeader(size_t len);
 
    int16_t explicitHeader();
 
    int16_t setRegulatorLDO();
 
    int16_t setRegulatorDCDC();
 
    int16_t setEncoding(uint8_t encoding) override;
 
    void setRfSwitchPins(uint32_t rxEn, uint32_t txEn);
 
    void setRfSwitchTable(const uint32_t (&pins)[Module::RFSWITCH_MAX_PINS], const Module::RfSwitchMode_t table[]);
 
    int16_t forceLDRO(bool enable);
 
    int16_t autoLDRO();
 
    uint8_t randomByte() override;
 
    int16_t invertIQ(bool enable) override;
 
    int16_t getModem(ModemType_t* modem) override;
    
    int16_t stageMode(RadioModeType_t mode, RadioModeConfig_t* cfg) override;
 
    int16_t launchMode() override;
 
    #if !RADIOLIB_EXCLUDE_DIRECT_RECEIVE
    void setDirectAction(void (*func)(void)) override;
 
    void readBit(uint32_t pin) override;
    #endif
 
    int16_t uploadPatch(const uint32_t* patch, size_t len, bool nonvolatile = true);
 
    int16_t spectralScanStart(uint16_t numSamples, uint8_t window = RADIOLIB_SX126X_SPECTRAL_SCAN_WINDOW_DEFAULT, uint8_t interval = RADIOLIB_SX126X_SCAN_INTERVAL_8_20_US);
    
    void spectralScanAbort();
 
    int16_t spectralScanGetStatus();
 
    int16_t spectralScanGetResult(uint16_t* results);
 
    int16_t setPaConfig(uint8_t paDutyCycle, uint8_t deviceSel, uint8_t hpMax = RADIOLIB_SX126X_PA_CONFIG_HP_MAX, uint8_t paLut = RADIOLIB_SX126X_PA_CONFIG_PA_LUT);
 
    int16_t calibrateImage(float freq);
 
    int16_t calibrateImageRejection(float freqMin, float freqMax);
 
    int16_t setPaRampTime(uint8_t rampTime);
 
#if !RADIOLIB_GODMODE && !RADIOLIB_LOW_LEVEL
  protected:
#endif
    Module* getMod() override;
    
    // SX126x SPI command implementations
    int16_t setFs();
    int16_t setTx(uint32_t timeout = 0);
    int16_t setRx(uint32_t timeout);
    int16_t setCad(uint8_t symbolNum, uint8_t detPeak, uint8_t detMin, uint8_t exitMode, RadioLibTime_t timeout);
    int16_t writeRegister(uint16_t addr, const uint8_t* data, uint8_t numBytes);
    int16_t readRegister(uint16_t addr, uint8_t* data, uint8_t numBytes);
    int16_t writeBuffer(const uint8_t* data, uint8_t numBytes, uint8_t offset = 0x00);
    int16_t readBuffer(uint8_t* data, uint8_t numBytes, uint8_t offset = 0x00);
    int16_t setDioIrqParams(uint16_t irqMask, uint16_t dio1Mask, uint16_t dio2Mask = RADIOLIB_SX126X_IRQ_NONE, uint16_t dio3Mask = RADIOLIB_SX126X_IRQ_NONE);
    virtual int16_t clearIrqStatus(uint16_t clearIrqParams = RADIOLIB_SX126X_IRQ_ALL);
    int16_t setRfFrequency(uint32_t frf);
    int16_t calibrateImage(const uint8_t* data);
    uint8_t getPacketType();
    int16_t setTxParams(uint8_t power, uint8_t rampTime);
    int16_t setModulationParams(uint8_t sf, uint8_t bw, uint8_t cr, uint8_t ldro);
    int16_t setModulationParamsFSK(uint32_t br, uint8_t sh, uint8_t rxBw, uint32_t freqDev);
    int16_t setPacketParams(uint16_t preambleLen, uint8_t crcType, uint8_t payloadLen, uint8_t hdrType, uint8_t invertIQ);
    int16_t setPacketParamsFSK(uint16_t preambleLen, uint8_t preambleDetectorLen, uint8_t crcType, uint8_t syncWordLen, uint8_t addrCmp, uint8_t whiten, uint8_t packType = RADIOLIB_SX126X_GFSK_PACKET_VARIABLE, uint8_t payloadLen = 0xFF);
    int16_t setBufferBaseAddress(uint8_t txBaseAddress = 0x00, uint8_t rxBaseAddress = 0x00);
    int16_t setRegulatorMode(uint8_t mode);
    uint8_t getStatus();
    uint32_t getPacketStatus();
    uint16_t getDeviceErrors();
    int16_t clearDeviceErrors();
 
#if !RADIOLIB_GODMODE
  protected:
#endif
    const char* chipType = NULL;
    uint8_t bandwidth = 0;
    float freqMHz = 0;
    
    // Allow subclasses to define different TX modes
    uint8_t txMode = Module::MODE_TX;
 
    int16_t setFrequencyRaw(float freq);
    int16_t fixPaClamping(bool enable = true);
 
    // common low-level SPI interface
    static int16_t SPIparseStatus(uint8_t in);
 
#if !RADIOLIB_GODMODE
  private:
#endif
    Module* mod;
 
    uint8_t spreadingFactor = 0, codingRate = 0, ldrOptimize = 0, crcTypeLoRa = 0, headerType = 0;
    uint16_t preambleLengthLoRa = 0;
    float bandwidthKhz = 0;
    bool ldroAuto = true;
 
    uint32_t bitRate = 0, frequencyDev = 0;
    uint8_t preambleDetLength = 0, rxBandwidth = 0, pulseShape = 0, crcTypeFSK = 0, syncWordLength = 0, whitening = 0, packetType = 0;
    uint16_t preambleLengthFSK = 0;
    float rxBandwidthKhz = 0;
 
    float dataRateMeasured = 0;
 
    uint32_t tcxoDelay = 0;
    uint8_t pwr = 0;
 
    size_t implicitLen = 0;
    uint8_t invertIQEnabled = RADIOLIB_SX126X_LORA_IQ_STANDARD;
    uint32_t rxTimeout = 0;
 
    // LR-FHSS stuff - there's a lot of it because all the encoding happens in software
    uint8_t lrFhssCr = RADIOLIB_SX126X_LR_FHSS_CR_2_3;
    uint8_t lrFhssBw = RADIOLIB_SX126X_LR_FHSS_BW_722_66;
    uint8_t lrFhssHdrCount = 3;
    uint8_t lrFhssSyncWord[RADIOLIB_SX126X_LR_FHSS_SYNC_WORD_BYTES] = { 0x12, 0xAD, 0x10, 0x1B };
    bool lrFhssGridNonFcc = false;
    uint16_t lrFhssNgrid = 0;
    uint16_t lrFhssLfsrState = 0;
    uint16_t lrFhssPoly = 0;
    uint16_t lrFhssSeed = 0;
    uint16_t lrFhssHopSeqId = 0;
    size_t lrFhssFrameBitsRem = 0;
    size_t lrFhssFrameHopsRem = 0;
    size_t lrFhssHopNum = 0;
 
    int16_t modSetup(float tcxoVoltage, bool useRegulatorLDO, uint8_t modem);
    int16_t config(uint8_t modem);
    bool findChip(const char* verStr);
    int16_t startReceiveCommon(uint32_t timeout = RADIOLIB_SX126X_RX_TIMEOUT_INF, RadioLibIrqFlags_t irqFlags = RADIOLIB_IRQ_RX_DEFAULT_FLAGS, RadioLibIrqFlags_t irqMask = RADIOLIB_IRQ_RX_DEFAULT_MASK);
    int16_t setPacketMode(uint8_t mode, uint8_t len);
    int16_t setHeaderType(uint8_t hdrType, size_t len = 0xFF);
    int16_t directMode();
    int16_t packetMode();
 
    // fixes to errata
    int16_t fixSensitivity();
    int16_t fixImplicitTimeout();
    int16_t fixInvertedIQ(uint8_t iqConfig);
 
    // LR-FHSS utilities
    int16_t buildLRFHSSPacket(const uint8_t* in, size_t in_len, uint8_t* out, size_t* out_len, size_t* out_bits, size_t* out_hops);
    int16_t resetLRFHSS();
    uint16_t stepLRFHSS();
    int16_t setLRFHSSHop(uint8_t index);
 
    void regdump();
    void effectEvalPre(uint8_t* buff, uint32_t start);
    void effectEvalPost(uint8_t* buff, uint32_t start);
    void effectEval();
};
 
#endif
 
#endif