From 5a2a0b87a5a496e87b432bbe04ca8ae3a1156db5 Mon Sep 17 00:00:00 2001
From: gismo2004 <reumuellermarkus@gmail.com>
Date: Sun, 14 Sep 2025 16:57:22 +0200
Subject: [PATCH 1/8] [crsf] add temperature and RPM telemetry

---
 src/main/rx/crsf.h        |  2 +
 src/main/telemetry/crsf.c | 97 +++++++++++++++++++++++++++++++++++++++
 2 files changed, 99 insertions(+)

diff --git a/src/main/rx/crsf.h b/src/main/rx/crsf.h
index 8d84d52b8e5..02ca7ddac42 100755
--- a/src/main/rx/crsf.h
+++ b/src/main/rx/crsf.h
@@ -88,6 +88,8 @@ typedef enum {
     CRSF_FRAMETYPE_VARIO_SENSOR = 0x07,
     CRSF_FRAMETYPE_BATTERY_SENSOR = 0x08,
     CRSF_FRAMETYPE_BAROMETER_ALTITUDE = 0x09,
+    CRSF_FRAMETYPE_RPM = 0x0C,
+    CRSF_FRAMETYPE_TEMP = 0x0D,
     CRSF_FRAMETYPE_LINK_STATISTICS = 0x14,
     CRSF_FRAMETYPE_RC_CHANNELS_PACKED = 0x16,
     CRSF_FRAMETYPE_ATTITUDE = 0x1E,
diff --git a/src/main/telemetry/crsf.c b/src/main/telemetry/crsf.c
index d86822ada7a..c6ef8a53a35 100755
--- a/src/main/telemetry/crsf.c
+++ b/src/main/telemetry/crsf.c
@@ -46,6 +46,7 @@
 #include "fc/runtime_config.h"
 
 #include "flight/imu.h"
+#include "flight/mixer.h"
 
 #include "io/gps.h"
 #include "io/serial.h"
@@ -55,8 +56,11 @@
 #include "rx/crsf.h"
 #include "rx/rx.h"
 
+
 #include "sensors/battery.h"
+#include "sensors/esc_sensor.h"
 #include "sensors/sensors.h"
+#include "sensors/temperature.h"
 
 #include "telemetry/crsf.h"
 #include "telemetry/telemetry.h"
@@ -162,6 +166,14 @@ static void crsfSerialize16(sbuf_t *dst, uint16_t v)
     crsfSerialize8(dst, (uint8_t)v);
 }
 
+static void crsfSerialize24(sbuf_t *dst, uint32_t v)
+{
+    // Use BigEndian format
+    crsfSerialize8(dst, (v >> 16));
+    crsfSerialize8(dst, (v >> 8));
+    crsfSerialize8(dst, (uint8_t)v);
+}
+
 static void crsfSerialize32(sbuf_t *dst, uint32_t v)
 {
     // Use BigEndian format
@@ -296,6 +308,69 @@ static void crsfBarometerAltitude(sbuf_t *dst)
     crsfSerialize16(dst, altitude_packed);
 }
 
+/*
+0x0C RPM
+Payload:
+uint8_t    rpm_source_id;  // Identifies the source of the RPM data (e.g., 0 = Motor 1, 1 = Motor 2, etc.)
+int24_t    rpm_value[];     // 1 - 19 RPM values with negative ones representing the motor spinning in reverse
+*/
+static void crsfRpm(sbuf_t *dst)
+{
+    uint8_t motorCount = getMotorCount();
+
+    if (STATE(ESC_SENSOR_ENABLED) && motorCount > 0) {
+        sbufWriteU8(dst, 1 + (motorCount * 3) + CRSF_FRAME_LENGTH_TYPE_CRC);
+        crsfSerialize8(dst, CRSF_FRAMETYPE_RPM);
+        // 0 = FC including all ESCs
+        crsfSerialize8(dst, 0);
+
+        for (uint8_t i = 0; i < motorCount; i++) {
+            const escSensorData_t *escState = getEscTelemetry(i);
+            crsfSerialize24(dst, (escState) ? escState->rpm : 0);
+        }
+    }
+}
+
+/*
+0x0D TEMP
+Payload:
+uint8_t temp_source_id; // Identifies the source of the temperature data (e.g., 0 = FC including all ESCs, 1 = Ambient, etc.)
+int16_t temperature[]; // up to 20 temperature values in deci-degree (tenths of a degree) Celsius (e.g., 250 = 25.0°C, -50 = -5.0°C)
+*/
+static void crsfTemperature(sbuf_t *dst)
+{
+
+    uint8_t tempCount = 0;
+    int16_t temperatures[20];
+
+#ifdef USE_ESC_SENSOR
+    uint8_t motorCount = getMotorCount();
+    if (STATE(ESC_SENSOR_ENABLED) && motorCount > 0) {
+        for (uint8_t i = 0; i < motorCount; i++) {
+            const escSensorData_t *escState = getEscTelemetry(i);
+            temperatures[tempCount++] = (escState) ? escState->temperature * 10 : TEMPERATURE_INVALID_VALUE;
+        }
+    }
+#endif
+
+#ifdef USE_TEMPERATURE_SENSOR
+    for (uint8_t i = 0; i < MAX_TEMP_SENSORS; i++) {
+        int16_t value;
+        if (getSensorTemperature(i, &value))
+            temperatures[tempCount++] = value;
+    }
+#endif
+
+    if (tempCount > 0) {
+        sbufWriteU8(dst, 1 + (tempCount * 2) + CRSF_FRAME_LENGTH_TYPE_CRC);
+        crsfSerialize8(dst, CRSF_FRAMETYPE_TEMP);
+        // 0 = FC including all ESCs
+        crsfSerialize8(dst, 0);
+        for (uint8_t i = 0; i < tempCount; i++)
+            crsfSerialize16(dst, temperatures[i]);
+    }
+}
+
 typedef enum {
     CRSF_ACTIVE_ANTENNA1 = 0,
     CRSF_ACTIVE_ANTENNA2 = 1
@@ -465,6 +540,8 @@ typedef enum {
     CRSF_FRAME_GPS_INDEX,
     CRSF_FRAME_VARIO_SENSOR_INDEX,
     CRSF_FRAME_BAROMETER_ALTITUDE_INDEX,
+    CRSF_FRAME_TEMP_INDEX,
+    CRSF_FRAME_RPM_INDEX,
     CRSF_SCHEDULE_COUNT_MAX
 } crsfFrameTypeIndex_e;
 
@@ -526,6 +603,20 @@ static void processCrsf(void)
         crsfFrameFlightMode(dst);
         crsfFinalize(dst);
     }
+#ifdef USE_ESC_SENSOR
+    if (currentSchedule & BV(CRSF_FRAME_RPM_INDEX)) {
+        crsfInitializeFrame(dst);
+        crsfRpm(dst);
+        crsfFinalize(dst);
+    }
+#endif
+#if defined(USE_ESC_SENSOR) || defined(USE_TEMPERATURE_SENSOR)
+    if (currentSchedule & BV(CRSF_FRAME_TEMP_INDEX)) {
+        crsfInitializeFrame(dst);
+        crsfTemperature(dst);
+        crsfFinalize(dst);
+    }
+#endif
 #ifdef USE_GPS
     if (currentSchedule & BV(CRSF_FRAME_GPS_INDEX)) {
         crsfInitializeFrame(dst);
@@ -582,6 +673,12 @@ void initCrsfTelemetry(void)
     if (sensors(SENSOR_BARO)) {
         crsfSchedule[index++] = BV(CRSF_FRAME_BAROMETER_ALTITUDE_INDEX);
     }
+#endif
+#ifdef USE_ESC_SENSOR
+    crsfSchedule[index++] = BV(CRSF_FRAME_RPM_INDEX);
+#endif
+#if defined(USE_ESC_SENSOR) || defined(USE_TEMPERATURE_SENSOR)
+    crsfSchedule[index++] = BV(CRSF_FRAME_TEMP_INDEX);
 #endif
     crsfScheduleCount = (uint8_t)index;
 }

From 710b36e46d56b827456ac80caa5a658d60e4ad55 Mon Sep 17 00:00:00 2001
From: gismo2004 <reumuellermarkus@gmail.com>
Date: Sun, 14 Sep 2025 17:29:00 +0200
Subject: [PATCH 2/8] make the compiler happy

---
 src/main/telemetry/crsf.c | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/src/main/telemetry/crsf.c b/src/main/telemetry/crsf.c
index c6ef8a53a35..afbd1438cb6 100755
--- a/src/main/telemetry/crsf.c
+++ b/src/main/telemetry/crsf.c
@@ -308,6 +308,7 @@ static void crsfBarometerAltitude(sbuf_t *dst)
     crsfSerialize16(dst, altitude_packed);
 }
 
+#ifdef USE_ESC_SENSOR
 /*
 0x0C RPM
 Payload:
@@ -330,6 +331,7 @@ static void crsfRpm(sbuf_t *dst)
         }
     }
 }
+#endif
 
 /*
 0x0D TEMP

From b39cc96f274fb3e554c2cbe197cd64a3d7f6c1cb Mon Sep 17 00:00:00 2001
From: gismo2004 <reumuellermarkus@gmail.com>
Date: Mon, 15 Sep 2025 06:44:52 +0200
Subject: [PATCH 3/8] more compiler warnings

---
 src/main/telemetry/crsf.c | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/main/telemetry/crsf.c b/src/main/telemetry/crsf.c
index afbd1438cb6..33cd8253f27 100755
--- a/src/main/telemetry/crsf.c
+++ b/src/main/telemetry/crsf.c
@@ -56,7 +56,6 @@
 #include "rx/crsf.h"
 #include "rx/rx.h"
 
-
 #include "sensors/battery.h"
 #include "sensors/esc_sensor.h"
 #include "sensors/sensors.h"
@@ -166,6 +165,7 @@ static void crsfSerialize16(sbuf_t *dst, uint16_t v)
     crsfSerialize8(dst, (uint8_t)v);
 }
 
+#ifdef USE_ESC_SENSOR
 static void crsfSerialize24(sbuf_t *dst, uint32_t v)
 {
     // Use BigEndian format
@@ -173,6 +173,7 @@ static void crsfSerialize24(sbuf_t *dst, uint32_t v)
     crsfSerialize8(dst, (v >> 8));
     crsfSerialize8(dst, (uint8_t)v);
 }
+#endif
 
 static void crsfSerialize32(sbuf_t *dst, uint32_t v)
 {

From f8dc0bce93c8f4bebf92656942d1354ddef96331 Mon Sep 17 00:00:00 2001
From: gismo2004 <reumuellermarkus@gmail.com>
Date: Tue, 23 Sep 2025 12:06:05 +0200
Subject: [PATCH 4/8] add AirSpeed

---
 src/main/rx/crsf.h        |  2 ++
 src/main/telemetry/crsf.c | 33 +++++++++++++++++++++++++++++++--
 2 files changed, 33 insertions(+), 2 deletions(-)

diff --git a/src/main/rx/crsf.h b/src/main/rx/crsf.h
index 02ca7ddac42..d5c0219f106 100755
--- a/src/main/rx/crsf.h
+++ b/src/main/rx/crsf.h
@@ -46,6 +46,7 @@ enum {
     CRSF_FRAME_VARIO_SENSOR_PAYLOAD_SIZE = 2,
     CRSF_FRAME_BATTERY_SENSOR_PAYLOAD_SIZE = 8,
     CRSF_FRAME_BAROMETER_ALTITUDE_PAYLOAD_SIZE = 2,
+    CRSF_FRAME_AIRSPEED_PAYLOAD_SIZE = 2,
     CRSF_FRAME_LINK_STATISTICS_PAYLOAD_SIZE = 10,
     CRSF_FRAME_RC_CHANNELS_PAYLOAD_SIZE = 22, // 11 bits per channel * 16 channels = 22 bytes.
     CRSF_FRAME_ATTITUDE_PAYLOAD_SIZE = 6,
@@ -88,6 +89,7 @@ typedef enum {
     CRSF_FRAMETYPE_VARIO_SENSOR = 0x07,
     CRSF_FRAMETYPE_BATTERY_SENSOR = 0x08,
     CRSF_FRAMETYPE_BAROMETER_ALTITUDE = 0x09,
+    CRSF_FRAMETYPE_AIRSPEED_SENSOR = 0x0A,
     CRSF_FRAMETYPE_RPM = 0x0C,
     CRSF_FRAMETYPE_TEMP = 0x0D,
     CRSF_FRAMETYPE_LINK_STATISTICS = 0x14,
diff --git a/src/main/telemetry/crsf.c b/src/main/telemetry/crsf.c
index 33cd8253f27..3007742df5c 100755
--- a/src/main/telemetry/crsf.c
+++ b/src/main/telemetry/crsf.c
@@ -58,6 +58,7 @@
 
 #include "sensors/battery.h"
 #include "sensors/esc_sensor.h"
+#include "sensors/pitotmeter.h"
 #include "sensors/sensors.h"
 #include "sensors/temperature.h"
 
@@ -309,6 +310,21 @@ static void crsfBarometerAltitude(sbuf_t *dst)
     crsfSerialize16(dst, altitude_packed);
 }
 
+#ifdef USE_PITOT
+/*
+0x0A Airspeed sensor
+Payload:
+int16      Air speed ( dm/s )
+*/
+static void crsfFrameAirSpeedSensor(sbuf_t *dst)
+{
+    // use sbufWrite since CRC does not include frame length
+    sbufWriteU8(dst, CRSF_FRAME_AIRSPEED_PAYLOAD_SIZE + CRSF_FRAME_LENGTH_TYPE_CRC);
+    crsfSerialize8(dst, CRSF_FRAMETYPE_AIRSPEED_SENSOR);
+    crsfSerialize16(dst, (uint16_t)(getAirspeedEstimate() * 36 / 100));
+}
+#endif
+
 #ifdef USE_ESC_SENSOR
 /*
 0x0C RPM
@@ -545,11 +561,12 @@ typedef enum {
     CRSF_FRAME_BAROMETER_ALTITUDE_INDEX,
     CRSF_FRAME_TEMP_INDEX,
     CRSF_FRAME_RPM_INDEX,
+    CRSF_FRAME_AIRSPEED_INDEX,
     CRSF_SCHEDULE_COUNT_MAX
 } crsfFrameTypeIndex_e;
 
 static uint8_t crsfScheduleCount;
-static uint8_t crsfSchedule[CRSF_SCHEDULE_COUNT_MAX];
+static uint16_t crsfSchedule[CRSF_SCHEDULE_COUNT_MAX];
 
 #if defined(USE_MSP_OVER_TELEMETRY)
 
@@ -586,7 +603,7 @@ static void processCrsf(void)
     }
 
     static uint8_t crsfScheduleIndex = 0;
-    const uint8_t currentSchedule = crsfSchedule[crsfScheduleIndex];
+    const uint16_t currentSchedule = crsfSchedule[crsfScheduleIndex];
 
     sbuf_t crsfPayloadBuf;
     sbuf_t *dst = &crsfPayloadBuf;
@@ -638,6 +655,13 @@ static void processCrsf(void)
         crsfBarometerAltitude(dst);
         crsfFinalize(dst);
     }
+#endif
+#ifdef USE_PITOT
+    if (currentSchedule & BV(CRSF_FRAME_AIRSPEED_INDEX)) {
+        crsfInitializeFrame(dst);
+        crsfFrameAirSpeedSensor(dst);
+        crsfFinalize(dst);
+    }
 #endif
     crsfScheduleIndex = (crsfScheduleIndex + 1) % crsfScheduleCount;
 }
@@ -682,6 +706,11 @@ void initCrsfTelemetry(void)
 #endif
 #if defined(USE_ESC_SENSOR) || defined(USE_TEMPERATURE_SENSOR)
     crsfSchedule[index++] = BV(CRSF_FRAME_TEMP_INDEX);
+#endif
+#ifdef USE_PITOT
+    if (sensors(SENSOR_PITOT)) {
+        crsfSchedule[index++] = BV(CRSF_FRAME_AIRSPEED_INDEX);
+    }
 #endif
     crsfScheduleCount = (uint8_t)index;
 }

From e5bfe799c3d56fc95a7573b27bfec77ca8044249 Mon Sep 17 00:00:00 2001
From: Ray Morris <deepmagicbeginshere@gmail.com>
Date: Thu, 18 Dec 2025 12:14:41 -0600
Subject: [PATCH 5/8] Fix CRSF telemetry corruption from PR #11025
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

This commit fixes the critical bugs that caused PR #11025 to be reverted
(PR #11139). The original implementation caused telemetry stream corruption
by emitting malformed frames when sensors were unavailable.

Root Cause:
The original PR scheduled telemetry frames unconditionally (if feature
compiled in) but frame functions only wrote data when sensors were available.
This resulted in frames containing only [SYNC][CRC] instead of the proper
[SYNC][LENGTH][TYPE][PAYLOAD][CRC] structure, corrupting the CRSF protocol
stream and breaking ALL telemetry (not just new frames).

Fixes Implemented:

1. RPM Frame (Bug #1 - CRITICAL):
   - Added conditional scheduling: only schedule if ESC_SENSOR_ENABLED
     and motorCount > 0
   - Added protocol limit enforcement: max 19 RPM values per CRSF spec
   - Location: src/main/telemetry/crsf.c:705-707, 337-343

2. Temperature Frame (Bug #2 - CRITICAL):
   - Added conditional scheduling: only schedule if temperature sources
     are actually available (ESC sensors OR temperature sensors)
   - Added bounds checking: prevent buffer overflow beyond 20 temperatures
   - Location: src/main/telemetry/crsf.c:709-732, 361-381

3. Buffer Overflow Protection (Bug #4):
   - Added MAX_CRSF_TEMPS constant and bounds checks in loops
   - Prevents array overflow if >20 temperature sources configured
   - Location: src/main/telemetry/crsf.c:361, 368, 376

4. Protocol Limit Enforcement (Bug #5):
   - Added MAX_CRSF_RPM_VALUES constant (19 per CRSF spec)
   - Clamp motorCount to protocol limit before sending
   - Location: src/main/telemetry/crsf.c:337, 342-344

Implementation Pattern:
Follows the GPS frame pattern:
  ✓ Conditional scheduling - only schedule if sensor available
  ✓ Unconditional writing - always write complete frame data when called

Testing:
- Code compiles successfully (verified with SITL build)
- No syntax errors or warnings
- All fixes follow existing code patterns in crsf.c

Related Issues:
- Original PR: #11025 (merged Nov 28, 2025, reverted same day)
- Revert PR: #11139
- Investigation: claude/developer/sent/pr11025-root-cause-analysis.md

Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com>
---
 src/main/telemetry/crsf.c | 39 ++++++++++++++++++++++++++++++++++-----
 1 file changed, 34 insertions(+), 5 deletions(-)

diff --git a/src/main/telemetry/crsf.c b/src/main/telemetry/crsf.c
index 3007742df5c..159a8c16ce2 100755
--- a/src/main/telemetry/crsf.c
+++ b/src/main/telemetry/crsf.c
@@ -334,9 +334,15 @@ int24_t    rpm_value[];     // 1 - 19 RPM values with negative ones representing
 */
 static void crsfRpm(sbuf_t *dst)
 {
+    const uint8_t MAX_CRSF_RPM_VALUES = 19;  // CRSF protocol limit: 1-19 RPM values
     uint8_t motorCount = getMotorCount();
 
     if (STATE(ESC_SENSOR_ENABLED) && motorCount > 0) {
+        // Enforce protocol limit
+        if (motorCount > MAX_CRSF_RPM_VALUES) {
+            motorCount = MAX_CRSF_RPM_VALUES;
+        }
+
         sbufWriteU8(dst, 1 + (motorCount * 3) + CRSF_FRAME_LENGTH_TYPE_CRC);
         crsfSerialize8(dst, CRSF_FRAMETYPE_RPM);
         // 0 = FC including all ESCs
@@ -358,14 +364,14 @@ int16_t temperature[]; // up to 20 temperature values in deci-degree (tenths of
 */
 static void crsfTemperature(sbuf_t *dst)
 {
-
+    const uint8_t MAX_CRSF_TEMPS = 20;  // Maximum temperatures per CRSF frame
     uint8_t tempCount = 0;
     int16_t temperatures[20];
 
 #ifdef USE_ESC_SENSOR
     uint8_t motorCount = getMotorCount();
     if (STATE(ESC_SENSOR_ENABLED) && motorCount > 0) {
-        for (uint8_t i = 0; i < motorCount; i++) {
+        for (uint8_t i = 0; i < motorCount && tempCount < MAX_CRSF_TEMPS; i++) {
             const escSensorData_t *escState = getEscTelemetry(i);
             temperatures[tempCount++] = (escState) ? escState->temperature * 10 : TEMPERATURE_INVALID_VALUE;
         }
@@ -373,7 +379,7 @@ static void crsfTemperature(sbuf_t *dst)
 #endif
 
 #ifdef USE_TEMPERATURE_SENSOR
-    for (uint8_t i = 0; i < MAX_TEMP_SENSORS; i++) {
+    for (uint8_t i = 0; i < MAX_TEMP_SENSORS && tempCount < MAX_CRSF_TEMPS; i++) {
         int16_t value;
         if (getSensorTemperature(i, &value))
             temperatures[tempCount++] = value;
@@ -702,10 +708,33 @@ void initCrsfTelemetry(void)
     }
 #endif
 #ifdef USE_ESC_SENSOR
-    crsfSchedule[index++] = BV(CRSF_FRAME_RPM_INDEX);
+    if (STATE(ESC_SENSOR_ENABLED) && getMotorCount() > 0) {
+        crsfSchedule[index++] = BV(CRSF_FRAME_RPM_INDEX);
+    }
 #endif
 #if defined(USE_ESC_SENSOR) || defined(USE_TEMPERATURE_SENSOR)
-    crsfSchedule[index++] = BV(CRSF_FRAME_TEMP_INDEX);
+    // Only schedule temperature frame if we have temperature sources available
+    bool hasTemperatureSources = false;
+#ifdef USE_ESC_SENSOR
+    if (STATE(ESC_SENSOR_ENABLED) && getMotorCount() > 0) {
+        hasTemperatureSources = true;
+    }
+#endif
+#ifdef USE_TEMPERATURE_SENSOR
+    if (!hasTemperatureSources) {
+        // Check if any temperature sensors are configured
+        for (uint8_t i = 0; i < MAX_TEMP_SENSORS; i++) {
+            int16_t value;
+            if (getSensorTemperature(i, &value)) {
+                hasTemperatureSources = true;
+                break;
+            }
+        }
+    }
+#endif
+    if (hasTemperatureSources) {
+        crsfSchedule[index++] = BV(CRSF_FRAME_TEMP_INDEX);
+    }
 #endif
 #ifdef USE_PITOT
     if (sensors(SENSOR_PITOT)) {

From f397f7ed043a30c7f5e45604bb9a8ffbb33513a7 Mon Sep 17 00:00:00 2001
From: Ray Morris <deepmagicbeginshere@gmail.com>
Date: Thu, 9 Apr 2026 22:40:50 -0500
Subject: [PATCH 6/8] telemetry: fix CRSF airspeed integer truncation and empty
 RPM/temp frames

- Fix airspeed always transmitting zero: integer `36 / 100` evaluates
  to 0 in C; use `36.0f / 100.0f` for correct cm/s to 0.1 km/h conversion
- crsfRpm/crsfTemperature now return bool; crsfFinalize is only called
  when data was actually written, preventing malformed single-byte frames
  when ESC sensor or temperature sources are absent
---
 src/main/telemetry/crsf.c | 20 +++++++++++++-------
 1 file changed, 13 insertions(+), 7 deletions(-)

diff --git a/src/main/telemetry/crsf.c b/src/main/telemetry/crsf.c
index 159a8c16ce2..e8214fc8c1f 100755
--- a/src/main/telemetry/crsf.c
+++ b/src/main/telemetry/crsf.c
@@ -321,7 +321,7 @@ static void crsfFrameAirSpeedSensor(sbuf_t *dst)
     // use sbufWrite since CRC does not include frame length
     sbufWriteU8(dst, CRSF_FRAME_AIRSPEED_PAYLOAD_SIZE + CRSF_FRAME_LENGTH_TYPE_CRC);
     crsfSerialize8(dst, CRSF_FRAMETYPE_AIRSPEED_SENSOR);
-    crsfSerialize16(dst, (uint16_t)(getAirspeedEstimate() * 36 / 100));
+    crsfSerialize16(dst, (uint16_t)(getAirspeedEstimate() * 36.0f / 100.0f));
 }
 #endif
 
@@ -332,7 +332,7 @@ static void crsfFrameAirSpeedSensor(sbuf_t *dst)
 uint8_t    rpm_source_id;  // Identifies the source of the RPM data (e.g., 0 = Motor 1, 1 = Motor 2, etc.)
 int24_t    rpm_value[];     // 1 - 19 RPM values with negative ones representing the motor spinning in reverse
 */
-static void crsfRpm(sbuf_t *dst)
+static bool crsfRpm(sbuf_t *dst)
 {
     const uint8_t MAX_CRSF_RPM_VALUES = 19;  // CRSF protocol limit: 1-19 RPM values
     uint8_t motorCount = getMotorCount();
@@ -352,7 +352,9 @@ static void crsfRpm(sbuf_t *dst)
             const escSensorData_t *escState = getEscTelemetry(i);
             crsfSerialize24(dst, (escState) ? escState->rpm : 0);
         }
+        return true;
     }
+    return false;
 }
 #endif
 
@@ -362,7 +364,7 @@ static void crsfRpm(sbuf_t *dst)
 uint8_t temp_source_id; // Identifies the source of the temperature data (e.g., 0 = FC including all ESCs, 1 = Ambient, etc.)
 int16_t temperature[]; // up to 20 temperature values in deci-degree (tenths of a degree) Celsius (e.g., 250 = 25.0°C, -50 = -5.0°C)
 */
-static void crsfTemperature(sbuf_t *dst)
+static bool crsfTemperature(sbuf_t *dst)
 {
     const uint8_t MAX_CRSF_TEMPS = 20;  // Maximum temperatures per CRSF frame
     uint8_t tempCount = 0;
@@ -393,7 +395,9 @@ static void crsfTemperature(sbuf_t *dst)
         crsfSerialize8(dst, 0);
         for (uint8_t i = 0; i < tempCount; i++)
             crsfSerialize16(dst, temperatures[i]);
+        return true;
     }
+    return false;
 }
 
 typedef enum {
@@ -632,15 +636,17 @@ static void processCrsf(void)
 #ifdef USE_ESC_SENSOR
     if (currentSchedule & BV(CRSF_FRAME_RPM_INDEX)) {
         crsfInitializeFrame(dst);
-        crsfRpm(dst);
-        crsfFinalize(dst);
+        if (crsfRpm(dst)) {
+            crsfFinalize(dst);
+        }
     }
 #endif
 #if defined(USE_ESC_SENSOR) || defined(USE_TEMPERATURE_SENSOR)
     if (currentSchedule & BV(CRSF_FRAME_TEMP_INDEX)) {
         crsfInitializeFrame(dst);
-        crsfTemperature(dst);
-        crsfFinalize(dst);
+        if (crsfTemperature(dst)) {
+            crsfFinalize(dst);
+        }
     }
 #endif
 #ifdef USE_GPS

From 0f18cbc6946a55a7391bfd2129da5331bd9d62ac Mon Sep 17 00:00:00 2001
From: Ray Morris <deepmagicbeginshere@gmail.com>
Date: Thu, 5 Mar 2026 23:11:59 -0600
Subject: [PATCH 7/8] Use single-precision math where double is unnecessary

Replace three uses of double-precision library functions with their
float equivalents, eliminating software-emulated double math on the
Cortex-M7 FPV5-SP-D16 (single-precision-only) FPU:

- gps_ublox.c: atof() -> fastA2F() in gpsDecodeProtocolVersion().
  atof() pulled in libc_nano strtod (28 KB of double-precision parsing
  machinery) to parse simple version strings like "18.00". fastA2F()
  is already in the codebase and covers this use case.

- maths.c: exp/pow (double) -> expf/powf in gaussian().
  The explicit (double) casts defeated the -fsingle-precision-constant
  flag. gaussian() is called from the IMU loop at up to 1000 Hz, so
  switching to hardware-accelerated single-precision also improves
  runtime performance.

- vtx_smartaudio.c: pow(10.0, ...) -> powf(10.0f, ...) in saDbiToMw().
  Combined with the maths.c change, removes all callers of double pow,
  dropping libm e_pow.o from the link entirely.

Flash savings on MATEKF722 (STM32F722, 512 KB):
  text: -16,560 B  data: -376 B  total: -16,936 B (~16.5 KB)
---
 src/main/common/maths.c      | 2 +-
 src/main/io/gps_ublox.c      | 2 +-
 src/main/io/vtx_smartaudio.c | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/main/common/maths.c b/src/main/common/maths.c
index 993634d902d..2881d2b8938 100644
--- a/src/main/common/maths.c
+++ b/src/main/common/maths.c
@@ -526,7 +526,7 @@ bool sensorCalibrationSolveForScale(sensorCalibrationState_t * state, float resu
 }
 
 float gaussian(const float x, const float mu, const float sigma) {
-    return exp(-pow((double)(x - mu), 2) / (2 * pow((double)sigma, 2)));
+    return expf(-powf(x - mu, 2.0f) / (2.0f * powf(sigma, 2.0f)));
 }
 
 float bellCurve(const float x, const float curveWidth)
diff --git a/src/main/io/gps_ublox.c b/src/main/io/gps_ublox.c
index f0899aa69d5..d198ed67dc6 100755
--- a/src/main/io/gps_ublox.c
+++ b/src/main/io/gps_ublox.c
@@ -549,7 +549,7 @@ static void gpsDecodeProtocolVersion(const char *proto, size_t bufferLength)
     if (bufferLength > 13 && (!strncmp(proto, "PROTVER=", 8) || !strncmp(proto, "PROTVER ", 8))) {
         proto+=8;
 
-        float ver = atof(proto);
+        float ver = fastA2F(proto);
 
         gpsState.swVersionMajor = (uint8_t)ver;
         gpsState.swVersionMinor = (uint8_t)((ver - gpsState.swVersionMajor) * 100.0f);
diff --git a/src/main/io/vtx_smartaudio.c b/src/main/io/vtx_smartaudio.c
index 7d5e213cce0..7e24d552929 100644
--- a/src/main/io/vtx_smartaudio.c
+++ b/src/main/io/vtx_smartaudio.c
@@ -212,7 +212,7 @@ int saDacToPowerIndex(int dac)
 
 int saDbiToMw(uint16_t dbi) {
 
-    uint16_t mw = (uint16_t)pow(10.0, dbi / 10.0);
+    uint16_t mw = (uint16_t)powf(10.0f, (float)dbi / 10.0f);
 
     if (dbi > 14) {
         // For powers greater than 25mW round up to a multiple of 50 to match expectations

From 03751bc76a9a6e60d6b28cebb3004af5d5149f98 Mon Sep 17 00:00:00 2001
From: Ray Morris <deepmagicbeginshere@gmail.com>
Date: Thu, 5 Mar 2026 23:25:04 -0600
Subject: [PATCH 8/8] Code review fixes for float math flash savings

Follow-up to the single-precision math change that saves ~17 KB of
flash on STM32F722 targets:

- maths.c: Replace powf(x, 2.0f) with explicit multiplies in
  gaussian(). Clearer intent and avoids any dependency on libm
  reducing integer-exponent powf to a multiply.

- vtx_smartaudio.c: Add roundf() before uint16_t cast in saDbiToMw().
  powf(10.0f, 1.0f) may return 9.999...f on some libm implementations,
  which would truncate to 9 mW instead of the correct 10 mW. roundf()
  closes the hazard at the cost of one FPU instruction.
---
 src/main/common/maths.c      | 2 +-
 src/main/io/vtx_smartaudio.c | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/main/common/maths.c b/src/main/common/maths.c
index 2881d2b8938..d591e40de81 100644
--- a/src/main/common/maths.c
+++ b/src/main/common/maths.c
@@ -526,7 +526,7 @@ bool sensorCalibrationSolveForScale(sensorCalibrationState_t * state, float resu
 }
 
 float gaussian(const float x, const float mu, const float sigma) {
-    return expf(-powf(x - mu, 2.0f) / (2.0f * powf(sigma, 2.0f)));
+    return expf(-((x - mu) * (x - mu)) / (2.0f * sigma * sigma));
 }
 
 float bellCurve(const float x, const float curveWidth)
diff --git a/src/main/io/vtx_smartaudio.c b/src/main/io/vtx_smartaudio.c
index 7e24d552929..acb2a34e6dc 100644
--- a/src/main/io/vtx_smartaudio.c
+++ b/src/main/io/vtx_smartaudio.c
@@ -212,7 +212,7 @@ int saDacToPowerIndex(int dac)
 
 int saDbiToMw(uint16_t dbi) {
 
-    uint16_t mw = (uint16_t)powf(10.0f, (float)dbi / 10.0f);
+    uint16_t mw = (uint16_t)roundf(powf(10.0f, (float)dbi / 10.0f));
 
     if (dbi > 14) {
         // For powers greater than 25mW round up to a multiple of 50 to match expectations