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/ConvCode.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
 
#define RADIOLIB_SX1261_POUT_MIN                                -17
#define RADIOLIB_SX1261_POUT_MAX                                15
#define RADIOLIB_SX1262_POUT_MIN                                -9
#define RADIOLIB_SX1262_POUT_MAX                                22
#define RADIOLIB_SX1268_POUT_MIN                                -9
#define RADIOLIB_SX1268_POUT_MAX                                22
#define RADIOLIB_STM32WLX_LP_POUT_MIN                           -17
#define RADIOLIB_STM32WLX_LP_POUT_MAX                           14
#define RADIOLIB_STM32WLX_HP_POUT_MIN                           -9
#define RADIOLIB_STM32WLX_HP_POUT_MAX                           22
 
// 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)
 
// convert a GFSK/BPSK bit rate in bps to the raw value used by the radio
#define RADIOLIB_SX126X_BIT_RATE_RAW(BR)                        ((uint32_t)((RADIOLIB_UNIT_MEGA(RADIOLIB_SX126X_CRYSTAL_FREQ) * 32UL) / (BR)))

class SX126x: public PhysicalLayer {
  public:
    // introduce PhysicalLayer overloads
    using PhysicalLayer::transmit;
    using PhysicalLayer::receive;
    using PhysicalLayer::startTransmit;
    using PhysicalLayer::startReceive;
    using PhysicalLayer::readData;
    using PhysicalLayer::setOutputPower;

    struct __attribute__((packed)) paTableEntry_t {
      uint8_t paDutyCycle: 4;
      uint8_t hpMax: 4;
      int8_t paVal;
    };

    explicit SX126x(Module* mod);

    RadioLibTCXOVoltage_t tcxoVoltage = Voltage1V6;

    bool useRegulatorLDO = false;
 
    // basic methods

    int16_t begin(uint8_t cr, uint8_t syncWord, uint16_t preambleLength);

    int16_t beginFSK(uint32_t br, uint32_t freqDev, uint32_t rxBw, uint16_t preambleLength);

    int16_t beginBPSK(uint32_t br);

    int16_t beginLRFHSS(uint8_t bw, uint8_t cr, bool narrowGrid);

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

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

    int16_t calibrate(uint8_t params);

    int16_t sleep() override; 
    
    int16_t sleep(bool retainConfig);

    int16_t standby() override;

    int16_t standby(uint8_t mode) override;

    int16_t standby(uint8_t mode, bool wakeup);

    int16_t hopLRFHSS();
 
    // interrupt methods

    virtual void setDio1Action(void (*func)(void));

    virtual void clearDio1Action();

    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 &cfg) override;

    int16_t getChannelScanResult() override;
 
    // configuration methods

    int16_t setBandwidth(uint32_t bw) override;

    int16_t setSpreadingFactor(uint8_t sf) override;

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

    int16_t setSyncWord(uint8_t syncWord, uint8_t controlBits = 0x44);

    int16_t setCurrentLimit(float currentLimit);

    float getCurrentLimit();

    int16_t setPreambleLength(size_t len, size_t detLen = 0xFFFFFFFF) override;

    int16_t setFrequencyDeviation(uint32_t freqDev) override;

    int16_t setBitRate(uint32_t br) override;

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

    int16_t setRxBandwidth(uint32_t 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 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(RadioLibTCXOVoltage_t voltage, uint32_t delay = 5000);

    int16_t setDio2AsRfSwitch(bool enable = true);

    float getRSSI() override;

    float getRSSI(bool packet);

    float getSNR() override;

    int32_t 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 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 getMode(RadioModeType_t* mode) override;
    
    int16_t stageMode(RadioModeType_t mode, RadioModeConfig_t* cfg) override;

    int16_t launchMode() override;

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

    int16_t clearTxBuffer() 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(uint32_t freq);

    int16_t calibrateImageRejection(uint32_t freqMin, uint32_t freqMax);

    int16_t setPaRampTime(uint8_t rampTime);

    int16_t setOutputPower(int8_t power, uint8_t paDutyCycle, uint8_t hpMax, uint8_t deviceSel);

    void setPaTable(SX126x::paTableEntry_t* table);
    
    int16_t setStandbyXOSC(bool enable);
 
#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 setModulationParamsBPSK(uint32_t br, uint8_t sh = RADIOLIB_SX126X_BPSK_PULSE_SHAPE);
    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 setPacketParamsBPSK(uint8_t payloadLen, uint16_t rampUpDelay, uint16_t rampDownDelay, uint16_t payloadLenBits);
    int16_t setBufferBaseAddress(uint8_t txBaseAddress = 0x00, uint8_t rxBaseAddress = 0x00);
    int16_t setRegulatorMode(uint8_t mode);
    int16_t setLoRaSymbNumTimeout(uint8_t symbolNum);
    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;
    uint32_t freqHz = 0;
    
    // Allow subclasses to define different TX modes
    uint8_t txMode = Module::MODE_TX;
 
    // pointer to PA lookup table - may be overridden by the user
    SX126x::paTableEntry_t* paOptTable = nullptr;
 
    int16_t setFrequencyRaw(uint32_t 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;
    uint32_t bandwidthHz = 0;
    bool ldroAuto = true;
    bool standbyXOSC = false;
 
    uint32_t bitRateRaw = 0, frequencyDev = 0;
    uint8_t preambleDetLength = 0, rxBandwidth = 0, pulseShape = 0, crcTypeFSK = 0, syncWordLength = 0, whitening = 0, packetType = 0;
    uint16_t preambleLengthFSK = 0;
    uint32_t rxBandwidthHz = 0;
 
    uint32_t tcxoDelay = 0;
    uint8_t pwr = 0;
    bool dio2RfSwitch = false;
    bool rxBoostedGainMode = false;
 
    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(uint8_t modem);
    int16_t config(uint8_t modem);
    bool findChip(const char* verStr);
    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);
    int16_t fixGFSK();
 
    // 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);
};
 
#endif
 
#endif