LR2021.h

#if !defined(RADIOLIB_LR2021_H)
#define RADIOLIB_LR2021_H
 
#include "../../TypeDef.h"
 
#if !RADIOLIB_EXCLUDE_LR2021
 
#include "../../Module.h"
 
#include "../../protocols/PhysicalLayer/PhysicalLayer.h"
#include "../LR11x0/LR_common.h"
#include "LR2021_commands.h"
#include "LR2021_types.h"
 
// LR2021 physical layer properties
#define RADIOLIB_LR2021_FREQUENCY_STEP_SIZE                     1.0
#define RADIOLIB_LR2021_MAX_PACKET_LENGTH                       255
#define RADIOLIB_LR2021_CRYSTAL_FREQ                            32.0
#define RADIOLIB_LR2021_DIV_EXPONENT                            25
#define RADIOLIB_LR2021_LF_POUT_MIN                             -9
#define RADIOLIB_LR2021_LF_POUT_MAX                             22
#define RADIOLIB_LR2021_HF_POUT_MIN                             -19
#define RADIOLIB_LR2021_HF_POUT_MAX                             12
 
// LR20xx device types - one driver serves the family, but the parts differ in what they support
#define RADIOLIB_LR2021_DEVICE_LR2021                           (0x00)
#define RADIOLIB_LR2021_DEVICE_LR2022                           (0x01)
#define RADIOLIB_LR2021_DEVICE_LR2012                           (0x02)
 
// GetVersion firmware versions, LR20xx datasheet Rev. 2.2 section 6.7.2 - LR2022 and LR2012 share one
#define RADIOLIB_LR2021_FW_LR2021                               (0x0118)
#define RADIOLIB_LR2021_FW_LR20X2                               (0x0200)

class LR2021: public LRxxxx {
  public:
    // introduce PhysicalLayer overloads
    using PhysicalLayer::transmit;
    using PhysicalLayer::receive;
    using PhysicalLayer::startTransmit;
    using PhysicalLayer::startReceive;
    using PhysicalLayer::readData;

    LR2021(Module* mod); // cppcheck-suppress noExplicitConstructor

    uint32_t irqDioNum = 5;

    bool fastCad = false;

    enum OpMode_t {
        MODE_END_OF_TABLE = Module::MODE_END_OF_TABLE,
        MODE_STBY = Module::MODE_IDLE,
        MODE_RX = Module::MODE_RX,
        MODE_TX = Module::MODE_TX,
        MODE_RX_HF,
        MODE_TX_HF,
    };

    RadioLibTCXOVoltage_t tcxoVoltage = Voltage1V6;
 
    // basic methods

    int16_t begin(const ConfigLoRa_t& config);

    int16_t beginGFSK(const ConfigFSK_t& config);

    int16_t beginOOK(const ConfigOOK_t& config);

    int16_t beginLRFHSS(const ConfigLRFHSS_t& config);

    int16_t beginFLRC(const ConfigFLRC_t& config);

    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 standby() override;

    int16_t standby(uint8_t mode) override;

    int16_t standby(uint8_t mode, bool wakeup);

    int16_t sleep() override;

    int16_t sleep(bool retainConfig, uint32_t sleepTime);

    size_t getPacketLength(bool update = true) override;
 
    // interrupt methods

    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 finishReceive() override;
    
    int16_t startChannelScan() override;

    int16_t startChannelScan(const ChannelScanConfig_t &cfg) override;

    int16_t getChannelScanResult() override;

    uint32_t getIrqFlags() override;

    int16_t setIrqFlags(uint32_t irq) override;

    int16_t clearIrqFlags(uint32_t irq) override;
    
    int16_t setModem(ModemType_t modem) override;
    
    // configuration methods

    int16_t setFrequency(uint32_t freq) override;

    int16_t setFrequency(uint32_t freq, bool skipCalibration);

    int16_t setOutputPower(int8_t power) override;

    int16_t setOutputPower(int8_t power, uint32_t rampTimeUs);

    void setPaTable(LR2021PaTableEntry_t* table, bool highFreq);

    int16_t setStandbyXOSC(bool enable);
    
    void setRfSwitchTable(const uint32_t (&pins)[Module::RFSWITCH_MAX_PINS], const Module::RfSwitchMode_t table[]);

    int16_t forceLDRO(bool enable);

    int16_t autoLDRO();

    int16_t setBandwidth(uint32_t bw) override;

    int16_t setSpreadingFactor(uint8_t sf) override;

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

    int16_t setSyncWord(uint8_t syncWord);

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

    int16_t setTCXO(RadioLibTCXOVoltage_t voltage, uint32_t delay = 1000000);

    int16_t setCRC(uint8_t len, uint32_t initial = 0x00001D0FUL, uint32_t polynomial = 0x00001021UL, bool inverted = true);

    int16_t invertIQ(bool enable) override;

    int16_t setBitRate(uint32_t br) override;

    int16_t setFrequencyDeviation(uint32_t freqDev) override;

    int16_t setRxBandwidth(uint32_t rxBw);
    
    int16_t setSyncWord(uint8_t* syncWord, size_t len) override;

    int16_t setNodeAddress(uint8_t nodeAddr);

    int16_t setBroadcastAddress(uint8_t broadAddr);

    int16_t disableAddressFiltering();

    int16_t setDataShaping(uint8_t sh) override;

    int16_t setEncoding(uint8_t encoding) override;

    int16_t fixedPacketLengthMode(uint8_t len = RADIOLIB_LR2021_MAX_PACKET_LENGTH);

    int16_t variablePacketLengthMode(uint8_t maxLen = RADIOLIB_LR2021_MAX_PACKET_LENGTH);

    int16_t setWhitening(bool enabled, uint16_t initial = 0x01FF);

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

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

    int16_t setRxBoostedGainMode(uint8_t level);

    RadioLibTime_t getTimeOnAir(size_t len) 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;

    float getVoltage(uint8_t bits = 13);
    
    float getTemperature(uint8_t source, uint8_t bits = 13);

    float getRSSI() override;

    float getRSSI(bool packet, bool skipReceive = false);

    float getSNR() override;

    int32_t getFrequencyError();

    uint8_t randomByte() override;

    int16_t implicitHeader(size_t len);

    int16_t explicitHeader();

    int16_t ookDetector(uint16_t pattern = 0x0285, uint8_t len = 16, uint8_t repeats = 0, bool syncRaw = false, bool rising = false, uint8_t sofLen = 0);
    
    int16_t setOokDetectionThreshold(int16_t level);

    int16_t setSideDetector(const LR2021LoRaSideDetector_t* cfg, size_t numDetectors);

    int16_t setGain(uint8_t gain);

    int16_t setTempCompensationInternal(uint8_t mode);

    int16_t setTempCompensationNTC(uint8_t mode, uint16_t rRatio, uint16_t betaK, uint8_t delay);

    int16_t getLoRaPacketStatus(uint8_t* cr, bool* crc, uint8_t* packetLen = NULL, float* snrPacket = NULL, float* rssiPacket = NULL, float* rssiSignalPacket = NULL, uint8_t* detector = NULL, int32_t* freqError = NULL);

    int16_t getLoRaRxHeaderInfo(uint8_t* cr, bool* hasCRC);
    
    int16_t getErrors(uint16_t* err);
    
    int16_t getLoRaRxStats(uint16_t* pktRxTotal, uint16_t* pktCrcError, uint16_t* headerCrcError, uint16_t* falseSynch);
    
    int16_t getRangingStats(uint16_t* exchangeValid, uint16_t* requestValid, uint16_t* responseDone, uint16_t* timeout, uint16_t* requestDiscarded);
    
    int16_t getGfskRxStats(uint16_t* packetRx, uint16_t* packetCrcError, uint16_t* lenError, uint16_t* preambleDet, uint16_t* syncOk, uint16_t* syncFail, uint16_t* timeout);
    
    int16_t getOqpskRxStats(uint16_t* packetRx, uint16_t* crcError, uint16_t* lenError);
    
    int16_t getFlrcRxStats(uint16_t* packetRx, uint16_t* packetCrcError, uint16_t* lenError);
    
    int16_t getOokRxStats(uint16_t* packetRx, uint16_t* crcError, uint16_t* lenError);

    int16_t setRegulatorLDO();

    int16_t setRegulatorDCDC();

    int16_t setFifoSize(bool rx, size_t size);

    int16_t setIQStream(uint32_t rate, bool fifo);

    int16_t getFifoIrqFlags(uint8_t* rxFifoFlags, uint8_t* txFifoFlags);
    
    int16_t clearFifoIrqFlags(uint8_t rxFifoFlags, uint8_t txFifoFlags);
    
    int16_t getRxFifoLevel(uint16_t* level);
    
    int16_t getTxFifoLevel(uint16_t* level);

    int16_t readRadioRxFifo(uint8_t* data, size_t len);
 
#if !RADIOLIB_GODMODE && !RADIOLIB_LOW_LEVEL
  protected:
#endif
    Module* getMod() override;
    
#if !RADIOLIB_GODMODE
  protected:
#endif
    uint8_t chipType = RADIOLIB_LR2021_DEVICE_LR2021;
 
#if !RADIOLIB_GODMODE
  private:
#endif
    uint8_t gainModeLf = RADIOLIB_LR2021_RX_BOOST_LF;
    uint8_t gainModeHf = RADIOLIB_LR2021_RX_BOOST_HF;
 
    bool standbyXOSC = false;
 
    // cached FLRC parameters
    uint16_t bitRateFlrc = 0;
    uint8_t codingRateFlrc = 0;
 
    // pointers to PA lookup tables - may be overridden by the user
    LR2021PaTableEntry_t* paOptTable[2] = { nullptr, nullptr };
 
    int16_t modSetup(uint32_t freq, uint8_t modem);
    bool findChip(void);
    const char* chipName(void) const;
    bool subGhzOnly(void) const;
    int16_t config(uint8_t modem);
    int16_t setPacketMode(uint8_t mode, uint8_t len);
    int16_t startCad(uint8_t symbolNum, uint8_t detPeak, bool fast, uint8_t exitMode, RadioLibTime_t timeout);
    void updatePowerLimits(bool highFreq);
 
    // chip control commands
    int16_t writeRadioTxFifo(const uint8_t* data, size_t len);
    int16_t writeRegMem32(uint32_t addr, const uint32_t* data, size_t len);
    int16_t writeRegMemMask32(uint32_t addr, uint32_t mask, uint32_t data);
    int16_t readRegMem32(uint32_t addr, uint32_t* data, size_t len);
    int16_t setFs(void);
    int16_t setAdditionalRegToRetain(uint8_t slot, uint32_t addr);
    int16_t setRx(uint32_t timeout);
    int16_t setTx(uint32_t timeout);
    int16_t setRxTxFallbackMode(uint8_t mode);
    int16_t setRxDutyCycle(uint32_t rxMaxTime, uint32_t cycleTime, uint8_t mode);
    int16_t autoTxRx(uint32_t delay, uint8_t mode, uint32_t timeout);
    int16_t getRxPktLength(uint16_t* len);
    int16_t resetRxStats(void);
    int16_t setDefaultRxTxTimeout(uint32_t rxTimeout, uint32_t txTimeout);
    int16_t setRegMode(uint8_t mode);
    int16_t calibrate(uint8_t blocks);
    int16_t calibrateFrontEnd(const uint16_t freq[3]);
    int16_t getVbat(uint8_t resolution, uint16_t* vbat);
    int16_t getTemp(uint8_t source, uint8_t resolution, float* temp);
    int16_t setEolConfig(bool enable, uint8_t trim);
    int16_t getRandomNumber(uint32_t* rnd);
    int16_t getVersion(uint8_t* major, uint8_t* minor);
    int16_t clearErrors(void);
    int16_t setDioFunction(uint8_t dio, uint8_t func, uint8_t pullDrive);
    int16_t setDioRfSwitchConfig(uint8_t dio, uint8_t func);
    int16_t setDioIrqConfig(uint8_t dio, uint32_t irq);
    int16_t clearIrqState(uint32_t irq);
    int16_t getAndClearIrqStatus(uint32_t* irq);
    int16_t configFifoIrq(uint8_t rxFifoIrq, uint8_t txFifoIrq, uint16_t rxHighThreshold, uint16_t txLowThreshold, uint16_t rxLowThreshold, uint16_t txHighThreshold);
    int16_t getAndClearFifoIrqFlags(uint8_t* rxFifoFlags, uint8_t* txFifoFlags);
    int16_t clearRxFifo(void);
    int16_t clearTxFifo(void);
    int16_t configLfClock(uint8_t cfg);
    int16_t configClkOutputs(uint8_t scaling);
    int16_t setTcxoMode(uint8_t tune, uint32_t startTime);
    int16_t setXoscCpTrim(uint8_t xta, uint8_t xtb, uint8_t startTime);
    int16_t activatePram(void);
    int16_t checkPramLoaded(bool* loaded);
    int16_t getPramVersion(uint16_t* version);
 
    // radio frequency front end commands
    int16_t setRfFrequency(uint32_t rfFreq);
    int16_t setRxPath(uint8_t rxPath, uint8_t rxBoost);
    int16_t getRssiInst(float* rssi);
    int16_t setRssiCalibration(uint8_t rxPath, const uint16_t gain[RADIOLIB_LR2021_GAIN_TABLE_LENGTH], const uint8_t noiseFloor[RADIOLIB_LR2021_GAIN_TABLE_LENGTH]);
    int16_t setTimestampSource(uint8_t index, uint8_t source);
    int16_t getTimestampValue(uint8_t index, uint32_t* timestamp);
    int16_t setCca(uint32_t duration, uint8_t gain);
    int16_t getCcaResult(float* rssiMin, float* rssiMax, float* rssiAvg);
    int16_t setCadParams(uint32_t cadTimeout, uint8_t threshold, uint8_t exitMode, uint32_t trxTimeout);
    int16_t setCad(void);
    int16_t selPa(uint8_t pa);
    int16_t setPaConfig(uint8_t pa, uint8_t paLfMode, uint8_t paLfDutyCycle, uint8_t paLfSlices, uint8_t paHfDutyCycle);
    int16_t setTxParams(int8_t txPower, uint8_t rampTime);
 
    // modem configuration commands
    int16_t setPacketType(uint8_t packetType);
    int16_t getPacketType(uint8_t* packetType);
 
    // LoRa commands
    int16_t setLoRaModulationParams(uint8_t sf, uint8_t bw, uint8_t cr, uint8_t ldro);
    int16_t setLoRaPacketParams(uint16_t preambleLen, uint8_t hdrType, uint8_t payloadLen, uint8_t crcType, uint8_t invertIQ);
    int16_t setLoRaSynchTimeout(uint16_t numSymbols);
    int16_t setLoRaSyncword(uint8_t syncword);
    int16_t setLoRaSideDetConfig(uint8_t* configs, size_t numSideDets);
    int16_t setLoRaSideDetSyncword(uint8_t* syncwords, size_t numSideDets);
    int16_t setLoRaCadParams(uint8_t numSymbols, bool preambleOnly, uint8_t pnrDelta, uint8_t cadExitMode, uint32_t timeout, uint8_t detPeak);
    int16_t setLoRaCad(void);
    int16_t setLoRaAddress(uint8_t addrLen, uint8_t addrPos, const uint8_t* addr);
    int16_t setLoRaHopping(uint8_t hopCtrl, uint16_t hopPeriod, const uint32_t* freqHops, size_t numFreqHops);
    int16_t setLoRaTxSync(uint8_t function, uint8_t dioNum);
    int16_t setLoRaSideDetCad(const uint8_t* pnrDelta, const uint8_t* detPeak, size_t numSideDets);
    int16_t setLoRaHeaderType(uint8_t hdrType, size_t len = RADIOLIB_LR2021_MAX_PACKET_LENGTH);
 
    // ranging commands
    int16_t setRangingAddr(uint32_t addr, uint8_t checkLen);
    int16_t setRangingReqAddr(uint32_t addr);
    int16_t getRangingResult(uint8_t type, uint32_t* rng1, uint8_t* rssi1, uint32_t* rng2);
    int16_t setRangingTxRxDelay(uint32_t delay);
    int16_t setRangingParams(bool spyMode, uint8_t nbSymbols);
 
    // GFSK commands
    int16_t setGfskModulationParams(uint32_t bitRate, uint8_t pulseShape, uint8_t rxBw, uint32_t freqDev);
    int16_t setGfskPacketParams(uint16_t preambleLen, uint8_t preambleDetect, bool longPreamble, bool pldLenBits, uint8_t addrComp, uint8_t packetFormat, uint16_t payloadLen, uint8_t crc, uint8_t dcFree);
    int16_t setGfskWhiteningParams(uint8_t whitenType, uint16_t init);
    int16_t setGfskCrcParams(uint32_t poly, uint32_t init);
    int16_t setGfskSyncword(const uint8_t* syncWord, size_t syncWordLen, bool msbFirst);
    int16_t setGfskAddress(uint8_t addrNode, uint8_t addrBroadcast);
    int16_t getGfskPacketStatus(uint16_t* packetLen, float* rssiAvg, float* rssiSync, bool* addrMatchNode, bool* addrMatchBroadcast, float* lqi);
 
    // OQPSK commands
    int16_t setOqpskParams(uint8_t mode, uint8_t rxBw, uint8_t payloadLen, uint16_t preambleLen, bool addrFilt, bool fcsManual);
    int16_t getOqpskPacketStatus(uint8_t* rxHeader, uint16_t* payloadLen, float* rssiAvg, float* rssiSync, float* lqi);
    int16_t setOqpskPacketLen(uint8_t len);
    int16_t setOqpskAddress(const uint8_t longDestAddr[8], uint16_t shortDestAddr, uint16_t panId, uint8_t transId);
 
    // BPSK commands
    int16_t setBpskModulationParams(uint32_t bitRate, uint8_t pulseShape, bool diff, uint8_t diffInit);
    int16_t setBpskPacketParams(uint8_t payloadLen, uint8_t mode, bool sigFoxControlMsg, uint8_t sigFoxRank);
 
    // FLRC commands
    int16_t setFlrcModulationParams(uint8_t brBw, uint8_t cr, uint8_t pulseShape);
    int16_t setFlrcPacketParams(uint8_t agcPreambleLen, uint8_t syncWordLen, uint8_t syncWordTx, uint8_t syncMatch, bool fixedLength, uint8_t crc, uint16_t payloadLen);
    int16_t getFlrcPacketStatus(uint16_t* packetLen, float* rssiAvg, float* rssiSync, uint8_t* syncWordNum, int32_t* freqError);
    int16_t setFlrcSyncWord(uint8_t syncWordNum, uint32_t syncWord);
 
    // LR-FHSS commands
    int16_t lrFhssSetSyncword(uint32_t syncWord);
    //int16_t readLrFhssHoppingTable(LR2021LrFhssHopTableEntry_t* hopTable[40], size_t* hopTableLen);
    //int16_t writeLrFhssHoppingTable(LR2021LrFhssHopTableEntry_t* hopTable[40], size_t hopTableLen);
 
    // OOK commands
    int16_t setOokModulationParams(uint32_t bitRate, uint8_t pulseShape, uint8_t rxBw, uint8_t depth);
    int16_t setOokPacketParams(uint16_t preambleLen, uint8_t addrComp, uint8_t packetFormat, uint16_t payloadLen, uint8_t crc, uint8_t manchester);
    int16_t setOokCrcParams(uint32_t poly, uint32_t init);
    int16_t setOokSyncword(const uint8_t* syncWord, size_t syncWordLen, bool msbFirst);
    int16_t setOokAddress(uint8_t addrNode, uint8_t addrBroadcast);
    int16_t getOokPacketStatus(uint16_t* packetLen, float* rssiAvg, float* rssiHigh, bool* addrMatchNode, bool* addrMatchBroadcast, float* lqi);
    int16_t setOokDetector(uint16_t preamblePattern, uint8_t patternLen, uint8_t patternNumRepeaters, bool syncWordRaw, bool sofDelimiterRising, uint8_t sofDelimiterLen);
    int16_t setOokWhiteningParams(uint8_t bitIdx, uint16_t poly, uint16_t init);
 
    // test commands
    int16_t setTxTestMode(uint8_t mode);
 
    // port of semtech's workaround
    int16_t setDCDCworkaround();
    int16_t resetDCDCworkaround();
};
#endif
 
#endif