Respect dynamic CR in transmit timing

robekl · weebl2000 · commit 45af60271685 · 2026-06-17T12:03:52.000+02:00
(cherry picked from commit d2e230d)
diff --git a/examples/companion_radio/MyMesh.cpp b/examples/companion_radio/MyMesh.cpp
@@ -258,6 +258,10 @@ float MyMesh::getAirtimeBudgetFactor() const {
   return _prefs.airtime_factor;
 }
 
+uint32_t MyMesh::estimateTxAirtimeFor(int len_bytes, uint8_t tx_cr) const {
+  return estimateLoRaAirtimeFor(len_bytes, _prefs.sf, _prefs.bw, tx_cr != 0 ? tx_cr : _prefs.cr);
+}
+
 int MyMesh::getInterferenceThreshold() const {
   return 0; // disabled for now, until currentRSSI() problem is resolved
 }
@@ -271,12 +275,12 @@ int MyMesh::calcRxDelay(float score, uint32_t air_time) const {
 }
 
 uint32_t MyMesh::getRetransmitDelay(const mesh::Packet *packet) {
-  uint32_t t = (_radio->getEstAirtimeFor(packet->getPathByteLen() + packet->payload_len + 2) * 0.5f);
-  return getRNG()->nextInt(0, 5*t + 1);
+  uint32_t tx_airtime_ms = (estimateTxAirtimeFor(packet->getPathByteLen() + packet->payload_len + 2, packet->_tx_cr) * 0.5f);
+  return getRNG()->nextInt(0, 5 * tx_airtime_ms + 1);
 }
 uint32_t MyMesh::getDirectRetransmitDelay(const mesh::Packet *packet) {
-  uint32_t t = (_radio->getEstAirtimeFor(packet->getPathByteLen() + packet->payload_len + 2) * 0.2f);
-  return getRNG()->nextInt(0, 5*t + 1);
+  uint32_t tx_airtime_ms = (estimateTxAirtimeFor(packet->getPathByteLen() + packet->payload_len + 2, packet->_tx_cr) * 0.2f);
+  return getRNG()->nextInt(0, 5 * tx_airtime_ms + 1);
 }
 
 uint8_t MyMesh::getExtraAckTransmitCount() const {
@@ -965,6 +969,7 @@ void MyMesh::begin(bool has_display) {
   _store->loadChannels(this);
 
   radio_driver.setParams(_prefs.freq, _prefs.bw, _prefs.sf, _prefs.cr);
+  setDefaultCR(_prefs.cr);
   radio_driver.setTxPower(_prefs.tx_power_dbm);
   radio_driver.setRxBoostedGainMode(_prefs.rx_boosted_gain);
   MESH_DEBUG_PRINTLN("RX Boosted Gain Mode: %s",
@@ -1392,6 +1397,7 @@ void MyMesh::handleCmdFrame(size_t len) {
       savePrefs();
 
       radio_driver.setParams(_prefs.freq, _prefs.bw, _prefs.sf, _prefs.cr);
+      setDefaultCR(_prefs.cr);
       MESH_DEBUG_PRINTLN("OK: CMD_SET_RADIO_PARAMS: f=%d, bw=%d, sf=%d, cr=%d", freq, bw, (uint32_t)sf,
                          (uint32_t)cr);
 
@@ -1757,10 +1763,13 @@ void MyMesh::handleCmdFrame(size_t len) {
       memcpy(&auth, &cmd_frame[5], 4);
       auto pkt = createTrace(tag, auth, flags);
       if (pkt) {
+        if ((path_len >> path_sz) > 0) {
+          pkt->_tx_cr = selectCodingRateForPeer(&cmd_frame[10], 1 << path_sz);
+        }
         sendDirect(pkt, &cmd_frame[10], path_len);
 
-        uint32_t t = _radio->getEstAirtimeFor(pkt->payload_len + pkt->path_len + 2);
-        uint32_t est_timeout = calcDirectTimeoutMillisFor(t, path_len >> path_sz);
+        uint32_t tx_airtime_ms = estimateTxAirtimeFor(pkt->payload_len + pkt->path_len + 2, pkt->_tx_cr);
+        uint32_t est_timeout = calcDirectTimeoutMillisFor(tx_airtime_ms, path_len >> path_sz);
 
         out_frame[0] = RESP_CODE_SENT;
         out_frame[1] = 0;
diff --git a/examples/companion_radio/MyMesh.h b/examples/companion_radio/MyMesh.h
@@ -104,6 +104,7 @@ class MyMesh : public BaseChatMesh, public DataStoreHost {
 
 protected:
   float getAirtimeBudgetFactor() const override;
+  uint32_t estimateTxAirtimeFor(int len_bytes, uint8_t tx_cr=0) const override;
   int getInterferenceThreshold() const override;
   bool getCADEnabled() const override;
   int calcRxDelay(float score, uint32_t air_time) const override;
diff --git a/examples/simple_repeater/MyMesh.cpp b/examples/simple_repeater/MyMesh.cpp
@@ -578,12 +578,12 @@ int MyMesh::calcRxDelay(float score, uint32_t air_time) const {
 }
 
 uint32_t MyMesh::getRetransmitDelay(const mesh::Packet *packet) {
-  uint32_t t = (_radio->getEstAirtimeFor(packet->getPathByteLen() + packet->payload_len + 2) * _prefs.tx_delay_factor);
-  return getRNG()->nextInt(0, 5*t + 1);
+  uint32_t tx_airtime_ms = (estimateTxAirtimeFor(packet->getPathByteLen() + packet->payload_len + 2, packet->_tx_cr) * _prefs.tx_delay_factor);
+  return getRNG()->nextInt(0, 5 * tx_airtime_ms + 1);
 }
 uint32_t MyMesh::getDirectRetransmitDelay(const mesh::Packet *packet) {
-  uint32_t t = (_radio->getEstAirtimeFor(packet->getPathByteLen() + packet->payload_len + 2) * _prefs.direct_tx_delay_factor);
-  return getRNG()->nextInt(0, 5*t + 1);
+  uint32_t tx_airtime_ms = (estimateTxAirtimeFor(packet->getPathByteLen() + packet->payload_len + 2, packet->_tx_cr) * _prefs.direct_tx_delay_factor);
+  return getRNG()->nextInt(0, 5 * tx_airtime_ms + 1);
 }
 
 bool MyMesh::filterRecvFloodPacket(mesh::Packet* pkt) {
@@ -1327,12 +1327,14 @@ void MyMesh::loop() {
   if (set_radio_at && millisHasNowPassed(set_radio_at)) { // apply pending (temporary) radio params
     set_radio_at = 0;                                     // clear timer
     radio_driver.setParams(pending_freq, pending_bw, pending_sf, pending_cr);
+    setDefaultCR(pending_cr);
     MESH_DEBUG_PRINTLN("Temp radio params");
   }
 
   if (revert_radio_at && millisHasNowPassed(revert_radio_at)) { // revert radio params to orig
     revert_radio_at = 0;                                        // clear timer
     radio_driver.setParams(_prefs.freq, _prefs.bw, _prefs.sf, _prefs.cr);
+    setDefaultCR(_prefs.cr);
     MESH_DEBUG_PRINTLN("Radio params restored");
   }
 
diff --git a/examples/simple_repeater/MyMesh.h b/examples/simple_repeater/MyMesh.h
@@ -135,6 +135,9 @@ class MyMesh : public mesh::Mesh, public CommonCLICallbacks {
   float getAirtimeBudgetFactor() const override {
     return _prefs.airtime_factor;
   }
+  uint32_t estimateTxAirtimeFor(int len_bytes, uint8_t tx_cr=0) const override {
+    return estimateLoRaAirtimeFor(len_bytes, _prefs.sf, _prefs.bw, tx_cr != 0 ? tx_cr : _prefs.cr);
+  }
 
   bool allowPacketForward(const mesh::Packet* packet) override;
   const char* getLogDateTime() override;
diff --git a/examples/simple_room_server/MyMesh.cpp b/examples/simple_room_server/MyMesh.cpp
@@ -272,12 +272,12 @@ const char *MyMesh::getLogDateTime() {
 }
 
 uint32_t MyMesh::getRetransmitDelay(const mesh::Packet *packet) {
-  uint32_t t = (_radio->getEstAirtimeFor(packet->getPathByteLen() + packet->payload_len + 2) * _prefs.tx_delay_factor);
-  return getRNG()->nextInt(0, 5*t + 1);
+  uint32_t tx_airtime_ms = (estimateTxAirtimeFor(packet->getPathByteLen() + packet->payload_len + 2, packet->_tx_cr) * _prefs.tx_delay_factor);
+  return getRNG()->nextInt(0, 5 * tx_airtime_ms + 1);
 }
 uint32_t MyMesh::getDirectRetransmitDelay(const mesh::Packet *packet) {
-  uint32_t t = (_radio->getEstAirtimeFor(packet->getPathByteLen() + packet->payload_len + 2) * _prefs.direct_tx_delay_factor);
-  return getRNG()->nextInt(0, 5*t + 1);
+  uint32_t tx_airtime_ms = (estimateTxAirtimeFor(packet->getPathByteLen() + packet->payload_len + 2, packet->_tx_cr) * _prefs.direct_tx_delay_factor);
+  return getRNG()->nextInt(0, 5 * tx_airtime_ms + 1);
 }
 
 bool MyMesh::allowPacketForward(const mesh::Packet *packet) {
@@ -700,6 +700,7 @@ void MyMesh::begin(FILESYSTEM *fs) {
   }
 
   radio_driver.setParams(_prefs.freq, _prefs.bw, _prefs.sf, _prefs.cr);
+  setDefaultCR(_prefs.cr);
   radio_driver.setTxPower(_prefs.tx_power_dbm);
   board.setLoRaFemLnaEnabled(_prefs.radio_fem_rxgain);
 
@@ -1009,12 +1010,14 @@ void MyMesh::loop() {
   if (set_radio_at && millisHasNowPassed(set_radio_at)) { // apply pending (temporary) radio params
     set_radio_at = 0;                                     // clear timer
     radio_driver.setParams(pending_freq, pending_bw, pending_sf, pending_cr);
+    setDefaultCR(pending_cr);
     MESH_DEBUG_PRINTLN("Temp radio params");
   }
 
   if (revert_radio_at && millisHasNowPassed(revert_radio_at)) { // revert radio params to orig
     revert_radio_at = 0;                                        // clear timer
     radio_driver.setParams(_prefs.freq, _prefs.bw, _prefs.sf, _prefs.cr);
+    setDefaultCR(_prefs.cr);
     MESH_DEBUG_PRINTLN("Radio params restored");
   }
 
diff --git a/examples/simple_room_server/MyMesh.h b/examples/simple_room_server/MyMesh.h
@@ -130,6 +130,9 @@ class MyMesh : public mesh::Mesh, public CommonCLICallbacks {
   float getAirtimeBudgetFactor() const override {
     return _prefs.airtime_factor;
   }
+  uint32_t estimateTxAirtimeFor(int len_bytes, uint8_t tx_cr=0) const override {
+    return estimateLoRaAirtimeFor(len_bytes, _prefs.sf, _prefs.bw, tx_cr != 0 ? tx_cr : _prefs.cr);
+  }
 
   void logRxRaw(float snr, float rssi, const uint8_t raw[], int len) override;
   void logRx(mesh::Packet* pkt, int len, float score) override;
diff --git a/examples/simple_secure_chat/main.cpp b/examples/simple_secure_chat/main.cpp
@@ -193,6 +193,9 @@ class MyMesh : public BaseChatMesh, ContactVisitor {
   float getAirtimeBudgetFactor() const override {
     return _prefs.airtime_factor;
   }
+  uint32_t estimateTxAirtimeFor(int len_bytes, uint8_t tx_cr=0) const override {
+    return estimateLoRaAirtimeFor(len_bytes, LORA_SF, LORA_BW, tx_cr != 0 ? tx_cr : LORA_CR);
+  }
 
   int calcRxDelay(float score, uint32_t air_time) const override {
     return 0;  // disable rxdelay
@@ -578,6 +581,7 @@ void setup() {
 #endif
 
   radio_driver.setParams(the_mesh.getFreqPref(), LORA_BW, LORA_SF, LORA_CR);
+  the_mesh.setDefaultCR(LORA_CR);
   radio_driver.setTxPower(the_mesh.getTxPowerPref());
 
   the_mesh.showWelcome();
diff --git a/examples/simple_sensor/SensorMesh.cpp b/examples/simple_sensor/SensorMesh.cpp
@@ -313,12 +313,12 @@ int SensorMesh::calcRxDelay(float score, uint32_t air_time) const {
 }
 
 uint32_t SensorMesh::getRetransmitDelay(const mesh::Packet* packet) {
-  uint32_t t = (_radio->getEstAirtimeFor(packet->getPathByteLen() + packet->payload_len + 2) * _prefs.tx_delay_factor);
-  return getRNG()->nextInt(0, 6)*t;
+  uint32_t tx_airtime_ms = (estimateTxAirtimeFor(packet->getPathByteLen() + packet->payload_len + 2, packet->_tx_cr) * _prefs.tx_delay_factor);
+  return getRNG()->nextInt(0, 6) * tx_airtime_ms;
 }
 uint32_t SensorMesh::getDirectRetransmitDelay(const mesh::Packet* packet) {
-  uint32_t t = (_radio->getEstAirtimeFor(packet->getPathByteLen() + packet->payload_len + 2) * _prefs.direct_tx_delay_factor);
-  return getRNG()->nextInt(0, 6)*t;
+  uint32_t tx_airtime_ms = (estimateTxAirtimeFor(packet->getPathByteLen() + packet->payload_len + 2, packet->_tx_cr) * _prefs.direct_tx_delay_factor);
+  return getRNG()->nextInt(0, 6) * tx_airtime_ms;
 }
 int SensorMesh::getInterferenceThreshold() const {
   return _prefs.interference_threshold;
@@ -770,6 +770,7 @@ void SensorMesh::begin(FILESYSTEM* fs) {
   }
 
   radio_driver.setParams(_prefs.freq, _prefs.bw, _prefs.sf, _prefs.cr);
+  setDefaultCR(_prefs.cr);
   radio_driver.setTxPower(_prefs.tx_power_dbm);
   board.setLoRaFemLnaEnabled(_prefs.radio_fem_rxgain);
 
@@ -915,12 +916,14 @@ void SensorMesh::loop() {
   if (set_radio_at && millisHasNowPassed(set_radio_at)) {   // apply pending (temporary) radio params
     set_radio_at = 0;  // clear timer
     radio_driver.setParams(pending_freq, pending_bw, pending_sf, pending_cr);
+    setDefaultCR(pending_cr);
     MESH_DEBUG_PRINTLN("Temp radio params");
   }
 
   if (revert_radio_at && millisHasNowPassed(revert_radio_at)) {   // revert radio params to orig
     revert_radio_at = 0;  // clear timer
     radio_driver.setParams(_prefs.freq, _prefs.bw, _prefs.sf, _prefs.cr);
+    setDefaultCR(_prefs.cr);
     MESH_DEBUG_PRINTLN("Radio params restored");
   }
 
diff --git a/examples/simple_sensor/SensorMesh.h b/examples/simple_sensor/SensorMesh.h
@@ -115,6 +115,9 @@ class SensorMesh : public mesh::Mesh, public CommonCLICallbacks {
 
   // Mesh overrides
   float getAirtimeBudgetFactor() const override;
+  uint32_t estimateTxAirtimeFor(int len_bytes, uint8_t tx_cr=0) const override {
+    return estimateLoRaAirtimeFor(len_bytes, _prefs.sf, _prefs.bw, tx_cr != 0 ? tx_cr : _prefs.cr);
+  }
   bool allowPacketForward(const mesh::Packet* packet) override;
   int calcRxDelay(float score, uint32_t air_time) const override;
   uint32_t getRetransmitDelay(const mesh::Packet* packet) override;
diff --git a/src/Dispatcher.cpp b/src/Dispatcher.cpp
@@ -63,6 +63,25 @@ uint32_t Dispatcher::getCADFailMaxDuration() const {
   return 4000;   // 4 seconds
 }
 
+uint32_t Dispatcher::estimateTxAirtimeFor(int len_bytes, uint8_t tx_cr) const {
+  (void)tx_cr;
+  return _radio->getEstAirtimeFor(len_bytes);
+}
+
+// Matches the standard LoRa time-on-air equation for the configured modem settings.
+uint32_t Dispatcher::estimateLoRaAirtimeFor(int len_bytes, uint8_t sf, float bw_khz, uint8_t cr) const {
+  bool ldro_enabled = (((float)(1UL << sf)) / bw_khz) > 16.0f;
+  float low_data_rate_optimize = ldro_enabled ? 1.0f : 0.0f;
+  float implicit_header = 0.0f;
+  float crc_enabled = 1.0f;
+  float preamble_symbols = 16.0f;
+  float payload_symbols = 8.0f + fmaxf(ceilf((8.0f * (float)len_bytes - 4.0f * (float)sf + 28.0f + 16.0f * crc_enabled - 20.0f * implicit_header) /
+                                             (4.0f * (float)sf - 8.0f * low_data_rate_optimize)) * (float)cr, 0.0f);
+  float total_symbols = preamble_symbols + payload_symbols + 4.25f;
+  float symbol_length_ms = ((float)(uint32_t(1) << sf) / bw_khz);
+  return (uint32_t)ceilf(symbol_length_ms * total_symbols);
+}
+
 void Dispatcher::loop() {
   if (millisHasNowPassed(next_floor_calib_time)) {
     _radio->triggerNoiseFloorCalibrate(getInterferenceThreshold());
@@ -334,8 +353,7 @@ void Dispatcher::checkSend() {
       if (outbound->_tx_cr != 0 && outbound->_tx_cr != _default_cr) {
         _radio->setCodingRate(outbound->_tx_cr);
       }
-
-      uint32_t max_airtime = _radio->getEstAirtimeFor(len)*3/2;
+      uint32_t max_airtime = estimateTxAirtimeFor(len, outbound->_tx_cr) * 3 / 2;
       outbound_start = _ms->getMillis();
       bool success = _radio->startSendRaw(raw, len);
       if (!success) {
@@ -402,4 +420,4 @@ unsigned long Dispatcher::futureMillis(int millis_from_now) const {
   return _ms->getMillis() + millis_from_now;
 }
 
-}
+}
diff --git a/src/Dispatcher.h b/src/Dispatcher.h
@@ -176,6 +176,10 @@ class Dispatcher {
   virtual bool getCADEnabled() const { return false; }    // hardware CAD disabled by default
   virtual int getAGCResetInterval() const { return 0; }    // disabled by default
   virtual unsigned long getDutyCycleWindowMs() const { return 3600000; }
+  // Estimates TX airtime using an explicit per-packet CR override when present.
+  virtual uint32_t estimateTxAirtimeFor(int len_bytes, uint8_t tx_cr=0) const;
+  // LoRa airtime helper for meshes that know the active SF/BW/CR settings directly.
+  uint32_t estimateLoRaAirtimeFor(int len_bytes, uint8_t sf, float bw_khz, uint8_t cr) const;
 
 public:
   void begin();
diff --git a/src/Mesh.cpp b/src/Mesh.cpp
@@ -15,9 +15,9 @@ bool Mesh::allowPacketForward(const mesh::Packet* packet) {
   return false;  // by default, Transport NOT enabled
 }
 uint32_t Mesh::getRetransmitDelay(const mesh::Packet* packet) { 
-  uint32_t t = (_radio->getEstAirtimeFor(packet->getRawLength()) * 52 / 50) / 2;
+  uint32_t tx_airtime_ms = (estimateTxAirtimeFor(packet->getRawLength(), packet->_tx_cr) * 52 / 50) / 2;
 
-  return _rng->nextInt(0, 5)*t;
+  return _rng->nextInt(0, 5) * tx_airtime_ms;
 }
 uint32_t Mesh::getDirectRetransmitDelay(const Packet* packet) {
   return 0;  // by default, no delay
@@ -694,6 +694,9 @@ void Mesh::sendDirect(Packet* packet, const uint8_t* path, uint8_t path_len, uin
     pri = 5;   // maybe make this configurable
   } else {
     packet->path_len = Packet::copyPath(packet->path, path, path_len);
+    if (packet->_tx_cr == 0 && packet->getPathHashCount() > 0) {
+      packet->_tx_cr = selectCodingRateForPeer(packet->path, packet->getPathHashSize());
+    }
     if (packet->getPayloadType() == PAYLOAD_TYPE_PATH) {
       pri = 1;   // slightly less priority
     } else {
@@ -728,4 +731,4 @@ void Mesh::sendZeroHop(Packet* packet, uint16_t* transport_codes, uint32_t delay
   sendPacket(packet, 0, delay_millis);
 }
 
-}
+}
diff --git a/src/helpers/BaseChatMesh.cpp b/src/helpers/BaseChatMesh.cpp

Original file line number	Diff line number	Diff line change
`@@ -578,12 +578,12 @@ int MyMesh::calcRxDelay(float score, uint32_t air_time) const {`
`578`	`578`	`}`
`579`	`579`
`580`	`580`	`uint32_t MyMesh::getRetransmitDelay(const mesh::Packet *packet) {`
`581`		`- uint32_t t = (_radio->getEstAirtimeFor(packet->getPathByteLen() + packet->payload_len + 2) * _prefs.tx_delay_factor);`
`582`		`- return getRNG()->nextInt(0, 5*t + 1);`
	`581`	`+ uint32_t tx_airtime_ms = (estimateTxAirtimeFor(packet->getPathByteLen() + packet->payload_len + 2, packet->_tx_cr) * _prefs.tx_delay_factor);`
	`582`	`+ return getRNG()->nextInt(0, 5 * tx_airtime_ms + 1);`
`583`	`583`	`}`
`584`	`584`	`uint32_t MyMesh::getDirectRetransmitDelay(const mesh::Packet *packet) {`
`585`		`- uint32_t t = (_radio->getEstAirtimeFor(packet->getPathByteLen() + packet->payload_len + 2) * _prefs.direct_tx_delay_factor);`
`586`		`- return getRNG()->nextInt(0, 5*t + 1);`
	`585`	`+ uint32_t tx_airtime_ms = (estimateTxAirtimeFor(packet->getPathByteLen() + packet->payload_len + 2, packet->_tx_cr) * _prefs.direct_tx_delay_factor);`
	`586`	`+ return getRNG()->nextInt(0, 5 * tx_airtime_ms + 1);`
`587`	`587`	`}`
`588`	`588`
`589`	`589`	`bool MyMesh::filterRecvFloodPacket(mesh::Packet* pkt) {`
`@@ -1327,12 +1327,14 @@ void MyMesh::loop() {`
`1327`	`1327`	`if (set_radio_at && millisHasNowPassed(set_radio_at)) { // apply pending (temporary) radio params`
`1328`	`1328`	`set_radio_at = 0; // clear timer`
`1329`	`1329`	`radio_driver.setParams(pending_freq, pending_bw, pending_sf, pending_cr);`
	`1330`	`+ setDefaultCR(pending_cr);`
`1330`	`1331`	`MESH_DEBUG_PRINTLN("Temp radio params");`
`1331`	`1332`	`}`
`1332`	`1333`
`1333`	`1334`	`if (revert_radio_at && millisHasNowPassed(revert_radio_at)) { // revert radio params to orig`
`1334`	`1335`	`revert_radio_at = 0; // clear timer`
`1335`	`1336`	`radio_driver.setParams(_prefs.freq, _prefs.bw, _prefs.sf, _prefs.cr);`
	`1337`	`+ setDefaultCR(_prefs.cr);`
`1336`	`1338`	`MESH_DEBUG_PRINTLN("Radio params restored");`
`1337`	`1339`	`}`
`1338`	`1340`
Original file line number	Diff line number	Diff line change
`@@ -135,6 +135,9 @@ class MyMesh : public mesh::Mesh, public CommonCLICallbacks {`
`135`	`135`	`float getAirtimeBudgetFactor() const override {`
`136`	`136`	`return _prefs.airtime_factor;`
`137`	`137`	`}`
	`138`	`+ uint32_t estimateTxAirtimeFor(int len_bytes, uint8_t tx_cr=0) const override {`
	`139`	`+ return estimateLoRaAirtimeFor(len_bytes, _prefs.sf, _prefs.bw, tx_cr != 0 ? tx_cr : _prefs.cr);`
	`140`	`+ }`
`138`	`141`
`139`	`142`	`bool allowPacketForward(const mesh::Packet* packet) override;`
`140`	`143`	`const char* getLogDateTime() override;`
Original file line number	Diff line number	Diff line change
`@@ -272,12 +272,12 @@ const char *MyMesh::getLogDateTime() {`
`272`	`272`	`}`
`273`	`273`
`274`	`274`	`uint32_t MyMesh::getRetransmitDelay(const mesh::Packet *packet) {`
`275`		`- uint32_t t = (_radio->getEstAirtimeFor(packet->getPathByteLen() + packet->payload_len + 2) * _prefs.tx_delay_factor);`
`276`		`- return getRNG()->nextInt(0, 5*t + 1);`
	`275`	`+ uint32_t tx_airtime_ms = (estimateTxAirtimeFor(packet->getPathByteLen() + packet->payload_len + 2, packet->_tx_cr) * _prefs.tx_delay_factor);`
	`276`	`+ return getRNG()->nextInt(0, 5 * tx_airtime_ms + 1);`
`277`	`277`	`}`
`278`	`278`	`uint32_t MyMesh::getDirectRetransmitDelay(const mesh::Packet *packet) {`
`279`		`- uint32_t t = (_radio->getEstAirtimeFor(packet->getPathByteLen() + packet->payload_len + 2) * _prefs.direct_tx_delay_factor);`
`280`		`- return getRNG()->nextInt(0, 5*t + 1);`
	`279`	`+ uint32_t tx_airtime_ms = (estimateTxAirtimeFor(packet->getPathByteLen() + packet->payload_len + 2, packet->_tx_cr) * _prefs.direct_tx_delay_factor);`
	`280`	`+ return getRNG()->nextInt(0, 5 * tx_airtime_ms + 1);`
`281`	`281`	`}`
`282`	`282`
`283`	`283`	`bool MyMesh::allowPacketForward(const mesh::Packet *packet) {`
`@@ -700,6 +700,7 @@ void MyMesh::begin(FILESYSTEM *fs) {`
`700`	`700`	`}`
`701`	`701`
`702`	`702`	`radio_driver.setParams(_prefs.freq, _prefs.bw, _prefs.sf, _prefs.cr);`
	`703`	`+ setDefaultCR(_prefs.cr);`
`703`	`704`	`radio_driver.setTxPower(_prefs.tx_power_dbm);`
`704`	`705`	`board.setLoRaFemLnaEnabled(_prefs.radio_fem_rxgain);`
`705`	`706`
`@@ -1009,12 +1010,14 @@ void MyMesh::loop() {`
`1009`	`1010`	`if (set_radio_at && millisHasNowPassed(set_radio_at)) { // apply pending (temporary) radio params`
`1010`	`1011`	`set_radio_at = 0; // clear timer`
`1011`	`1012`	`radio_driver.setParams(pending_freq, pending_bw, pending_sf, pending_cr);`
	`1013`	`+ setDefaultCR(pending_cr);`
`1012`	`1014`	`MESH_DEBUG_PRINTLN("Temp radio params");`
`1013`	`1015`	`}`
`1014`	`1016`
`1015`	`1017`	`if (revert_radio_at && millisHasNowPassed(revert_radio_at)) { // revert radio params to orig`
`1016`	`1018`	`revert_radio_at = 0; // clear timer`
`1017`	`1019`	`radio_driver.setParams(_prefs.freq, _prefs.bw, _prefs.sf, _prefs.cr);`
	`1020`	`+ setDefaultCR(_prefs.cr);`
`1018`	`1021`	`MESH_DEBUG_PRINTLN("Radio params restored");`
`1019`	`1022`	`}`
`1020`	`1023`
Original file line number	Diff line number	Diff line change
`@@ -130,6 +130,9 @@ class MyMesh : public mesh::Mesh, public CommonCLICallbacks {`
`130`	`130`	`float getAirtimeBudgetFactor() const override {`
`131`	`131`	`return _prefs.airtime_factor;`
`132`	`132`	`}`
	`133`	`+ uint32_t estimateTxAirtimeFor(int len_bytes, uint8_t tx_cr=0) const override {`
	`134`	`+ return estimateLoRaAirtimeFor(len_bytes, _prefs.sf, _prefs.bw, tx_cr != 0 ? tx_cr : _prefs.cr);`
	`135`	`+ }`
`133`	`136`
`134`	`137`	`void logRxRaw(float snr, float rssi, const uint8_t raw[], int len) override;`
`135`	`138`	`void logRx(mesh::Packet* pkt, int len, float score) override;`
Original file line number	Diff line number	Diff line change
`@@ -313,12 +313,12 @@ int SensorMesh::calcRxDelay(float score, uint32_t air_time) const {`
`313`	`313`	`}`
`314`	`314`
`315`	`315`	`uint32_t SensorMesh::getRetransmitDelay(const mesh::Packet* packet) {`
`316`		`- uint32_t t = (_radio->getEstAirtimeFor(packet->getPathByteLen() + packet->payload_len + 2) * _prefs.tx_delay_factor);`
`317`		`- return getRNG()->nextInt(0, 6)*t;`
	`316`	`+ uint32_t tx_airtime_ms = (estimateTxAirtimeFor(packet->getPathByteLen() + packet->payload_len + 2, packet->_tx_cr) * _prefs.tx_delay_factor);`
	`317`	`+ return getRNG()->nextInt(0, 6) * tx_airtime_ms;`
`318`	`318`	`}`
`319`	`319`	`uint32_t SensorMesh::getDirectRetransmitDelay(const mesh::Packet* packet) {`
`320`		`- uint32_t t = (_radio->getEstAirtimeFor(packet->getPathByteLen() + packet->payload_len + 2) * _prefs.direct_tx_delay_factor);`
`321`		`- return getRNG()->nextInt(0, 6)*t;`
	`320`	`+ uint32_t tx_airtime_ms = (estimateTxAirtimeFor(packet->getPathByteLen() + packet->payload_len + 2, packet->_tx_cr) * _prefs.direct_tx_delay_factor);`
	`321`	`+ return getRNG()->nextInt(0, 6) * tx_airtime_ms;`
`322`	`322`	`}`
`323`	`323`	`int SensorMesh::getInterferenceThreshold() const {`
`324`	`324`	`return _prefs.interference_threshold;`
`@@ -770,6 +770,7 @@ void SensorMesh::begin(FILESYSTEM* fs) {`
`770`	`770`	`}`
`771`	`771`
`772`	`772`	`radio_driver.setParams(_prefs.freq, _prefs.bw, _prefs.sf, _prefs.cr);`
	`773`	`+ setDefaultCR(_prefs.cr);`
`773`	`774`	`radio_driver.setTxPower(_prefs.tx_power_dbm);`
`774`	`775`	`board.setLoRaFemLnaEnabled(_prefs.radio_fem_rxgain);`
`775`	`776`
`@@ -915,12 +916,14 @@ void SensorMesh::loop() {`
`915`	`916`	`if (set_radio_at && millisHasNowPassed(set_radio_at)) { // apply pending (temporary) radio params`
`916`	`917`	`set_radio_at = 0; // clear timer`
`917`	`918`	`radio_driver.setParams(pending_freq, pending_bw, pending_sf, pending_cr);`
	`919`	`+ setDefaultCR(pending_cr);`
`918`	`920`	`MESH_DEBUG_PRINTLN("Temp radio params");`
`919`	`921`	`}`
`920`	`922`
`921`	`923`	`if (revert_radio_at && millisHasNowPassed(revert_radio_at)) { // revert radio params to orig`
`922`	`924`	`revert_radio_at = 0; // clear timer`
`923`	`925`	`radio_driver.setParams(_prefs.freq, _prefs.bw, _prefs.sf, _prefs.cr);`
	`926`	`+ setDefaultCR(_prefs.cr);`
`924`	`927`	`MESH_DEBUG_PRINTLN("Radio params restored");`
`925`	`928`	`}`
`926`	`929`