Merge pull request ExpressLRS#3353 from pkendall64/desync+optmised-tx

Optimised TX + Continuous mode RX

Author: pkendall64

src/lib/LBT/LBT.cpp

@@ -2,6 +2,7 @@
 #include "common.h"
 #include "logging.h"
 #include "LBT.h"
+#include "POWERMGNT.h"
 #include "config.h"
 
 LQCALC<100> LBTSuccessCalc;
@@ -11,10 +12,10 @@ static uint32_t rxStartTime;
   #define LBT_RSSI_THRESHOLD_OFFSET_DB 0
 #endif
 
-static bool LBTEnabled = false;
+bool LbtIsEnabled = false;
 static uint32_t validRSSIdelayUs = 0;
 
-static uint32_t ICACHE_RAM_ATTR SpreadingFactorToRSSIvalidDelayUs(uint8_t SF, uint8_t radio_type)
+static uint32_t SpreadingFactorToRSSIvalidDelayUs(uint8_t SF, uint8_t radio_type)
 {
 #if defined(RADIO_LR1121)
   if (radio_type == RADIO_TYPE_LR1121_LORA_2G4 || radio_type == RADIO_TYPE_LR1121_LORA_DUAL)
@@ -30,7 +31,7 @@ static uint32_t ICACHE_RAM_ATTR SpreadingFactorToRSSIvalidDelayUs(uint8_t SF, ui
   }
   if (radio_type == RADIO_TYPE_LR1121_GFSK_2G4)
   {
-    return 20; // 20us settling time (seems fine when testing)
+    return 40; // 40us settling time; documentation says Twait for 467 kHz bandwidth is 30.68us
   }
 #elif defined(RADIO_SX128X)
   // The necessary wait time from RX start to valid instant RSSI reading
@@ -66,15 +67,14 @@ static uint32_t ICACHE_RAM_ATTR SpreadingFactorToRSSIvalidDelayUs(uint8_t SF, ui
     return 60 + 20; // switching time (60us) + 20us settling time (seems fine when testing)
   }
 #endif
-  ERRLN("LBT not supported on this radio type");
   return 0;
 }
 
-void EnableLBT()
+void LbtEnableIfRequired()
 {
-    LBTEnabled = config.GetPower() > PWR_10mW;
+    LbtIsEnabled = config.GetPower() > PWR_10mW;
 #if defined(RADIO_LR1121)
-    LBTEnabled = LBTEnabled && (ExpressLRS_currAirRate_Modparams->radio_type == RADIO_TYPE_LR1121_LORA_2G4 || ExpressLRS_currAirRate_Modparams->radio_type == RADIO_TYPE_LR1121_GFSK_2G4 || ExpressLRS_currAirRate_Modparams->radio_type == RADIO_TYPE_LR1121_LORA_DUAL);
+    LbtIsEnabled = LbtIsEnabled && (ExpressLRS_currAirRate_Modparams->radio_type == RADIO_TYPE_LR1121_LORA_2G4 || ExpressLRS_currAirRate_Modparams->radio_type == RADIO_TYPE_LR1121_GFSK_2G4 || ExpressLRS_currAirRate_Modparams->radio_type == RADIO_TYPE_LR1121_LORA_DUAL);
 #endif
     validRSSIdelayUs = SpreadingFactorToRSSIvalidDelayUs(ExpressLRS_currAirRate_Modparams->sf, ExpressLRS_currAirRate_Modparams->radio_type);
 }
@@ -138,36 +138,25 @@ static int8_t ICACHE_RAM_ATTR PowerEnumToLBTLimit(PowerLevels_e txPower, uint8_t
     }
   }
 #endif
-  ERRLN("LBT not supported on this radio type");
   return 0;
 }
 
-void ICACHE_RAM_ATTR SetClearChannelAssessmentTime(void)
+void ICACHE_RAM_ATTR LbtCcaTimerStart(void)
 {
-  if (!LBTEnabled)
+  if (!LbtIsEnabled)
     return;
 
-#if defined(TARGET_TX)
-#if defined(RADIO_LR1121)
-  Radio.RXnb(LR1121_MODE_RX, validRSSIdelayUs);
-#elif defined(RADIO_SX128X)
-  Radio.RXnb(SX1280_MODE_RX, validRSSIdelayUs);
-#else
-#error No continuous receive mode defined for this radio type
-#endif
-#endif
-
   rxStartTime = micros();
 }
 
-SX12XX_Radio_Number_t ICACHE_RAM_ATTR ChannelIsClear(SX12XX_Radio_Number_t radioNumber)
+SX12XX_Radio_Number_t ICACHE_RAM_ATTR LbtChannelIsClear(SX12XX_Radio_Number_t radioNumber)
 {
   if (radioNumber == SX12XX_Radio_NONE)
     return SX12XX_Radio_NONE;
 
   LBTSuccessCalc.inc(); // Increment count for every channel check
 
-  if (!LBTEnabled)
+  if (!LbtIsEnabled)
   {
     LBTSuccessCalc.add();
     return radioNumber;
@@ -218,7 +207,7 @@ SX12XX_Radio_Number_t ICACHE_RAM_ATTR ChannelIsClear(SX12XX_Radio_Number_t radio
   if (radioNumber & SX12XX_Radio_2)
   {
     rssiInst2 = Radio.GetRssiInst(SX12XX_Radio_2);
-    
+
     if(rssiInst2 < rssiCutOff)
     {
         clearChannelsMask |= SX12XX_Radio_2;

src/lib/LBT/LBT.h

@@ -1,15 +1,18 @@
-#if defined(Regulatory_Domain_EU_CE_2400)
 #pragma once
+#include "SX12xxDriverCommon.h"
 
-#include "POWERMGNT.h"
+#if defined(Regulatory_Domain_EU_CE_2400)
 #include "LQCALC.h"
-#include "SX12xxDriverCommon.h"
 
 extern LQCALC<100> LBTSuccessCalc;
+extern bool LbtIsEnabled;
 
-void EnableLBT();
-void ICACHE_RAM_ATTR SetClearChannelAssessmentTime(void);
-SX12XX_Radio_Number_t ICACHE_RAM_ATTR ChannelIsClear(SX12XX_Radio_Number_t radioNumber);
+void LbtEnableIfRequired();
+void ICACHE_RAM_ATTR LbtCcaTimerStart();
+SX12XX_Radio_Number_t ICACHE_RAM_ATTR LbtChannelIsClear(SX12XX_Radio_Number_t radioNumber);
 #else
-inline void EnableLBT() {}
+static constexpr bool LbtIsEnabled = false;
+static inline void LbtEnableIfRequired() {}
+static inline void LbtCcaTimerStart() {}
+static inline SX12XX_Radio_Number_t LbtChannelIsClear(SX12XX_Radio_Number_t radioNumber) { return radioNumber; }
 #endif

src/lib/LR1121Driver/LR1121.cpp

@@ -18,14 +18,10 @@ static uint32_t beginTX;
 static uint32_t endTX;
 #endif
 
-// RxTimeout is expressed in periods of the 32.768kHz RTC
-#define RX_TIMEOUT_PERIOD_BASE_NANOS 1000000000 / 32768 // TODO check for LR1121
-
 LR1121Driver::LR1121Driver(): SX12xxDriverCommon()
 {
     useFSK = false;
     instance = this;
-    timeout = 0xFFFFFF;
     lastSuccessfulPacketRadio = SX12XX_Radio_1;
     fallBackMode = LR1121_MODE_FS;
     useFEC = false;
@@ -131,12 +127,12 @@ transitioning from FS mode and the other from Standby mode. This causes the tx d
 void LR1121Driver::startCWTest(uint32_t freq, SX12XX_Radio_Number_t radioNumber)
 {
     // Set a basic Config that can be used for both 2.4G and SubGHz bands.
-    Config(LR11XX_RADIO_LORA_BW_62, LR11XX_RADIO_LORA_SF6, LR11XX_RADIO_LORA_CR_4_8, freq, 12, false, 8, 0, false, 0, 0, radioNumber);
+    Config(LR11XX_RADIO_LORA_BW_62, LR11XX_RADIO_LORA_SF6, LR11XX_RADIO_LORA_CR_4_8, freq, 12, false, 8, false, 0, 0, radioNumber);
     hal.WriteCommand(LR11XX_RADIO_SET_TX_CW_OC, radioNumber);
 }
 
 void LR1121Driver::Config(uint8_t bw, uint8_t sf, uint8_t cr, uint32_t regfreq,
-                          uint8_t PreambleLength, bool InvertIQ, uint8_t _PayloadLength, uint32_t rxtimeout,
+                          uint8_t PreambleLength, bool InvertIQ, uint8_t _PayloadLength,
                           bool setFSKModulation, uint8_t fskSyncWord1, uint8_t fskSyncWord2,
                           SX12XX_Radio_Number_t radioNumber)
 {
@@ -158,8 +154,6 @@ void LR1121Driver::Config(uint8_t bw, uint8_t sf, uint8_t cr, uint32_t regfreq,
         inverted = LR11XX_RADIO_LORA_IQ_STANDARD;
     }
 
-    SetRxTimeoutUs(rxtimeout);
-
     SetMode(LR1121_MODE_STDBY_RC, radioNumber);
 
     useFSK = setFSKModulation;
@@ -201,7 +195,7 @@ void LR1121Driver::Config(uint8_t bw, uint8_t sf, uint8_t cr, uint32_t regfreq,
         SetPacketParamsLoRa(PreambleLength, packetLengthType, PayloadLength, inverted, radioNumber);
     }
 
-    SetFrequencyHz(regfreq, radioNumber);
+    SetFrequencyReg(regfreq, radioNumber, false);
 
     ClearIrqStatus(radioNumber);
 
@@ -282,15 +276,6 @@ void LR1121Driver::SetDioAsRfSwitch()
     hal.WriteCommand(LR11XX_SYSTEM_SET_DIO_AS_RF_SWITCH_OC, switchbuf, sizeof(switchbuf), SX12XX_Radio_All);
 }
 
-void LR1121Driver::SetRxTimeoutUs(uint32_t interval)
-{
-    timeout = 0xFFFFFF; // no timeout, continuous mode
-    if (interval)
-    {
-        timeout = interval * 1000 / RX_TIMEOUT_PERIOD_BASE_NANOS;
-    }
-}
-
 void LR1121Driver::CorrectRegisterForSF6(uint8_t sf, SX12XX_Radio_Number_t radioNumber)
 {
     // 8.3.1 SetModulationParams
@@ -431,10 +416,9 @@ void ICACHE_RAM_ATTR LR1121Driver::SetPaConfig(bool isSubGHz, SX12XX_Radio_Numbe
     hal.WriteCommand(LR11XX_RADIO_SET_PA_CFG_OC, Pabuf, sizeof(Pabuf), radioNumber);
 }
 
-void LR1121Driver::SetMode(lr11xx_RadioOperatingModes_t OPmode, SX12XX_Radio_Number_t radioNumber, uint32_t incomingTimeout)
+void LR1121Driver::SetMode(lr11xx_RadioOperatingModes_t OPmode, SX12XX_Radio_Number_t radioNumber)
 {
     WORD_ALIGNED_ATTR uint8_t buf[5] = {0};
-    uint32_t tempTimeout;
 
     switch (OPmode)
     {
@@ -460,20 +444,6 @@ void LR1121Driver::SetMode(lr11xx_RadioOperatingModes_t OPmode, SX12XX_Radio_Num
         hal.WriteCommand(LR11XX_SYSTEM_SET_FS_OC, radioNumber);
         break;
 
-    case LR1121_MODE_RX:
-        // 7.2.2 SetRx
-        tempTimeout = incomingTimeout ? (incomingTimeout * 1000 / RX_TIMEOUT_PERIOD_BASE_NANOS) : timeout;
-
-        // incomingTimeout is below the minimum period so lets set it to 1.
-        if (incomingTimeout && !tempTimeout)
-            tempTimeout = 1;
-
-        buf[0] = tempTimeout >> 16;
-        buf[1] = tempTimeout >> 8;
-        buf[2] = tempTimeout & 0xFF;
-        hal.WriteCommand(LR11XX_RADIO_SET_RX_OC, buf, 3, radioNumber);
-        break;
-
     case LR1121_MODE_RX_CONT:
         // 7.2.2 SetRx
         buf[0] = 0xFF;
@@ -529,24 +499,31 @@ void LR1121Driver::SetPacketParamsLoRa(uint8_t PreambleLength, lr11xx_RadioLoRaP
     hal.WriteCommand(LR11XX_RADIO_SET_PKT_PARAM_OC, buf, sizeof(buf), radioNumber);
 }
 
-void ICACHE_RAM_ATTR LR1121Driver::SetFrequencyHz(uint32_t freq, SX12XX_Radio_Number_t radioNumber)
+void ICACHE_RAM_ATTR LR1121Driver::SetFrequencyReg(uint32_t freq, SX12XX_Radio_Number_t radioNumber, bool doRx, uint32_t rxTime)
 {
-    // 7.2.1 SetRfFrequency
-    uint8_t buf[4];
-    buf[0] = freq >> 24;
-    buf[1] = freq >> 16;
-    buf[2] = freq >> 8;
-    buf[3] = freq & 0xFF;
-    hal.WriteCommand(LR11XX_RADIO_SET_RF_FREQUENCY_OC, buf, sizeof(buf), radioNumber);
+    uint8_t buf[7] = {
+        (uint8_t)(freq >> 24),
+        (uint8_t)(freq >> 16),
+        (uint8_t)(freq >> 8),
+        (uint8_t)(freq),
+        0xFF,
+        0xFF,
+        0xFF,
+    };
+    if (doRx)
+    {
+        // SetRfFrequency_SetRX
+        hal.WriteCommand(LR11XX_RADIO_SET_FREQ_SET_RX, buf, sizeof(buf), radioNumber);
+    }
+    else
+    {
+        // 7.2.1 SetRfFrequency
+        hal.WriteCommand(LR11XX_RADIO_SET_RF_FREQUENCY_OC, buf, 4, radioNumber);
+    }
 
     currFreq = freq;
 }
 
-void ICACHE_RAM_ATTR LR1121Driver::SetFrequencyReg(uint32_t freq, SX12XX_Radio_Number_t radioNumber)
-{
-    SetFrequencyHz(freq, radioNumber);
-}
-
 // 4.1.1 SetDioIrqParams
 void LR1121Driver::SetDioIrqParams()
 {
@@ -720,9 +697,9 @@ bool ICACHE_RAM_ATTR LR1121Driver::RXnbISR(SX12XX_Radio_Number_t radioNumber)
     return true;
 }
 
-void ICACHE_RAM_ATTR LR1121Driver::RXnb(lr11xx_RadioOperatingModes_t rxMode, uint32_t incomingTimeout)
+void ICACHE_RAM_ATTR LR1121Driver::RXnb()
 {
-    SetMode(rxMode, SX12XX_Radio_All, incomingTimeout);
+    SetMode(LR1121_MODE_RX_CONT, SX12XX_Radio_All);
 }
 
 bool ICACHE_RAM_ATTR LR1121Driver::GetFrequencyErrorbool(SX12XX_Radio_Number_t radioNumber)

src/lib/LR1121Driver/LR1121.h

@@ -22,22 +22,15 @@ class LR1121Driver: public SX12xxDriverCommon
 public:
     static LR1121Driver *instance;
 
-    ///////////Radio Variables////////
-    uint32_t timeout;
-
-    ///////////////////////////////////
-
     ////////////////Configuration Functions/////////////
     LR1121Driver();
     bool Begin(uint32_t minimumFrequency, uint32_t maximumFrequency);
     void End();
     void SetTxIdleMode() { SetMode(LR1121_MODE_FS, SX12XX_Radio_All); }; // set Idle mode used when switching from RX to TX
     void Config(uint8_t bw, uint8_t sf, uint8_t cr, uint32_t freq,
-                uint8_t PreambleLength, bool InvertIQ, uint8_t PayloadLength, uint32_t rxtimeout, bool setFSKModulation,
+                uint8_t PreambleLength, bool InvertIQ, uint8_t PayloadLength, bool setFSKModulation,
                 uint8_t fskSyncWord1, uint8_t fskSyncWord2, SX12XX_Radio_Number_t radioNumber = SX12XX_Radio_All);
-    void SetFrequencyHz(uint32_t freq, SX12XX_Radio_Number_t radioNumber);
-    void SetFrequencyReg(uint32_t freq, SX12XX_Radio_Number_t radioNumber = SX12XX_Radio_All);
-    void SetRxTimeoutUs(uint32_t interval);
+    void SetFrequencyReg(uint32_t freq, SX12XX_Radio_Number_t radioNumber, bool doRx = false, uint32_t rxTime = 0);
     void SetOutputPower(int8_t power, bool isSubGHz = true);
     void startCWTest(uint32_t freq, SX12XX_Radio_Number_t radioNumber);
 
@@ -47,7 +40,7 @@ class LR1121Driver: public SX12xxDriverCommon
     bool FrequencyErrorAvailable() const { return false; }
 
     void TXnb(uint8_t *data, uint8_t size, bool sendGeminiBuffer, uint8_t * dataGemini, SX12XX_Radio_Number_t radioNumber);
-    void RXnb(lr11xx_RadioOperatingModes_t rxMode = LR1121_MODE_RX, uint32_t incomingTimeout = 0);
+    void RXnb();
 
     uint32_t GetIrqStatus(SX12XX_Radio_Number_t radioNumber);
     void ClearIrqStatus(SX12XX_Radio_Number_t radioNumber);
@@ -86,7 +79,7 @@ class LR1121Driver: public SX12xxDriverCommon
 
     bool CheckVersion(SX12XX_Radio_Number_t radioNumber);
 
-    void SetMode(lr11xx_RadioOperatingModes_t OPmode, SX12XX_Radio_Number_t radioNumber, uint32_t incomingTimeout = 0);
+    void SetMode(lr11xx_RadioOperatingModes_t OPmode, SX12XX_Radio_Number_t radioNumber);
 
     // LoRa functions
     void ConfigModParamsLoRa(uint8_t bw, uint8_t sf, uint8_t cr, SX12XX_Radio_Number_t radioNumber);

src/lib/LR1121Driver/LR1121_Regs.h

@@ -83,7 +83,6 @@ typedef enum
     LR1121_MODE_STDBY_RC,     //! The radio is in standby mode with RC oscillator
     LR1121_MODE_STDBY_XOSC,   //! The radio is in standby mode with XOSC oscillator
     LR1121_MODE_FS,           //! The radio is in frequency synthesis mode
-    LR1121_MODE_RX,           //! The radio is in receive mode
     LR1121_MODE_RX_CONT,      //! The radio is in continuous receive mode
     LR1121_MODE_TX,           //! The radio is in transmit mode
     LR1121_MODE_CAD           //! The radio is in channel activity detection mode