{

if (isDualRadio())

{

geminiMode = config.GetAntennaMode();

}

{

// Determine the most number of CRC-passing packets we could receive on

// a single channel out of 100 packets that fill the LQcalc span.

// The LQ must be GREATER THAN this value, not >=

// The amount of time we coexist on the same channel is

// 100 divided by the total number of packets in a FHSS loop (rounded up)

// and there would be 4x packets received each time it passes by so

// FHSShopInterval * ceil(100 / FHSShopInterval * numfhss) or

// FHSShopInterval * trunc((100 + (FHSShopInterval * numfhss) - 1) / (FHSShopInterval * numfhss))

// With a interval of 4 this works out to: 2.4=4, FCC915=4, AU915=8, EU868=8, EU/AU433=36

const uint32_t numfhss = FHSSgetChannelCount();

const uint8_t interval = ExpressLRS_currAirRate_Modparams->FHSShopInterval;

return interval * ((interval * numfhss + 99) / (interval * numfhss));

{

if (GPIO_PIN_NSS_2 != UNDEF_PIN)

{

antenna = (Radio.GetProcessingPacketRadio() == SX12XX_Radio_1) ? 0 : 1;

}

int32_t rssiDBM = Radio.LastPacketRSSI;

if (GPIO_PIN_NSS_2 != UNDEF_PIN)

{

int32_t rssiDBM2 = Radio.LastPacketRSSI2;

#if !defined(DEBUG_RCVR_LINKSTATS)

rssiDBM = LPF_UplinkRSSI0.update(rssiDBM);

rssiDBM2 = LPF_UplinkRSSI1.update(rssiDBM2);

#endif

rssiDBM = (rssiDBM > 0) ? 0 : rssiDBM;

rssiDBM2 = (rssiDBM2 > 0) ? 0 : rssiDBM2;

// BetaFlight/iNav expect positive values for -dBm (e.g. -80dBm -> sent as 80)

CRSF::LinkStatistics.uplink_RSSI_1 = -rssiDBM;

CRSF::LinkStatistics.uplink_RSSI_2 = -rssiDBM2;

antenna = (rssiDBM > rssiDBM2)? 0 : 1; // report a better antenna for the reception

}

else if (antenna == 0)

{

#if !defined(DEBUG_RCVR_LINKSTATS)

rssiDBM = LPF_UplinkRSSI0.update(rssiDBM);

#endif

if (rssiDBM > 0) rssiDBM = 0;

// BetaFlight/iNav expect positive values for -dBm (e.g. -80dBm -> sent as 80)

CRSF::LinkStatistics.uplink_RSSI_1 = -rssiDBM;

}

else

{

#if !defined(DEBUG_RCVR_LINKSTATS)

rssiDBM = LPF_UplinkRSSI1.update(rssiDBM);

#endif

if (rssiDBM > 0) rssiDBM = 0;

// BetaFlight/iNav expect positive values for -dBm (e.g. -80dBm -> sent as 80)

// May be overwritten below if DEBUG_BF_LINK_STATS is set

CRSF::LinkStatistics.uplink_RSSI_2 = -rssiDBM;

}

SnrMean.add(Radio.LastPacketSNRRaw);

CRSF::LinkStatistics.active_antenna = antenna;

CRSF::LinkStatistics.uplink_SNR = SNR_DESCALE(Radio.LastPacketSNRRaw); // possibly overriden below

//CRSF::LinkStatistics.uplink_Link_quality = uplinkLQ; // handled in Tick

CRSF::LinkStatistics.rf_Mode = ExpressLRS_currAirRate_Modparams->enum_rate;

//DBGLN(CRSF::LinkStatistics.uplink_RSSI_1);

#if defined(DEBUG_BF_LINK_STATS)

CRSF::LinkStatistics.downlink_RSSI = debug1;

CRSF::LinkStatistics.downlink_Link_quality = debug2;

CRSF::LinkStatistics.downlink_SNR = debug3;

CRSF::LinkStatistics.uplink_RSSI_2 = debug4;

#endif

#if defined(DEBUG_RCVR_LINKSTATS)

// DEBUG_RCVR_LINKSTATS gets full precision SNR, override the value

CRSF::LinkStatistics.uplink_SNR = Radio.LastPacketSNRRaw;

debugRcvrLinkstatsFhssIdx = FHSSsequence[FHSSptr];

#endif

{

expresslrs_mod_settings_s *const ModParams = get_elrs_airRateConfig(index);

expresslrs_rf_pref_params_s *const RFperf = get_elrs_RFperfParams(index);

bool invertIQ = UID[5] & 0x01;

uint32_t interval = ModParams->interval;

#if defined(DEBUG_FREQ_CORRECTION) && defined(RADIO_SX128X)

interval = interval * 12 / 10; // increase the packet interval by 20% to allow adding packet header

#endif

hwTimer::updateInterval(interval);

Radio.Config(ModParams->bw, ModParams->sf, ModParams->cr, GetInitialFreq(),

ModParams->PreambleLen, invertIQ, ModParams->PayloadLength, 0

#if defined(RADIO_SX128X)

, uidMacSeedGet(), OtaCrcInitializer, (ModParams->radio_type == RADIO_TYPE_SX128x_FLRC)

#endif

);

Radio.FuzzySNRThreshold = (RFperf->DynpowerSnrThreshUp == DYNPOWER_SNR_THRESH_NONE) ? 0 : (RFperf->DynpowerSnrThreshDn - RFperf->DynpowerSnrThreshUp);

checkGeminiMode();

if (geminiMode)

{

Radio.SetFrequencyReg(FHSSgetInitialGeminiFreq(), SX12XX_Radio_2);

}

OtaUpdateSerializers(smWideOr8ch, ModParams->PayloadLength);

MspReceiver.setMaxPackageIndex(ELRS_MSP_MAX_PACKAGES);

TelemetrySender.setMaxPackageIndex(OtaIsFullRes ? ELRS8_TELEMETRY_MAX_PACKAGES : ELRS4_TELEMETRY_MAX_PACKAGES);

// Wait for (11/10) 110% of time it takes to cycle through all freqs in FHSS table (in ms)

cycleInterval = ((uint32_t)11U * FHSSgetChannelCount() * ModParams->FHSShopInterval * interval) / (10U * 1000U);

ExpressLRS_currAirRate_Modparams = ModParams;

ExpressLRS_currAirRate_RFperfParams = RFperf;

ExpressLRS_nextAirRateIndex = index; // presumably we just handled this

telemBurstValid = false;

{

uint8_t modresultFHSS = (OtaNonce + 1) % ExpressLRS_currAirRate_Modparams->FHSShopInterval;

if ((ExpressLRS_currAirRate_Modparams->FHSShopInterval == 0) || alreadyFHSS == true || InBindingMode || (modresultFHSS != 0) || (connectionState == disconnected))

{

return false;

}

alreadyFHSS = true;

if (geminiMode)

{

if (((OtaNonce + 1)/ExpressLRS_currAirRate_Modparams->FHSShopInterval) % 2 == 0)

{

Radio.SetFrequencyReg(FHSSgetNextFreq(), SX12XX_Radio_1);

Radio.SetFrequencyReg(FHSSgetGeminiFreq(), SX12XX_Radio_2);

}

else

{

Radio.SetFrequencyReg(FHSSgetNextFreq(), SX12XX_Radio_2);

Radio.SetFrequencyReg(FHSSgetGeminiFreq(), SX12XX_Radio_1);

}

}

else

{

Radio.SetFrequencyReg(FHSSgetNextFreq());

}

#if defined(RADIO_SX127X)

// SX127x radio has to reset receive mode after hopping

uint8_t modresultTLM = (OtaNonce + 1) % ExpressLRS_currTlmDenom;

if (modresultTLM != 0 || ExpressLRS_currTlmDenom == 1) // if we are about to send a tlm response don't bother going back to rx

{

Radio.RXnb();

}

#endif

#if defined(Regulatory_Domain_EU_CE_2400)

SetClearChannelAssessmentTime();

#endif

return true;

{

// The value in linkstatistics is "positivized" (inverted polarity)

// and must be inverted on the TX side. Positive values are used

// so save a bit to encode which antenna is in use

ls->uplink_RSSI_1 = CRSF::LinkStatistics.uplink_RSSI_1;

ls->uplink_RSSI_2 = CRSF::LinkStatistics.uplink_RSSI_2;

ls->antenna = antenna;

ls->modelMatch = connectionHasModelMatch;

ls->lq = CRSF::LinkStatistics.uplink_Link_quality;

ls->mspConfirm = MspReceiver.GetCurrentConfirm() ? 1 : 0;

#if defined(DEBUG_FREQ_CORRECTION)

ls->SNR = FreqCorrection * 127 / FreqCorrectionMax;

#else

ls->SNR = SnrMean.mean();

#endif

{

uint8_t modresult = (OtaNonce + 1) % ExpressLRS_currTlmDenom;

if ((connectionState == disconnected) || (ExpressLRS_currTlmDenom == 1) || (alreadyTLMresp == true) || (modresult != 0))

{

return false; // don't bother sending tlm if disconnected or TLM is off

}

#if defined(Regulatory_Domain_EU_CE_2400)

BeginClearChannelAssessment();

#endif

// ESP requires word aligned buffer

WORD_ALIGNED_ATTR OTA_Packet_s otaPkt = {0};

alreadyTLMresp = true;

otaPkt.std.type = PACKET_TYPE_TLM;

if (NextTelemetryType == ELRS_TELEMETRY_TYPE_LINK || (!firmwareOptions.is_airport && !TelemetrySender.IsActive()))

{

OTA_LinkStats_s * ls;

if (OtaIsFullRes)

{

otaPkt.full.tlm_dl.containsLinkStats = 1;

ls = &otaPkt.full.tlm_dl.ul_link_stats.stats;

// Include some advanced telemetry in the extra space

// Note the use of `ul_link_stats.payload` vs just `payload`

otaPkt.full.tlm_dl.packageIndex = TelemetrySender.GetCurrentPayload(

otaPkt.full.tlm_dl.ul_link_stats.payload,

sizeof(otaPkt.full.tlm_dl.ul_link_stats.payload));

}

else

{

otaPkt.std.tlm_dl.type = ELRS_TELEMETRY_TYPE_LINK;

ls = &otaPkt.std.tlm_dl.ul_link_stats.stats;

}

LinkStatsToOta(ls);

NextTelemetryType = ELRS_TELEMETRY_TYPE_DATA;

// Start the count at 1 because the next will be DATA and doing +1 before checking

// against Max below is for some reason 10 bytes more code

telemetryBurstCount = 1;

}

else

{

if (telemetryBurstCount < telemetryBurstMax)

{

telemetryBurstCount++;

}

else

{

NextTelemetryType = ELRS_TELEMETRY_TYPE_LINK;

}

if (firmwareOptions.is_airport)

{

OtaPackAirportData(&otaPkt, &apInputBuffer);

}

else

{

if (OtaIsFullRes)

{

otaPkt.full.tlm_dl.packageIndex = TelemetrySender.GetCurrentPayload(

otaPkt.full.tlm_dl.payload,

sizeof(otaPkt.full.tlm_dl.payload));

}

else

{

otaPkt.std.tlm_dl.type = ELRS_TELEMETRY_TYPE_DATA;

otaPkt.std.tlm_dl.packageIndex = TelemetrySender.GetCurrentPayload(

otaPkt.std.tlm_dl.payload,

sizeof(otaPkt.std.tlm_dl.payload));

}

}

}

OtaGeneratePacketCrc(&otaPkt);

SX12XX_Radio_Number_t transmittingRadio = geminiMode ? SX12XX_Radio_All : Radio.GetLastSuccessfulPacketRadio();

#if defined(Regulatory_Domain_EU_CE_2400)

transmittingRadio &= ChannelIsClear(transmittingRadio); // weed out the radio(s) if channel in use

#endif

if (config.GetForceTlmOff())

{

transmittingRadio = SX12XX_Radio_NONE;

}

Radio.TXnb((uint8_t*)&otaPkt, ExpressLRS_currAirRate_Modparams->PayloadLength, transmittingRadio);

return true;

{

int32_t tempFC = FreqCorrection;

if (Radio.GetProcessingPacketRadio() == SX12XX_Radio_2)

{

tempFC = FreqCorrection_2;

}

if (value)

{

if (tempFC > FreqCorrectionMin)

{

tempFC--; // FREQ_STEP units

if (tempFC == FreqCorrectionMin)

{

DBGLN("Max -FreqCorrection reached!");

}

}

}

else

{

if (tempFC < FreqCorrectionMax)

{

tempFC++; // FREQ_STEP units

if (tempFC == FreqCorrectionMax)

{

DBGLN("Max +FreqCorrection reached!");

}

}

}

if (Radio.GetProcessingPacketRadio() == SX12XX_Radio_1)

{

FreqCorrection = tempFC;

}

else

{

FreqCorrection_2 = tempFC;

}

return tempFC;

{

if (connectionState != disconnected && PFDloop.hasResult())

{

int32_t RawOffset = PFDloop.calcResult();

int32_t Offset = LPF_Offset.update(RawOffset);

int32_t OffsetDx = LPF_OffsetDx.update(RawOffset - PfdPrevRawOffset);

PfdPrevRawOffset = RawOffset;

if (RXtimerState == tim_locked)

{

// limit rate of freq offset adjustment, use slot 1

// because telemetry can fall on slot 1 and will

// never get here

if (OtaNonce % 8 == 1)

{

if (Offset > 0)

{

hwTimer::incFreqOffset();

}

else if (Offset < 0)

{

hwTimer::decFreqOffset();

}

}

}

if (connectionState != connected)

{

hwTimer::phaseShift(RawOffset >> 1);

}

else

{

hwTimer::phaseShift(Offset >> 2);

}

DBGVLN("%d:%d:%d:%d:%d", Offset, RawOffset, OffsetDx, hwTimer::FreqOffset, uplinkLQ);

UNUSED(OffsetDx); // complier warning if no debug

}

PFDloop.reset();

{

updatePhaseLock();

OtaNonce++;

// if (!alreadyTLMresp && !alreadyFHSS && !LQCalc.currentIsSet()) // packet timeout AND didn't DIDN'T just hop or send TLM

// {

// Radio.RXnb(); // put the radio cleanly back into RX in case of garbage data

// }

if (ExpressLRS_currAirRate_Modparams->numOfSends == 1)

{

// Save the LQ value before the inc() reduces it by 1

uplinkLQ = LQCalc.getLQ();

} else

if (!((OtaNonce - 1) % ExpressLRS_currAirRate_Modparams->numOfSends))

{

uplinkLQ = LQCalcDVDA.getLQ();

LQCalcDVDA.inc();

}

CRSF::LinkStatistics.uplink_Link_quality = uplinkLQ;

// Only advance the LQI period counter if we didn't send Telemetry this period

if (!alreadyTLMresp)

LQCalc.inc();

alreadyTLMresp = false;

alreadyFHSS = false;

{

if (GPIO_PIN_ANT_CTRL != UNDEF_PIN && config.GetAntennaMode() == 2)

{

// 0 and 1 is use for gpio_antenna_select

// 2 is diversity

antenna = !antenna;

(antenna == 0) ? LPF_UplinkRSSI0.reset() : LPF_UplinkRSSI1.reset(); // discard the outdated value after switching

digitalWrite(GPIO_PIN_ANT_CTRL, antenna);

if (GPIO_PIN_ANT_CTRL_COMPL != UNDEF_PIN)

{

digitalWrite(GPIO_PIN_ANT_CTRL_COMPL, !antenna);

}

}

{

if (GPIO_PIN_ANT_CTRL != UNDEF_PIN)

{

if(config.GetAntennaMode() == 2)

{

// 0 and 1 is use for gpio_antenna_select

// 2 is diversity

static int32_t prevRSSI; // saved rssi so that we can compare if switching made things better or worse

static int32_t antennaLQDropTrigger;

static int32_t antennaRSSIDropTrigger;

int32_t rssi = (antenna == 0) ? LPF_UplinkRSSI0.value() : LPF_UplinkRSSI1.value();

int32_t otherRSSI = (antenna == 0) ? LPF_UplinkRSSI1.value() : LPF_UplinkRSSI0.value();

//if rssi dropped by the amount of DIVERSITY_ANTENNA_RSSI_TRIGGER

if ((rssi < (prevRSSI - DIVERSITY_ANTENNA_RSSI_TRIGGER)) && antennaRSSIDropTrigger >= DIVERSITY_ANTENNA_INTERVAL)

{

switchAntenna();

antennaLQDropTrigger = 1;

antennaRSSIDropTrigger = 0;

}

else if (rssi > prevRSSI || antennaRSSIDropTrigger < DIVERSITY_ANTENNA_INTERVAL)

{

prevRSSI = rssi;

antennaRSSIDropTrigger++;

}

// if we didn't get a packet switch the antenna

if (!LQCalc.currentIsSet() && antennaLQDropTrigger == 0)

{

switchAntenna();

antennaLQDropTrigger = 1;

antennaRSSIDropTrigger = 0;

}

else if (antennaLQDropTrigger >= DIVERSITY_ANTENNA_INTERVAL)

{

// We switched antenna on the previous packet, so we now have relatively fresh rssi info for both antennas.

// We can compare the rssi values and see if we made things better or worse when we switched

if (rssi < otherRSSI)

{

// things got worse when we switched, so change back.

switchAntenna();

antennaLQDropTrigger = 1;

antennaRSSIDropTrigger = 0;

}

else

{

// all good, we can stay on the current antenna. Clear the flag.

antennaLQDropTrigger = 0;

}

}

else if (antennaLQDropTrigger > 0)

{

antennaLQDropTrigger ++;

}

}

else

{

digitalWrite(GPIO_PIN_ANT_CTRL, config.GetAntennaMode());

if (GPIO_PIN_ANT_CTRL_COMPL != UNDEF_PIN)

{

digitalWrite(GPIO_PIN_ANT_CTRL_COMPL, !config.GetAntennaMode());

}

antenna = config.GetAntennaMode();

}

}

{

if (tlmSent && Radio.GetLastTransmitRadio() == SX12XX_Radio_NONE)

{

Radio.TXdoneCallback();

}

PFDloop.intEvent(micros()); // our internal osc just fired

if (ExpressLRS_currAirRate_Modparams->numOfSends > 1 && !(OtaNonce % ExpressLRS_currAirRate_Modparams->numOfSends) && LQCalcDVDA.currentIsSet())

{

crsfRCFrameAvailable();

servoNewChannelsAvailable();

}

if (!didFHSS)

{

HandleFHSS();

}

didFHSS = false;

Radio.isFirstRxIrq = true;

updateDiversity();

tlmSent = HandleSendTelemetryResponse();

#if defined(DEBUG_RX_SCOREBOARD)

static bool lastPacketWasTelemetry = false;

if (!LQCalc.currentIsSet() && !lastPacketWasTelemetry)

DBGW(lastPacketCrcError ? '.' : '_');

lastPacketCrcError = false;

lastPacketWasTelemetry = tlmSent;

#endif

{

DBGLN("lost conn fc=%d fo=%d", FreqCorrection, hwTimer::getFreqOffset());

// Use this rate as the initial rate next time if we connected on it

if (connectionState == connected)

config.SetRateInitialIdx(ExpressLRS_nextAirRateIndex);

RFmodeCycleMultiplier = 1;

connectionState = disconnected; //set lost connection

RXtimerState = tim_disconnected;

hwTimer::resetFreqOffset();

PfdPrevRawOffset = 0;

GotConnectionMillis = 0;

uplinkLQ = 0;

LQCalc.reset();

LQCalcDVDA.reset();

LPF_Offset.init(0);

LPF_OffsetDx.init(0);

alreadyTLMresp = false;

alreadyFHSS = false;

if (!InBindingMode)

{

if (hwTimer::running)

{

while(micros() - PFDloop.getIntEventTime() > 250); // time it just after the tock()

hwTimer::stop();

}

SetRFLinkRate(ExpressLRS_nextAirRateIndex); // also sets to initialFreq

// If not resumRx, Radio will be left in SX127x_OPMODE_STANDBY / SX1280_MODE_STDBY_XOSC

if (resumeRx)

{

Radio.RXnb();

}

}

{

PFDloop.reset();

connectionState = tentative;

connectionHasModelMatch = false;

RXtimerState = tim_disconnected;

DBGLN("tentative conn");

PfdPrevRawOffset = 0;

LPF_Offset.init(0);

SnrMean.reset();

RFmodeLastCycled = now; // give another 3 sec for lock to occur

// The caller MUST call hwTimer::resume(). It is not done here because

// the timer ISR will fire immediately and preempt any other code

{

if (connectionState == connected)

{

return; // Already connected

}

LockRFmode = firmwareOptions.lock_on_first_connection;

connectionState = connected; //we got a packet, therefore no lost connection

RXtimerState = tim_tentative;

GotConnectionMillis = now;

#if defined(PLATFORM_ESP32) || defined(PLATFORM_ESP8266)

webserverPreventAutoStart = true;

#endif

if (firmwareOptions.is_airport)

{

apInputBuffer.flush();

apOutputBuffer.flush();

}

DBGLN("got conn");

{

// Must be fully connected to process RC packets, prevents processing RC

// during sync, where packets can be received before connection

if (connectionState != connected || SwitchModePending)

return;

bool telemetryConfirmValue = OtaUnpackChannelData(otaPktPtr, ChannelData, ExpressLRS_currTlmDenom);

TelemetrySender.ConfirmCurrentPayload(telemetryConfirmValue);

// No channels packets to the FC or PWM pins if no model match

if (connectionHasModelMatch)

{

if (ExpressLRS_currAirRate_Modparams->numOfSends == 1)

{

crsfRCFrameAvailable();

servoNewChannelsAvailable();

}

else if (!LQCalcDVDA.currentIsSet())

{

LQCalcDVDA.add();

}

#if defined(DEBUG_RCVR_LINKSTATS)

debugRcvrLinkstatsPending = true;

#endif

}

{

uint8_t packageIndex;

uint8_t const * payload;

uint8_t dataLen;

if (OtaIsFullRes)

{

packageIndex = otaPktPtr->full.msp_ul.packageIndex;

payload = otaPktPtr->full.msp_ul.payload;

dataLen = sizeof(otaPktPtr->full.msp_ul.payload);

}

else

{

packageIndex = otaPktPtr->std.msp_ul.packageIndex;

payload = otaPktPtr->std.msp_ul.payload;

dataLen = sizeof(otaPktPtr->std.msp_ul.payload);

}

// Always examine MSP packets for bind information if in bind mode

// [1] is the package index, first packet of the MSP

if (InBindingMode && packageIndex == 1 && payload[0] == MSP_ELRS_BIND)

{

OnELRSBindMSP((uint8_t *)&payload[1]);

return;

}

// Must be fully connected to process MSP, prevents processing MSP

// during sync, where packets can be received before connection

if (connectionState != connected)

return;

bool currentMspConfirmValue = MspReceiver.GetCurrentConfirm();

MspReceiver.ReceiveData(packageIndex, payload, dataLen);

if (currentMspConfirmValue != MspReceiver.GetCurrentConfirm())

{

NextTelemetryType = ELRS_TELEMETRY_TYPE_LINK;

}

{

if (OtaSwitchModeCurrent == newSwitchMode)

{

// Cancel any switch if pending

SwitchModePending = 0;

return;

}

// One is added to the mode because SwitchModePending==0 means no switch pending

// and that's also a valid switch mode. The 1 is removed when this is handled.

// A negative SwitchModePending means not to switch yet

int8_t newSwitchModePending = -(int8_t)newSwitchMode - 1;

// Switch mode can be changed while disconnected

// OR there are two sync packets with the same new switch mode,

// as a "confirm". No RC packets are processed until

if (connectionState == disconnected ||

SwitchModePending == newSwitchModePending)

{

// Add one to the mode because SwitchModePending==0 means no switch pending

// and that's also a valid switch mode. The 1 is removed when this is handled

SwitchModePending = newSwitchMode + 1;

}

else

{

// Save the negative version of the new switch mode to compare

// against on the next SYNC packet, but do not switch yet

SwitchModePending = newSwitchModePending;

}

{

// Verify the first two of three bytes of the binding ID, which should always match

if (otaSync->UID3 != UID[3] || otaSync->UID4 != UID[4])

return false;

// The third byte will be XORed with inverse of the ModelId if ModelMatch is on

// Only require the first 18 bits of the UID to match to establish a connection

// but the last 6 bits must modelmatch before sending any data to the FC

if ((otaSync->UID5 & ~MODELMATCH_MASK) != (UID[5] & ~MODELMATCH_MASK))

return false;

LastSyncPacket = now;

#if defined(DEBUG_RX_SCOREBOARD)

DBGW('s');

#endif

// Will change the packet air rate in loop() if this changes

ExpressLRS_nextAirRateIndex = otaSync->rateIndex;

updateSwitchModePendingFromOta(otaSync->switchEncMode);

// Update TLM ratio, should never be TLM_RATIO_STD/DISARMED, the TX calculates the correct value for the RX

expresslrs_tlm_ratio_e TLMrateIn = (expresslrs_tlm_ratio_e)(otaSync->newTlmRatio + (uint8_t)TLM_RATIO_NO_TLM);

uint8_t TlmDenom = TLMratioEnumToValue(TLMrateIn);

if (ExpressLRS_currTlmDenom != TlmDenom)

{

DBGLN("New TLMrate 1:%u", TlmDenom);

ExpressLRS_currTlmDenom = TlmDenom;

telemBurstValid = false;

}

// modelId = 0xff indicates modelMatch is disabled, the XOR does nothing in that case

uint8_t modelXor = (~config.GetModelId()) & MODELMATCH_MASK;

bool modelMatched = otaSync->UID5 == (UID[5] ^ modelXor);

DBGVLN("MM %u=%u %d", otaSync->UID5, UID[5], modelMatched);

if (connectionState == disconnected

|| OtaNonce != otaSync->nonce

|| FHSSgetCurrIndex() != otaSync->fhssIndex

|| connectionHasModelMatch != modelMatched)

{

//DBGLN("\r\n%ux%ux%u", OtaNonce, otaPktPtr->sync.nonce, otaPktPtr->sync.fhssIndex);

FHSSsetCurrIndex(otaSync->fhssIndex);

OtaNonce = otaSync->nonce;

TentativeConnection(now);

// connectionHasModelMatch must come after TentativeConnection, which resets it

connectionHasModelMatch = modelMatched;

return true;

}

return false;

{

if (status != SX12xxDriverCommon::SX12XX_RX_OK)

{

DBGVLN("HW CRC error");

#if defined(DEBUG_RX_SCOREBOARD)

lastPacketCrcError = true;

#endif

return false;

}

uint32_t const beginProcessing = micros();