Fixed hanging on 'defaults nosave' when RX_SERIAL is enabled. (#8946)

Fixed hanging on 'defaults nosave' when RX_SERIAL is enabled.

src/main/cli/cli.c

@@ -3335,8 +3335,13 @@ static void cliBeeper(char *cmdline)
 #if defined(USE_RX_SPI) || defined (USE_SERIALRX_SRXL2)
 void cliRxBind(char *cmdline){
     UNUSED(cmdline);
-    if (featureIsEnabled(FEATURE_RX_SERIAL)) {
+    switch (rxRuntimeConfig.rxProvider) {
-        switch (rxConfig()->serialrx_provider) {
+    default:
+        cliPrint("Not supported.");
+
+        break;
+    case RX_PROVIDER_SERIAL:
+        switch (rxRuntimeConfig.serialrxProvider) {
         default:
             cliPrint("Not supported.");
             break;
@@ -3347,9 +3352,10 @@ void cliRxBind(char *cmdline){
             break;
 #endif
         }
-    } 
+
+        break;
 #if defined(USE_RX_SPI)
-    else if (featureIsEnabled(FEATURE_RX_SPI)) {
+    case RX_PROVIDER_SPI:
         switch (rxSpiConfig()->rx_spi_protocol) {
         default:
             cliPrint("Not supported.");
@@ -3380,8 +3386,9 @@ void cliRxBind(char *cmdline){
 #endif
         }
 
-    }
+        break;
 #endif
+    }
 }
 #endif
 

src/main/fc/tasks.c

@@ -293,10 +293,10 @@ void fcTasksInit(void)
 #ifdef USE_TELEMETRY
     if (featureIsEnabled(FEATURE_TELEMETRY)) {
         setTaskEnabled(TASK_TELEMETRY, true);
-        if (rxConfig()->serialrx_provider == SERIALRX_JETIEXBUS) {
+        if (rxRuntimeConfig.serialrxProvider == SERIALRX_JETIEXBUS) {
             // Reschedule telemetry to 500hz for Jeti Exbus
             rescheduleTask(TASK_TELEMETRY, TASK_PERIOD_HZ(500));
-        } else if (rxConfig()->serialrx_provider == SERIALRX_CRSF) {
+        } else if (rxRuntimeConfig.serialrxProvider == SERIALRX_CRSF) {
             // Reschedule telemetry to 500hz, 2ms for CRSF
             rescheduleTask(TASK_TELEMETRY, TASK_PERIOD_HZ(500));
         }

src/main/rx/pwm.c

@@ -60,12 +60,20 @@ void rxPwmInit(const rxConfig_t *rxConfig, rxRuntimeConfig_t *rxRuntimeConfig)
     rxRuntimeConfig->rxRefreshRate = 20000;
 
     // configure PWM/CPPM read function and max number of channels. serial rx below will override both of these, if enabled
-    if (featureIsEnabled(FEATURE_RX_PARALLEL_PWM)) {
+    switch (rxRuntimeConfig->rxProvider) {
+    default:
+
+        break;
+    case RX_PROVIDER_PARALLEL_PWM:
         rxRuntimeConfig->channelCount = MAX_SUPPORTED_RC_PARALLEL_PWM_CHANNEL_COUNT;
         rxRuntimeConfig->rcReadRawFn = pwmReadRawRC;
-    } else if (featureIsEnabled(FEATURE_RX_PPM)) {
+
+        break;
+    case RX_PROVIDER_PPM:
         rxRuntimeConfig->channelCount = MAX_SUPPORTED_RC_PPM_CHANNEL_COUNT;
         rxRuntimeConfig->rcReadRawFn = ppmReadRawRC;
+
+        break;
     }
 }
 #endif

src/main/rx/rx.c

@@ -180,10 +180,10 @@ STATIC_UNIT_TESTED bool isPulseValid(uint16_t pulseDuration)
 }
 
 #ifdef USE_SERIAL_RX
-bool serialRxInit(const rxConfig_t *rxConfig, rxRuntimeConfig_t *rxRuntimeConfig)
+static bool serialRxInit(const rxConfig_t *rxConfig, rxRuntimeConfig_t *rxRuntimeConfig)
 {
     bool enabled = false;
-    switch (rxConfig->serialrx_provider) {
+    switch (rxRuntimeConfig->serialrxProvider) {
 #ifdef USE_SERIALRX_SRXL2
     case SERIALRX_SRXL2:
         enabled = srxl2RxInit(rxConfig, rxRuntimeConfig);
@@ -252,6 +252,20 @@ bool serialRxInit(const rxConfig_t *rxConfig, rxRuntimeConfig_t *rxRuntimeConfig
 
 void rxInit(void)
 {
+    if (featureIsEnabled(FEATURE_RX_PARALLEL_PWM)) {
+        rxRuntimeConfig.rxProvider = RX_PROVIDER_PARALLEL_PWM;
+    } else if (featureIsEnabled(FEATURE_RX_PPM)) {
+        rxRuntimeConfig.rxProvider = RX_PROVIDER_PPM;
+    } else if (featureIsEnabled(FEATURE_RX_SERIAL)) {
+        rxRuntimeConfig.rxProvider = RX_PROVIDER_SERIAL;
+    } else if (featureIsEnabled(FEATURE_RX_MSP)) {
+        rxRuntimeConfig.rxProvider = RX_PROVIDER_MSP;
+    } else if (featureIsEnabled(FEATURE_RX_SPI)) {
+        rxRuntimeConfig.rxProvider = RX_PROVIDER_SPI;
+    } else {
+        rxRuntimeConfig.rxProvider = RX_PROVIDER_NONE;
+    }
+    rxRuntimeConfig.serialrxProvider = rxConfig()->serialrx_provider;
     rxRuntimeConfig.rcReadRawFn = nullReadRawRC;
     rxRuntimeConfig.rcFrameStatusFn = nullFrameStatus;
     rxRuntimeConfig.rcProcessFrameFn = nullProcessFrame;
@@ -282,38 +296,52 @@ void rxInit(void)
         }
     }
 
+    switch (rxRuntimeConfig.rxProvider) {
+    default:
+
+        break;
 #ifdef USE_SERIAL_RX
-    if (featureIsEnabled(FEATURE_RX_SERIAL)) {
+    case RX_PROVIDER_SERIAL:
+        {
             const bool enabled = serialRxInit(rxConfig(), &rxRuntimeConfig);
             if (!enabled) {
                 rxRuntimeConfig.rcReadRawFn = nullReadRawRC;
                 rxRuntimeConfig.rcFrameStatusFn = nullFrameStatus;
             }
         }
+
+        break;
 #endif
 
 #ifdef USE_RX_MSP
-    if (featureIsEnabled(FEATURE_RX_MSP)) {
+    case RX_PROVIDER_MSP:
         rxMspInit(rxConfig(), &rxRuntimeConfig);
         needRxSignalMaxDelayUs = DELAY_5_HZ;
-    }
+
+        break;
 #endif
 
 #ifdef USE_RX_SPI
-    if (featureIsEnabled(FEATURE_RX_SPI)) {
+    case RX_PROVIDER_SPI:
+        {
             const bool enabled = rxSpiInit(rxSpiConfig(), &rxRuntimeConfig);
             if (!enabled) {
                 rxRuntimeConfig.rcReadRawFn = nullReadRawRC;
                 rxRuntimeConfig.rcFrameStatusFn = nullFrameStatus;
             }
         }
+
+        break;
 #endif
 
 #if defined(USE_PWM) || defined(USE_PPM)
-    if (featureIsEnabled(FEATURE_RX_PPM | FEATURE_RX_PARALLEL_PWM)) {
+    case RX_PROVIDER_PPM:
+    case RX_PROVIDER_PARALLEL_PWM:
         rxPwmInit(rxConfig(), &rxRuntimeConfig);
-    }
+
+        break;
 #endif
+    }
 
 #if defined(USE_ADC)
     if (featureIsEnabled(FEATURE_RSSI_ADC)) {
@@ -343,7 +371,7 @@ bool rxAreFlightChannelsValid(void)
 void suspendRxPwmPpmSignal(void)
 {
 #if defined(USE_PWM) || defined(USE_PPM)
-    if (featureIsEnabled(FEATURE_RX_PARALLEL_PWM | FEATURE_RX_PPM)) {
+    if (rxRuntimeConfig.rxProvider == RX_PROVIDER_PARALLEL_PWM || rxRuntimeConfig.rxProvider == RX_PROVIDER_PPM) {
         suspendRxSignalUntil = micros() + SKIP_RC_ON_SUSPEND_PERIOD;
         skipRxSamples = SKIP_RC_SAMPLES_ON_RESUME;
         failsafeOnRxSuspend(SKIP_RC_ON_SUSPEND_PERIOD);
@@ -354,7 +382,7 @@ void suspendRxPwmPpmSignal(void)
 void resumeRxPwmPpmSignal(void)
 {
 #if defined(USE_PWM) || defined(USE_PPM)
-    if (featureIsEnabled(FEATURE_RX_PARALLEL_PWM | FEATURE_RX_PPM)) {
+    if (rxRuntimeConfig.rxProvider == RX_PROVIDER_PARALLEL_PWM || rxRuntimeConfig.rxProvider == RX_PROVIDER_PPM) {
         suspendRxSignalUntil = micros();
         skipRxSamples = SKIP_RC_SAMPLES_ON_RESUME;
         failsafeOnRxResume();
@@ -419,23 +447,33 @@ bool rxUpdateCheck(timeUs_t currentTimeUs, timeDelta_t currentDeltaTime)
     bool signalReceived = false;
     bool useDataDrivenProcessing = true;
 
+    switch (rxRuntimeConfig.rxProvider) {
+    default:
+
+        break;
 #if defined(USE_PWM) || defined(USE_PPM)
-    if (featureIsEnabled(FEATURE_RX_PPM)) {
+    case RX_PROVIDER_PPM:
         if (isPPMDataBeingReceived()) {
             signalReceived = true;
             rxIsInFailsafeMode = false;
             needRxSignalBefore = currentTimeUs + needRxSignalMaxDelayUs;
             resetPPMDataReceivedState();
         }
-    } else if (featureIsEnabled(FEATURE_RX_PARALLEL_PWM)) {
+
+        break;
+    case RX_PROVIDER_PARALLEL_PWM:
         if (isPWMDataBeingReceived()) {
             signalReceived = true;
             rxIsInFailsafeMode = false;
             needRxSignalBefore = currentTimeUs + needRxSignalMaxDelayUs;
             useDataDrivenProcessing = false;
         }
-    } else
+
+        break;
 #endif
+    case RX_PROVIDER_SERIAL:
+    case RX_PROVIDER_MSP:
+    case RX_PROVIDER_SPI:
         {
             const uint8_t frameStatus = rxRuntimeConfig.rcFrameStatusFn(&rxRuntimeConfig);
             if (frameStatus & RX_FRAME_COMPLETE) {
@@ -454,6 +492,9 @@ bool rxUpdateCheck(timeUs_t currentTimeUs, timeDelta_t currentDeltaTime)
             }
         }
 
+        break;
+    }
+
     if (signalReceived) {
         rxSignalReceived = true;
     } else if (currentTimeUs >= needRxSignalBefore) {
@@ -584,7 +625,7 @@ static void detectAndApplySignalLossBehaviour(void)
             }
         }
 #if defined(USE_PWM) || defined(USE_PPM)
-        if (featureIsEnabled(FEATURE_RX_PARALLEL_PWM | FEATURE_RX_PPM)) {
+        if (rxRuntimeConfig.rxProvider == RX_PROVIDER_PARALLEL_PWM || rxRuntimeConfig.rxProvider == RX_PROVIDER_PPM) {
             // smooth output for PWM and PPM
             rcData[channel] = calculateChannelMovingAverage(channel, sample);
         } else

src/main/rx/rx.h

@@ -126,7 +126,18 @@ typedef uint16_t (*rcReadRawDataFnPtr)(const struct rxRuntimeConfig_s *rxRuntime
 typedef uint8_t (*rcFrameStatusFnPtr)(struct rxRuntimeConfig_s *rxRuntimeConfig);
 typedef bool (*rcProcessFrameFnPtr)(const struct rxRuntimeConfig_s *rxRuntimeConfig);
 
+typedef enum {
+    RX_PROVIDER_NONE = 0,
+    RX_PROVIDER_PARALLEL_PWM,
+    RX_PROVIDER_PPM,
+    RX_PROVIDER_SERIAL,
+    RX_PROVIDER_MSP,
+    RX_PROVIDER_SPI,
+} rxProvider_t;
+
 typedef struct rxRuntimeConfig_s {
+    rxProvider_t        rxProvider;
+    SerialRXType        serialrxProvider;
     uint8_t             channelCount; // number of RC channels as reported by current input driver
     uint16_t            rxRefreshRate;
     rcReadRawDataFnPtr  rcReadRawFn;

src/main/rx/spektrum.c

@@ -242,7 +242,7 @@ void spektrumBind(rxConfig_t *rxConfig)
         ioTag_t rxPin = serialPinConfig()->ioTagRx[index];
 
         // Take care half-duplex case
-        switch (rxConfig->serialrx_provider) {
+        switch (rxRuntimeConfig.serialrxProvider) {
         case SERIALRX_SRXL:
 #if defined(USE_TELEMETRY_SRXL)
             if (featureIsEnabled(FEATURE_TELEMETRY) && !telemetryCheckRxPortShared(portConfig)) {
@@ -357,7 +357,10 @@ bool spektrumInit(const rxConfig_t *rxConfig, rxRuntimeConfig_t *rxRuntimeConfig
     bool portShared = false;
 #endif
 
-    switch (rxConfig->serialrx_provider) {
+    switch (rxRuntimeConfig->serialrxProvider) {
+    default:
+
+        break;
     case SERIALRX_SRXL:
 #if defined(USE_TELEMETRY_SRXL)
         srxlEnabled = (featureIsEnabled(FEATURE_TELEMETRY) && !portShared);

src/main/rx/xbus.c

@@ -266,7 +266,7 @@ bool xBusInit(const rxConfig_t *rxConfig, rxRuntimeConfig_t *rxRuntimeConfig)
 {
     uint32_t baudRate;
 
-    switch (rxConfig->serialrx_provider) {
+    switch (rxRuntimeConfig->serialrxProvider) {
     case SERIALRX_XBUS_MODE_B:
         rxRuntimeConfig->channelCount = XBUS_CHANNEL_COUNT;
         xBusFrameReceived = false;

src/main/telemetry/telemetry.c

@@ -136,21 +136,21 @@ bool telemetryDetermineEnabledState(portSharing_e portSharing)
 bool telemetryCheckRxPortShared(const serialPortConfig_t *portConfig)
 {
     if (portConfig->functionMask & FUNCTION_RX_SERIAL && portConfig->functionMask & TELEMETRY_SHAREABLE_PORT_FUNCTIONS_MASK &&
-        (rxConfig()->serialrx_provider == SERIALRX_SPEKTRUM1024 ||
+        (rxRuntimeConfig.serialrxProvider == SERIALRX_SPEKTRUM1024 ||
-        rxConfig()->serialrx_provider == SERIALRX_SPEKTRUM2048 ||
+        rxRuntimeConfig.serialrxProvider == SERIALRX_SPEKTRUM2048 ||
-        rxConfig()->serialrx_provider == SERIALRX_SBUS ||
+        rxRuntimeConfig.serialrxProvider == SERIALRX_SBUS ||
-        rxConfig()->serialrx_provider == SERIALRX_SUMD ||
+        rxRuntimeConfig.serialrxProvider == SERIALRX_SUMD ||
-        rxConfig()->serialrx_provider == SERIALRX_SUMH ||
+        rxRuntimeConfig.serialrxProvider == SERIALRX_SUMH ||
-        rxConfig()->serialrx_provider == SERIALRX_XBUS_MODE_B ||
+        rxRuntimeConfig.serialrxProvider == SERIALRX_XBUS_MODE_B ||
-        rxConfig()->serialrx_provider == SERIALRX_XBUS_MODE_B_RJ01 ||
+        rxRuntimeConfig.serialrxProvider == SERIALRX_XBUS_MODE_B_RJ01 ||
-        rxConfig()->serialrx_provider == SERIALRX_IBUS)) {
+        rxRuntimeConfig.serialrxProvider == SERIALRX_IBUS)) {
 
         return true;
     }
 #ifdef USE_TELEMETRY_IBUS
     if (   portConfig->functionMask & FUNCTION_TELEMETRY_IBUS
         && portConfig->functionMask & FUNCTION_RX_SERIAL
-        && rxConfig()->serialrx_provider == SERIALRX_IBUS) {
+        && rxRuntimeConfig.serialrxProvider == SERIALRX_IBUS) {
         // IBUS serial RX & telemetry
         return true;
     }