Files
meshcore-tth/src/helpers/radiolib/RadioLibWrappers.cpp
T

444 lines
16 KiB
C++

#define RADIOLIB_STATIC_ONLY 1
#include "RadioLibWrappers.h"
#define STATE_IDLE 0
#define STATE_RX 1
#define STATE_TX_WAIT 3
#define STATE_TX_DONE 4
#define STATE_INT_READY 16
#define NUM_NOISE_FLOOR_SAMPLES 64
#define SAMPLING_THRESHOLD 14
static volatile uint8_t state = STATE_IDLE;
#ifdef RADIO_DIAG
static volatile uint32_t diag_isr_count = 0; // DIO1 edges that reached the MCU
static volatile uint32_t diag_isr_ms = 0; // millis() of the last one
#endif
// this function is called when a complete packet
// is transmitted by the module
static
#if defined(ESP8266) || defined(ESP32)
ICACHE_RAM_ATTR
#endif
void setFlag(void) {
// we sent a packet, set the flag
state |= STATE_INT_READY;
#ifdef RADIO_DIAG
diag_isr_count++;
diag_isr_ms = millis();
#endif
}
void RadioLibWrapper::begin() {
_radio->setPacketReceivedAction(setFlag); // this is also SentComplete interrupt
_preamble_sf = getSpreadingFactor();
_radio->setPreambleLength(preambleLengthForSF(_preamble_sf)); // longer preamble for lower SF improves reliability
state = STATE_IDLE;
if (_board->getStartupReason() == BD_STARTUP_RX_PACKET) { // received a LoRa packet (while in deep sleep)
setFlag(); // LoRa packet is already received
}
_noise_floor = 0;
_threshold = 0;
_cad_enabled = false;
// start average out some samples
_num_floor_samples = 0;
_floor_sample_sum = 0;
}
uint32_t RadioLibWrapper::getRngSeed() {
return _radio->random(0x7FFFFFFF);
}
void RadioLibWrapper::setTxPower(int8_t dbm) {
#if defined(USE_LR2021)
// Upstream 114093ee: on LR2021, setOutputPower() writes the PA config and
// TxParams, which are standby-only commands, and recvRaw() keeps state ==
// STATE_RX there, so nothing re-arms the receiver by itself. Drop to standby
// first and let checkRecv() re-arm Rx.
idle();
#endif
// CUSTOM (TeTeHacko): keep the status. The signature is an upstream callback
// and has to stay void, but the return value must not be thrown away: SX1262
// accepts only -9..+22 dBm and rejects the rest WITHOUT touching the PA, while
// `set tx` clamps to -9..30, saves the pref and replies "OK". Without this,
// "the radio refused" and "the radio changed" look identical from the console.
_last_txpow_dbm = dbm;
_last_txpow_status = _radio->setOutputPower(dbm);
}
void RadioLibWrapper::idle() {
_radio->standby();
state = STATE_IDLE; // need another startReceive()
}
void RadioLibWrapper::triggerNoiseFloorCalibrate(int threshold) {
_threshold = threshold;
if (_num_floor_samples >= NUM_NOISE_FLOOR_SAMPLES) { // ignore trigger if currently sampling
_num_floor_samples = 0;
_floor_sample_sum = 0;
}
}
void RadioLibWrapper::doResetAGC() {
_radio->sleep(); // warm sleep to reset analog frontend
}
void RadioLibWrapper::resetAGC() {
// make sure we're not mid-receive of packet!
if ((state & STATE_INT_READY) != 0 || isReceivingPacket()) return;
doResetAGC();
state = STATE_IDLE; // trigger a startReceive()
// Reset noise floor sampling so it reconverges from scratch.
// Without this, a stuck _noise_floor of -120 makes the sampling threshold
// too low (-106) to accept normal samples (~-105), self-reinforcing the
// stuck value even after the receiver has recovered.
_noise_floor = 0;
_num_floor_samples = 0;
_floor_sample_sum = 0;
}
#ifdef LORA_POLL_IRQ
// CUSTOM (TeTeHacko): salvage path for a node whose DIO1 interrupt line is dead.
//
// setPacketReceivedAction() above is the ONLY thing that ever sets
// STATE_INT_READY, so a broken DIO1 line means RxDone/TxDone never reach the
// MCU: TX times out and retries while the frames actually radiate (a witness
// node hears them), and received packets are never picked up. That is the exact
// signature that killed bench-board -- see nrf52-radio-fault-diagnosis.
//
// The chip latches those events in its IRQ status register regardless of whether
// they are mapped out to a DIO pin, so reading it over SPI bypasses the whole
// line -- and therefore works no matter WHICH end of it is broken (dead nRF52
// input, dead SX1262 output, or a cut trace). Rewiring DIO1 to a spare GPIO only
// helps in the first of those three cases, so this is the strictly stronger fix:
// if polling does not revive the node, no wire can either.
//
// Cost: one extra SPI read per Dispatcher pass (Dispatcher.cpp:72 -> loop()),
// alongside the isReceivingPacket() read that already happens in the same path,
// and completion is noticed on the next pass instead of instantly.
void RadioLibWrapper::pollIrq() {
if (state != STATE_RX && state != STATE_TX_WAIT) return; // nothing pending
uint32_t mask = irqDoneMask();
if (mask == 0) return; // radio has no mask
if (_radio->getIrqFlags() & mask) setFlag();
}
#endif
void RadioLibWrapper::loop() {
#ifdef LORA_POLL_IRQ
pollIrq();
#endif
if (state == STATE_RX && _num_floor_samples < NUM_NOISE_FLOOR_SAMPLES) {
if (!isReceivingPacket()) {
int rssi = getCurrentRSSI();
if (rssi < _noise_floor + SAMPLING_THRESHOLD) { // only consider samples below current floor + sampling THRESHOLD
_num_floor_samples++;
_floor_sample_sum += rssi;
}
}
} else if (_num_floor_samples >= NUM_NOISE_FLOOR_SAMPLES && _floor_sample_sum != 0) {
_noise_floor = _floor_sample_sum / NUM_NOISE_FLOOR_SAMPLES;
if (_noise_floor < -120) {
_noise_floor = -120; // clamp to lower bound of -120dBi
}
_floor_sample_sum = 0;
#ifdef MESH_DEBUG_NOISE_FLOOR
MESH_DEBUG_PRINTLN("RadioLibWrapper: noise_floor = %d", (int)_noise_floor);
#endif
}
}
void RadioLibWrapper::startRecv() {
#if defined(USE_LR2021)
_radio->standby(); // without this LR2021 can throw -706 when calling startReceive after hardware CAD when side detectors are enabled
#endif
int err = _radio->startReceive();
if (err == RADIOLIB_ERR_NONE) {
state = STATE_RX;
} else {
MESH_DEBUG_PRINTLN("RadioLibWrapper: error: startReceive(%d)", err);
}
}
bool RadioLibWrapper::isInRecvMode() const {
return (state & ~STATE_INT_READY) == STATE_RX;
}
int RadioLibWrapper::recvRaw(uint8_t* bytes, int sz) {
int len = 0;
if (state & STATE_INT_READY) {
len = _radio->getPacketLength();
if (len > 0) {
if (len > sz) { len = sz; }
int err = _radio->readData(bytes, len);
if (err == RADIOLIB_ERR_NONE && !lastRxHadCRC()) {
err = RADIOLIB_ERR_LORA_HEADER_DAMAGED; // header says no CRC, so the payload was never checked
}
if (err != RADIOLIB_ERR_NONE) {
MESH_DEBUG_PRINTLN("RadioLibWrapper: error: readData(%d)", err);
len = 0;
n_recv_errors++;
} else {
// Serial.print(" readData() -> "); Serial.println(len);
n_recv++;
#ifdef RADIO_DIAG
_diag_last_rx_ms = millis();
#endif
}
}
#if defined(USE_LR2021)
state = STATE_RX; // LR2021 stays in Rx after readData, calling startReceive while still in Rx throws -706 errors
#else
state = STATE_IDLE; // need another startReceive()
#endif
}
if (state != STATE_RX) {
int err = _radio->startReceive();
if (err == RADIOLIB_ERR_NONE) {
state = STATE_RX;
} else {
MESH_DEBUG_PRINTLN("RadioLibWrapper: error: startReceive(%d)", err);
}
}
return len;
}
uint32_t RadioLibWrapper::getEstAirtimeFor(int len_bytes) {
return _radio->getTimeOnAir(len_bytes) / 1000;
}
bool RadioLibWrapper::startSendRaw(const uint8_t* bytes, int len) {
_board->onBeforeTransmit();
int err = _radio->startTransmit((uint8_t *) bytes, len);
if (err == RADIOLIB_ERR_NONE) {
state = STATE_TX_WAIT;
return true;
}
MESH_DEBUG_PRINTLN("RadioLibWrapper: error: startTransmit(%d)", err);
idle(); // trigger another startRecv()
_board->onAfterTransmit();
return false;
}
bool RadioLibWrapper::isSendComplete() {
if (state & STATE_INT_READY) {
state = STATE_IDLE;
n_sent++;
return true;
}
return false;
}
void RadioLibWrapper::onSendFinished() {
_radio->finishTransmit();
_board->onAfterTransmit();
state = STATE_IDLE;
}
int16_t RadioLibWrapper::performChannelScan() {
return _radio->scanChannel();
}
#ifdef PIN_DIAG
// CUSTOM (TeTeHacko): make the radio itself assert DIO1, then report the chip's
// IRQ status register (read over SPI, independent of the pin) NEXT TO the actual
// level on the pin. That pair is what a multimeter would otherwise have to tell
// us, and it says which END of a dead DIO1 line is broken:
//
// irq has TX_DONE, pin HIGH -> the line is fine, look elsewhere
// irq has TX_DONE, pin LOW -> line dead. If a probe wire is fitted from the
// DIO1 net to PIN_DIAG_PROBE and THAT reads HIGH,
// the SX1262 still drives and it is the nRF52's
// input pad that died -- the one case a rewire
// to a spare GPIO actually fixes.
// no TX_DONE at all -> the chip never finished the transmit; the
// fault is not the IRQ line (SPI/BUSY/PA).
//
// A 1-byte transmit is used as the stimulus because TX_DONE is unconditional --
// it needs no peer, no antenna match and no RX activity. It DOES put a frame on
// the air, so run it on the bench band.
int RadioLibWrapper::probeDio1(uint32_t* irq_out, int* dio1_level, int* probe_level) {
if (state == STATE_TX_WAIT) return -1; // mid-transmit, don't clobber it
uint32_t mask = irqDoneMask();
if (mask == 0) return -3; // radio has no chip mask -> can't tell
uint8_t dummy = 0;
_radio->standby();
_board->onBeforeTransmit();
int err = _radio->startTransmit(&dummy, 1);
if (err != RADIOLIB_ERR_NONE) {
_board->onAfterTransmit();
idle();
return err;
}
uint32_t irq = 0;
unsigned long deadline = millis() + 2000;
while (millis() < deadline) {
irq = _radio->getIrqFlags();
if (irq & mask) break;
}
// Levels have to be sampled while the IRQ is still asserted: DIO1 stays high
// until the status register is cleared, and finishTransmit() clears it.
// Runtime compare, not #if: P_LORA_DIO_1 is usually a variant constant like D1
// (a static const, invisible to the preprocessor, which would silently read 0).
uint32_t dio1_pin = (uint32_t) P_LORA_DIO_1;
*dio1_level = (dio1_pin == RADIOLIB_NC) ? -1 : digitalRead(dio1_pin);
#ifdef PIN_DIAG_PROBE
pinMode(PIN_DIAG_PROBE, INPUT);
*probe_level = digitalRead(PIN_DIAG_PROBE);
#else
*probe_level = -1;
#endif
*irq_out = irq;
_radio->finishTransmit();
_board->onAfterTransmit();
state = STATE_IDLE; // Dispatcher will startReceive() again
return (irq & mask) ? 0 : -2;
}
#endif
bool RadioLibWrapper::isChannelActive() {
// int.thresh: RSSI-based interference detection (relative to noise floor)
if (_threshold != 0 && getCurrentRSSI() > _noise_floor + _threshold) return true;
// cad: hardware channel activity detection
if (_cad_enabled) {
int16_t result = performChannelScan();
// scanChannel() triggers DIO interrupt (CAD done) which sets STATE_INT_READY
// via setFlag() ISR. Clear it before restarting RX so recvRaw() doesn't
// try to read a non-existent packet and count a spurious recv error.
state = STATE_IDLE;
startRecv();
if (result != RADIOLIB_CHANNEL_FREE) return true;
}
return false;
}
float RadioLibWrapper::getLastRSSI() const {
return _radio->getRSSI();
}
float RadioLibWrapper::getLastSNR() const {
return _radio->getSNR();
}
// Approximate SNR threshold per SF for successful reception (based on Semtech datasheets)
static float snr_threshold[] = {
-7.5, // SF7 needs at least -7.5 dB SNR
-10, // SF8 needs at least -10 dB SNR
-12.5, // SF9 needs at least -12.5 dB SNR
-15, // SF10 needs at least -15 dB SNR
-17.5,// SF11 needs at least -17.5 dB SNR
-20 // SF12 needs at least -20 dB SNR
};
float RadioLibWrapper::packetScoreInt(float snr, int sf, int packet_len) {
if (sf < 7) return 0.0f;
if (snr < snr_threshold[sf - 7]) return 0.0f; // Below threshold, no chance of success
auto success_rate_based_on_snr = (snr - snr_threshold[sf - 7]) / 10.0;
auto collision_penalty = 1 - (packet_len / 256.0); // Assuming max packet of 256 bytes
return max(0.0, min(1.0, success_rate_based_on_snr * collision_penalty));
}
PacketMillis RadioLibWrapper::calcMaxPacketMillis(uint8_t sf, float bw, uint8_t cr, uint8_t preambleSymbols) {
// based on RadioLib's calculateTimeOnAir()
uint32_t tsym_us = ((uint32_t)10000 << sf) / (bw * 10);
uint32_t sfCoeff1_x4 = (sf == 5 || sf == 6) ? 25 : 17; // 6.25 : 4.25, semtech magic numbers to account for sync word + sfd
// preamble + syncword + sfd + header
uint32_t preamble_us = (((preambleSymbols + 8) * 4 + sfCoeff1_x4) * tsym_us) / 4;
// airtime for max packet at current radio settings
uint32_t total_us = _radio->getTimeOnAir(MAX_TRANS_UNIT);
// airtime for payload only (no preamble, header or SOF).
//
// CUSTOM (TeTeHacko): the fallback taken when getTimeOnAir() is not usable yet
// must not underflow. Upstream writes the intended "4 secs at worst case" as
// 4000 -- these are MICROseconds, so 4 ms -- and then subtracts an unsigned
// preamble from it. Our CZ preset (SF8 / BW62.5) has a ~4.1 ms symbol time and
// a ~116 ms preamble, so the subtraction wraps to ~4.29e9 us and
// _maxPayloadMillis becomes ~4.29 million seconds. isReceiving() can then never
// time out a header it has latched: the radio reports "busy receiving" forever,
// RX is never re-armed, and the node goes deaf while still transmitting
// normally -- no acks, no channel messages, no adverts.
//
// Every SX126x/LR11x0 wrapper feeds this into its stateful isReceiving(), so it
// reaches the T1000-E and the Wio L1 as much as the SenseCap boards.
// Fix taken from ALLFATHER-BV/meshcomod d6a72f8 (MIT).
const uint32_t fallback_total_us = 4000000; // 4 SECONDS, in microseconds
const uint32_t base_us = (total_us > preamble_us) ? total_us : fallback_total_us;
uint32_t payload_us = (base_us > preamble_us) ? (base_us - preamble_us) : (base_us / 2);
// rescale payload_us for max possible CR
if (cr >= 5 && cr < 8) { payload_us = (payload_us * 8) / cr; }
return PacketMillis {(preamble_us + 999) / 1000, (payload_us + 999) / 1000};
}
#ifdef RADIO_DIAG
// CUSTOM (TeTeHacko): a receiver that silently stops receiving (31. 10. 2026,
// bench-sensor: recv frozen for minutes, noise_floor -120, last_rssi 0, a reboot
// revived it) can be stuck in several different places, and each one is a
// different bug:
//
// chip mode != RX -> the chip left RX (reset/brownout, or a
// command path that put it in standby)
// while `st` still says RX
// mode RX, RX_DONE in irq, DIO1=1 -> the packet is there and the line is up,
// but the edge never reached the MCU
// (isr count frozen): lost interrupt
// mode RX, irq clean, RSSI ~floor -> analog front end / AGC stuck
//
// `radiostat` reads all of it without touching the radio state. `radiokick`
// then applies ONE recovery step at a time, from the gentlest; the first step
// that brings recv back names the layer that was broken.
bool RadioLibWrapper::diagHandleCommand(const char* command, char* reply) {
if (strcmp(command, "radiostat") == 0) {
uint32_t now = millis();
int n = snprintf(reply, 160, "st=%u isr=%lu/%lus rx=%lu/%lus err=%lu",
(unsigned) state, (unsigned long) diag_isr_count,
(unsigned long) ((now - diag_isr_ms) / 1000),
(unsigned long) n_recv, (unsigned long) ((now - _diag_last_rx_ms) / 1000),
(unsigned long) n_recv_errors);
if (n > 0 && n < 160) diagChip(reply + n, 160 - n);
return true;
}
if (memcmp(command, "radiokick ", 10) == 0) {
const char* what = command + 10;
if (strcmp(what, "rx") == 0) { // re-arm RX only (no standby, no clear)
state = STATE_IDLE;
} else if (strcmp(what, "clrirq") == 0) { // drop latched IRQs: DIO1 falls, next RX_DONE is a new edge
_radio->clearIrqFlags(0xFFFFFFFF);
} else if (strcmp(what, "standby") == 0) { // standby + startReceive
idle();
} else if (strcmp(what, "agc") == 0) { // warm sleep + calibrate, the agc.reset path
doResetAGC();
state = STATE_IDLE;
} else {
strcpy(reply, "usage: radiokick rx|clrirq|standby|agc");
return true;
}
sprintf(reply, "OK - %s", what);
return true;
}
return false;
}
#endif