maintenance-10.x into next-10.1

docs/Cli.md

@@ -245,7 +245,7 @@ Note that the usual caveat that one should not share a timer with both a motor a
 
 ## Flash chip management
 
-For targets that have a flash data chip, typically used for blackbox logs, the following additional comamnds are provided.
+For targets that have a flash data chip, typically used for blackbox logs, the following additional commands are provided.
 
 | Command | Effect |
 | ------- | ------ |

docs/OSD.md

@@ -192,7 +192,7 @@ Here are the OSD Elements provided by INAV.
 | 157 | OSD_CUSTOM_ELEMENT_7                             | 8.0.0  |       |
 | 158 | OSD_CUSTOM_ELEMENT_8                             | 8.0.0  |       |
 | 159 | OSD_LQ_DOWNLINK                                  | 8.0.0  |       |
-| 160 | OSD_RX_POWER_DOWNLINK                            | 8.0.0  |       |
+| 160 | OSD_RX_POWER_DOWNLINK                            | 8.0.0  | The element is hidden while the receiver transmit power is 0 mW, which is also the value when the RC link does not report it. MSP receivers that send `MSP2_COMMON_SET_MSP_RC_INFO` and mLRS as MAVLink receiver report it (mLRS at 0 dBm or less reads as 0 mW). INAV does not read it from CRSF links such as ExpressLRS. |
 | 161 | OSD_RX_BAND                                      | 8.0.0  |       |
 | 162 | OSD_RX_MODE                                      | 8.0.0  |       |
 | 163 | OSD_COURSE_TO_FENCE                              | 8.0.0  |       |

docs/Serial.md

@@ -48,6 +48,7 @@ e.g. after configuring a port for GPS enable the GPS feature.
 * All telemetry systems except MSP will ignore any attempts to override the baudrate.
 * MSP/CLI can be shared with EITHER Blackbox OR telemetry (LTM or MAVlink, not RX telemetry).  In shared mode blackbox or telemetry will be output only when armed.
 * Smartport telemetry cannot be shared with MSP.
+* SBUS servo output (`SERVO_SERIAL`) can only be used on one port. The `serial` CLI command refuses to assign it to a second port. If a saved configuration already has it on several ports, only the first one in the `serial` list outputs SBUS.
 * No other serial port sharing combinations are valid.
 * You can use as many different telemetry systems as you like at the same time.
 * You can only use each telemetry system once.  e.g.  FrSky telemetry cannot be used on two port, but LTN Telemetry and FrSky on two different ports is fine.

src/main/common/string_light.c

@@ -82,3 +82,29 @@ int sl_strncasecmp(const char * s1, const char * s2, int n)
 
     return d;
 }
+
+const char * sl_strnstr(const char * haystack, const char * needle, int n)
+{
+    if (*needle == '\0') {
+        return haystack;
+    }
+    for (; n > 0 && *haystack != '\0'; haystack++, n--) {
+        const char * h = haystack;
+        const char * nd = needle;
+        int left = n;
+        while (left > 0 && *h != '\0' && *h == *nd) {
+            h++;
+            nd++;
+            left--;
+        }
+        if (*nd == '\0') {
+            return haystack;
+        }
+    }
+    return NULL;
+}
+
+const char * sl_strstr(const char * haystack, const char * needle)
+{
+    return sl_strnstr(haystack, needle, INT_MAX);
+}

src/main/common/string_light.h

@@ -27,3 +27,6 @@ void sl_toupperptr(char * c);
 
 int sl_strcasecmp(const char * s1, const char * s2);
 int sl_strncasecmp(const char * s1, const char * s2, int n);
+// newlib's strstr/strnstr link the two-way search machinery (~2.8 KB); plain scans are enough here
+const char * sl_strstr(const char * haystack, const char * needle);
+const char * sl_strnstr(const char * haystack, const char * needle, int n);

src/main/drivers/compass/compass_ist8310.c

@@ -84,7 +84,6 @@
  *      This bit will be set to zero after POR routine
  */
 
-#define IST8310_REG_DATA 0x03
 #define IST8310_REG_STAT1 0x02
 #define IST8310_DRDY_MASK 0x01
 #define IST8310_REG_WHOAMI 0x00
@@ -96,64 +95,62 @@
 #define IST8310_REG_PDCNTL 0x42
 
 // Parameter
-// ODR = Output Data Rate, we use single measure mode for getting more data.
 #define IST8310_ODR_SINGLE 0x01
-#define IST8310_ODR_10_HZ 0x03
-#define IST8310_ODR_20_HZ 0x05
-#define IST8310_ODR_50_HZ 0x07
-#define IST8310_ODR_100_HZ 0x06
 
 // Device ID (ist8310 -> 0x10)
 #define IST8310_CHIP_ID 0x10
 #define IST8310_AVG_16  0x24
 #define IST8310_PULSE_DURATION_NORMAL 0xC0
+#define IST8310_RANGE_XY 16000  // mG, 1600 uT
+#define IST8310_RANGE_Z  25000  // mG, 2500 uT
 
 #define IST8310_CNTRL2_RESET 0x01
 #define IST8310_CNTRL2_DRPOL 0x04
 #define IST8310_CNTRL2_DRENA 0x08
 
 static bool ist8310Init(magDev_t * mag)
 {
-    busWrite(mag->busDev, IST8310_REG_CNTRL1, IST8310_ODR_50_HZ);
-    delay(5);
+    // A reboot without a power cycle leaves the chip as it was, and it may never measure again
+    busWrite(mag->busDev, IST8310_REG_CNTRL2, IST8310_CNTRL2_RESET);
+    delay(50);  // power-on reset routine: 50 ms max
 
     busWrite(mag->busDev, IST8310_REG_AVERAGE, IST8310_AVG_16);
     delay(5);
 
     busWrite(mag->busDev, IST8310_REG_PDCNTL, IST8310_PULSE_DURATION_NORMAL);
     delay(5);
 
+    // Single measurement is the only mode the datasheet defines besides stand-by
+    busWrite(mag->busDev, IST8310_REG_CNTRL1, IST8310_ODR_SINGLE);
+
     return true;
 }
 
 static bool ist8310Read(magDev_t * mag)
 {
-    uint8_t status = 0;
-
-    if (!busRead(mag->busDev, IST8310_REG_STAT1, &status)) {
+    // STAT1 and the data in one read: in single measurement mode the data only changes after a trigger
+    uint8_t buf[7];
+    if (!busReadBuf(mag->busDev, IST8310_REG_STAT1, buf, 7)) {
         return false;
     }
 
-    // The IST8310 updates its data registers once per output-data period. Only read
-    // them once DRDY is set; a read racing an update would mix old and new samples
-    // across axes, corrupting the mag vector and calibration. When no fresh sample
-    // is ready, return success so the caller keeps the previous values.
-    if (!(status & IST8310_DRDY_MASK)) {
-        return true;
-    }
-
-    uint8_t buf[6];
     uint8_t LSB2FSV = 3; // 3mG - 14 bit
-
-    bool ack = busReadBuf(mag->busDev, IST8310_REG_DATA, buf, 6);
-    if (!ack) {
-        return false;
+    const int x = (int16_t)(buf[2] << 8 | buf[1]) * LSB2FSV;
+    const int y = (int16_t)(buf[4] << 8 | buf[3]) * LSB2FSV;
+    const int z = (int16_t)(buf[6] << 8 | buf[5]) * LSB2FSV;
+
+    // Past the measuring range a sample can only be corrupt, and one spoils a compass calibration
+    const bool inRange = ABS(x) <= IST8310_RANGE_XY && ABS(y) <= IST8310_RANGE_XY && ABS(z) <= IST8310_RANGE_Z;
+
+    if ((buf[0] & IST8310_DRDY_MASK) && inRange) {
+        // Invert Y axis to convert from left to right coordinate system
+        mag->magADCRaw[X] =  x;
+        mag->magADCRaw[Y] = -y;
+        mag->magADCRaw[Z] =  z;
     }
 
-    // Invert Y axis to co convert from left to right coordinate system
-    mag->magADCRaw[X] =  (int16_t)(buf[1] << 8 | buf[0]) * LSB2FSV;
-    mag->magADCRaw[Y] = -(int16_t)(buf[3] << 8 | buf[2]) * LSB2FSV;
-    mag->magADCRaw[Z] =  (int16_t)(buf[5] << 8 | buf[4]) * LSB2FSV;
+    // Also restarts a measurement that never completed: the task is far slower than its 6 ms
+    busWrite(mag->busDev, IST8310_REG_CNTRL1, IST8310_ODR_SINGLE);
 
     return true;
 }

src/main/drivers/pitotmeter/pitotmeter_dlvr_l10d.c

@@ -116,7 +116,7 @@ static void dlvr_calculate(pitotDev_t * pitot, float *pressure, float *temperatu
 
     // result must fit inside the max pressure range
     if ((dP_inchH2O > RANGE_INCH_H2O) || (dP_inchH2O < -RANGE_INCH_H2O)) {
-        LOG_DEBUG( PITOT,"DLVR: Out of range. pressure = %f", (double)(dP_inchH2O) );
+        LOG_DEBUG( PITOT,"DLVR: Out of range. pressure = %d/1000 inH2O", (int)(dP_inchH2O * 1000.0f) );
         return;
     }
 

src/main/drivers/pwm_mapping.c

@@ -97,6 +97,15 @@ static bool checkPwmTimerConflicts(const timerHardware_t *timHw)
 {
     serialPortPins_t uartPins;
 
+#if defined(USE_UART1)
+    // MSP is UART1's default next to the VCP and has always given these pins up to the outputs
+    const serialPortConfig_t *uart1Config = serialFindPortConfiguration(SERIAL_PORT_USART1);
+    uartGetPortPins(UARTDEV_1, &uartPins);
+    if (uart1Config && (uart1Config->functionMask & ~FUNCTION_MSP) && (timHw->tag == uartPins.txPin || timHw->tag == uartPins.rxPin)) {
+        return true;
+    }
+#endif
+
 #if defined(USE_UART2)
     uartGetPortPins(UARTDEV_2, &uartPins);
     if (doesConfigurationUsePort(SERIAL_PORT_USART2) && (timHw->tag == uartPins.txPin || timHw->tag == uartPins.rxPin)) {

src/main/drivers/serial.c

@@ -20,6 +20,10 @@
 
 #include "platform.h"
 
+#include "build/atomic.h"
+
+#include "drivers/nvic.h"
+
 #include "serial.h"
 
 void serialPrint(serialPort_t *instance, const char *str)
@@ -133,3 +137,19 @@ bool serialIsIdle(serialPort_t *instance)
     else
         return false;
 }
+
+// Swaps in a larger receive buffer; what the old one held is dropped
+void serialSetRxBuffer(serialPort_t *instance, volatile uint8_t *buffer, uint32_t size)
+{
+    if (size <= instance->rxBufferSize) {
+        return;
+    }
+
+    // The receive interrupt must never see the new buffer with the old size or indices
+    ATOMIC_BLOCK(NVIC_PRIO_MAX) {
+        instance->rxBuffer = buffer;
+        instance->rxBufferSize = size;
+        instance->rxBufferHead = 0;
+        instance->rxBufferTail = 0;
+    }
+}

src/main/drivers/serial.h

@@ -122,6 +122,7 @@ void serialPrint(serialPort_t *instance, const char *str);
 uint32_t serialGetBaudRate(serialPort_t *instance);
 bool serialIsConnected(const serialPort_t *instance);
 bool serialIsIdle(serialPort_t *instance);
+void serialSetRxBuffer(serialPort_t *instance, volatile uint8_t *buffer, uint32_t size);
 
 // A shim that adapts the bufWriter API to the serialWriteBuf() API.
 void serialWriteBufShim(void *instance, const uint8_t *data, int count);

src/main/drivers/serial_uart.h

@@ -20,11 +20,10 @@
 #define UART_AF(uart, af) CONCAT3(GPIO_AF, af, _ ## uart)
 
 // Since serial ports can be used for any function these buffer sizes should be equal
-// The two largest things that need to be sent are: 1, MSP responses, 2, UBLOX SVINFO packet.
+// The largest thing that needs to be sent is an MSP response.
 
-// Size must be a power of two due to various optimizations which use 'and' instead of 'mod'
-// Various serial routines return the buffer occupied size as uint8_t which would need to be extended in order to
-// increase size further.
+// Size must be a power of two due to various optimizations which use 'and' instead of 'mod'.
+// The GPS port gets a larger receive buffer of its own, see gps.c.
 #define UART1_RX_BUFFER_SIZE    256
 #define UART1_TX_BUFFER_SIZE    256
 #define UART2_RX_BUFFER_SIZE    256

src/main/drivers/serial_uart_stm32f4xx.c

@@ -217,7 +217,7 @@ void uartIrqHandler(uartPort_t *s)
 {
     if (USART_GetITStatus(s->USARTx, USART_IT_RXNE) == SET) {
         if (s->port.rxCallback) {
-            s->port.rxCallback(s->USARTx->DR, s->port.rxCallbackData);
+            s->port.rxCallback(s->USARTx->DR & 0xFF, s->port.rxCallbackData); // mask out parity bit
         } else {
             s->port.rxBuffer[s->port.rxBufferHead] = s->USARTx->DR;
             s->port.rxBufferHead = (s->port.rxBufferHead + 1) % s->port.rxBufferSize;

src/main/fc/cli.c

@@ -944,6 +944,12 @@ static void cliSerial(char *cmdline)
         return;
     }
 
+    const uint32_t duplicatedFunctions = serialGetDuplicatedSinglePortFunctions(&portConfig);
+    if (duplicatedFunctions) {
+        cliPrintErrorLinef("Function %d is already assigned to another port", (int)duplicatedFunctions);
+        return;
+    }
+
     memcpy(currentConfig, &portConfig, sizeof(portConfig));
 }
 
@@ -1009,9 +1015,9 @@ static void cliSerialPassthrough(char *cmdline)
                 baud = fastA2I(tok);
                 break;
             case 2:
-                if (strstr(tok, "rx") || strstr(tok, "RX"))
+                if (sl_strstr(tok, "rx") || sl_strstr(tok, "RX"))
                     mode |= MODE_RX;
-                if (strstr(tok, "tx") || strstr(tok, "TX"))
+                if (sl_strstr(tok, "tx") || sl_strstr(tok, "TX"))
                     mode |= MODE_TX;
                 break;
             case 3:
@@ -4024,7 +4030,7 @@ static void cliSet(char *cmdline)
             cliPrintVar(val, len); // when len is 1 (when * is passed as argument), it will print min/max values as well, for gui
             cliPrintLinefeed();
         }
-    } else if ((eqptr = strstr(cmdline, "=")) != NULL) {
+    } else if ((eqptr = strchr(cmdline, '=')) != NULL) {
         // has equals
 
         char *lastNonSpaceCharacter = eqptr;
@@ -4377,9 +4383,9 @@ static void cliStatus(char *cmdline)
         }
         cliPrintLinefeed();
         cliPrintLinef("  SATS: %i", gpsSol.numSat);
-        cliPrintLinef("  HDOP: %f", (double)(gpsSol.hdop / (float)HDOP_SCALE));
-        cliPrintLinef("  EPH : %f m", (double)(gpsSol.eph / 100.0f));
-        cliPrintLinef("  EPV : %f m", (double)(gpsSol.epv / 100.0f));
+        cliPrintLinef("  HDOP: %d.%02d", gpsSol.hdop / HDOP_SCALE, gpsSol.hdop % HDOP_SCALE);
+        cliPrintLinef("  EPH : %d.%02d m", gpsSol.eph / 100, gpsSol.eph % 100);
+        cliPrintLinef("  EPV : %d.%02d m", gpsSol.epv / 100, gpsSol.epv % 100);
         //cliPrintLinef("  GNSS Capabilities: %d", gpsUbloxCapLastUpdate());
         cliPrintLinef("  GNSS Capabilities:");
         cliPrintLine("    GNSS Provider active/default");

src/main/fc/fc_core.c

@@ -680,7 +680,7 @@ bool fcSetArmState(bool arm)
         disarm(DISARM_SWITCH);
     }
 
-    return ARMING_FLAG(ARMED) == arm;
+    return (ARMING_FLAG(ARMED) != 0) == arm;
 }
 
 #define TELEMETRY_FUNCTION_MASK (FUNCTION_TELEMETRY_HOTT | FUNCTION_TELEMETRY_SMARTPORT | FUNCTION_TELEMETRY_LTM | FUNCTION_TELEMETRY_MAVLINK | FUNCTION_TELEMETRY_IBUS)

src/main/fc/settings.c

@@ -102,7 +102,7 @@ void settingGetName(const setting_t *val, char *buf)
 bool settingNameContains(const setting_t *val, char *buf, const char *cmdline)
 {
 	settingGetName(val, buf);
-	return strstr(buf, cmdline) != NULL;
+	return sl_strstr(buf, cmdline) != NULL;
 }
 
 bool settingNameIsExactMatch(const setting_t *val, char *buf, const char *cmdline, uint8_t var_name_length)

src/main/flight/pid.c

@@ -160,6 +160,11 @@ static EXTENDED_FASTRAM int16_t headingHoldTarget;
 static EXTENDED_FASTRAM pt1Filter_t headingHoldRateFilter;
 static EXTENDED_FASTRAM pt1Filter_t fixedWingTpaFilter;
 
+// Time constant of an I-term that opposes a big stick input while the lock holds it (see iTermLockApply)
+#define FW_ITERM_LOCK_FADE_S        0.5f
+// Rate target, as a fraction of the maximum rate, from which the lock counts a stick input as big
+#define FW_ITERM_LOCK_BIG_STICK     0.2f
+
 // Thrust PID Attenuation factor. 0.0f means fully attenuated, 1.0f no attenuation is applied
 STATIC_FASTRAM bool pidGainsUpdateRequired= true;
 FASTRAM int16_t axisPID[FLIGHT_DYNAMICS_INDEX_COUNT];
@@ -1063,7 +1068,7 @@ static void applyAutoTransitionTargetItermLock(autoTransitionTargetPidState_t *p
     const float dampingFactor = attenuation(rateTarget, maxRate * targetPidProfile->fwItermLockRateLimit / 100.0f);
     const bool errorThresholdReached = fabsf(rateError) > maxRate * targetPidProfile->fwItermLockEngageThreshold / 100.0f;
 
-    if (fabsf(rateTarget) > maxRate * 0.2f) {
+    if (fabsf(rateTarget) > maxRate * FW_ITERM_LOCK_BIG_STICK) {
         pidState->attenuation.targetOverThresholdTimeMs = pidLoopNowMs;
     }
 
@@ -1116,6 +1121,11 @@ static int16_t applyAutoTransitionTargetFixedWingRateController(autoTransitionTa
         pidState->errorGyroIf += rateError * pidState->kI * dT * pidState->attenuation.aI;
     }
 
+    if (axis != FD_YAW && pidState->errorGyroIf * rateTarget < 0.0f
+        && fabsf(rateTarget) > controlProfile->stabilized.rates[axis] * 10.0f * FW_ITERM_LOCK_BIG_STICK) {
+        pidState->errorGyroIf *= 1.0f - MIN((1.0f - pidState->attenuation.aI) * dT / FW_ITERM_LOCK_FADE_S, 1.0f);
+    }
+
     applyAutoTransitionTargetItermLimiting(pidState, itermLimitActive);
 
     const uint16_t limit = 500;
@@ -1669,7 +1679,7 @@ static void iTermLockApply(pidState_t *pidState, const float rateTarget, const f
     const bool errorThresholdReached = fabsf(rateError) > maxRate * pidProfile()->fwItermLockEngageThreshold / 100.0f;
 
     //When abs of rate target is above 20% of max rate, we start tracking time
-    if (fabsf(rateTarget) > maxRate * 0.2f) {
+    if (fabsf(rateTarget) > maxRate * FW_ITERM_LOCK_BIG_STICK) {
         pidState->attenuation.targetOverThresholdTimeMs = pidLoopNowMs;
     }
 
@@ -1709,6 +1719,15 @@ static void NOINLINE pidApplyFixedWingRateController(pidState_t *pidState, float
         pidState->errorGyroIf += rateError * pidState->kI * dT * pidState->attenuation.aI;
     }
 
+    // The lock holds the I-term at whatever it had when the stick went out. Built in a motion the pilot did not ask
+    // for, it can stand against the stick and eat the feed-forward that is left: then it fades while the stick is out.
+    // Only for the inputs the lock counts as big, so a small correction keeps the trim, and not on yaw, whose rate
+    // target in a banked turn is the turn's and its I-term the rudder trim
+    if (pidState->axis != FD_YAW && pidState->errorGyroIf * rateTarget < 0.0f
+        && fabsf(rateTarget) > currentControlProfile->stabilized.rates[pidState->axis] * 10.0f * FW_ITERM_LOCK_BIG_STICK) {
+        pidState->errorGyroIf *= 1.0f - MIN((1.0f - pidState->attenuation.aI) * dT / FW_ITERM_LOCK_FADE_S, 1.0f);
+    }
+
     applyItermLimiting(pidState);
 
     const uint16_t limit = pidState->pidSumLimit;

src/main/flight/servos.c

@@ -232,10 +232,10 @@ void loadCustomServoMixer(void)
     // target-profile response.
     if (carryOverServoSpeedLimitsOnNextLoad) {
         for (int i = 0; i < servoRuleCount; i++) {
-            if(currentServoMixer[i].inputSource == INPUT_MIXER_SWITCH_HELPER || movefilterCount >= MAX_SERVO_RULES_SWITCH_CARRY) {
-                //will not carry over INPUT_MIXER_SWITCH_HELPER rules
+            if (movefilterCount >= MAX_SERVO_RULES_SWITCH_CARRY) {
                 break;
             }
+            // carry helper rules too, they still hold the decaying output of an earlier switch
             if(currentServoMixer[i].speed != 0 && fabsf(servoSpeedLimitFilter[i].state) > 0.01f) {
                 servoMixerSwitchHelper[movefilterCount].targetChannel = currentServoMixer[i].targetChannel;
                 servoMixerSwitchHelper[movefilterCount].speed = currentServoMixer[i].speed;

src/main/flight/wind_estimator.c

@@ -184,9 +184,9 @@ void updateWindEstimator(timeMs_t currentTimeMs)
         memcpy(lastFuselageDirection, fuselageDirection, sizeof(lastFuselageDirection));
         memcpy(lastGroundVelocity, groundVelocity, sizeof(lastGroundVelocity));
 
-        float theta = atan2f(groundVelocityDiff[Y], groundVelocityDiff[X]) - atan2f(fuselageDirectionDiff[Y], fuselageDirectionDiff[X]);    // equation 9
-        float sintheta = sinf(theta);
-        float costheta = cosf(theta);
+        float theta = atan2_approx(groundVelocityDiff[Y], groundVelocityDiff[X]) - atan2_approx(fuselageDirectionDiff[Y], fuselageDirectionDiff[X]);    // equation 9
+        float sintheta = sin_approx(theta);
+        float costheta = cos_approx(theta);
 
         float wind[XYZ_AXIS_COUNT];
         wind[X] = (groundVelocitySum[X] - V * (costheta * fuselageDirectionSum[X] - sintheta * fuselageDirectionSum[Y])) * 0.5f;    // equation 10