Merge sedsprintf_rs upstream main

Author: Rylan-Meilutis

sedsprintf_rs/Cargo.toml

@@ -60,6 +60,14 @@ debug = 0
 incremental = false
 overflow-checks = false
 
+[profile.release.package."*"]
+opt-level = 3
+codegen-units = 1
+strip = "symbols"
+debug = 0
+incremental = false
+overflow-checks = false
+
 # Release profile for embedded builds, size optimized
 [profile.release-embedded]
 inherits = "release"
@@ -70,4 +78,12 @@ panic = "abort"
 strip = "symbols"
 debug = 0
 incremental = false
+overflow-checks = false
+
+[profile.release-embedded.package."*"]
+opt-level = "z"
+debug = 0
+strip = "symbols"
+codegen-units = 1
+incremental = false
 overflow-checks = false

sedsprintf_rs/src/c_api.rs

@@ -183,12 +183,12 @@ fn view_to_packet(view: &SedsPacketView) -> Result<TelemetryPacket, ()> {
     }
 
     // Sender as Arc<str>
-    let sender_owned: Arc<str> = if view.sender.is_null() || view.sender_len == 0 {
-        Arc::<str>::from("")
+    let sender_owned: &str = if view.sender.is_null() || view.sender_len == 0 {
+        ""
     } else {
         let sb = unsafe { slice::from_raw_parts(view.sender as *const u8, view.sender_len) };
         let s = from_utf8(sb).map_err(|_| ())?;
-        Arc::<str>::from(s)
+        s
     };
 
     // Payload bytes
@@ -211,7 +211,7 @@ fn view_to_packet(view: &SedsPacketView) -> Result<TelemetryPacket, ()> {
 /// - If the buffer is too small, writes as much as fits (NUL-terminated)
 ///   and returns the required size.
 /// - On success, returns `SEDS_OK` (0).
- #[inline]
+#[inline]
 unsafe fn write_str_to_buf(s: &str, buf: *mut c_char, buf_len: usize) -> i32 {
     if buf.is_null() && buf_len != 0 {
         return status_from_err(TelemetryError::BadArg);
@@ -796,8 +796,9 @@ pub extern "C" fn seds_router_log_typed_ex(
             (SEDS_EK_SIGNED, 2) => finish_with::<i16>(r, ty, ts, queue, &padded, required_elems, 2),
             (SEDS_EK_SIGNED, 4) => finish_with::<i32>(r, ty, ts, queue, &padded, required_elems, 4),
             (SEDS_EK_SIGNED, 8) => finish_with::<i64>(r, ty, ts, queue, &padded, required_elems, 8),
-            (SEDS_EK_SIGNED, 16) => finish_with::<i128>(r, ty, ts, queue, &padded, required_elems, 16),
-
+            (SEDS_EK_SIGNED, 16) => {
+                finish_with::<i128>(r, ty, ts, queue, &padded, required_elems, 16)
+            }
 
             (SEDS_EK_FLOAT, 4) => finish_with::<f32>(r, ty, ts, queue, &padded, required_elems, 4),
             (SEDS_EK_FLOAT, 8) => finish_with::<f64>(r, ty, ts, queue, &padded, required_elems, 8),
@@ -819,7 +820,6 @@ pub extern "C" fn seds_router_log_typed_ex(
         (SEDS_EK_SIGNED, 8) => do_vec_log_typed!(r, ty, ts, queue, data, count, i64),
         (SEDS_EK_SIGNED, 16) => do_vec_log_typed!(r, ty, ts, queue, data, count, i128),
 
-
         (SEDS_EK_FLOAT, 4) => do_vec_log_typed!(r, ty, ts, queue, data, count, f32),
         (SEDS_EK_FLOAT, 8) => do_vec_log_typed!(r, ty, ts, queue, data, count, f64),
 
@@ -1350,7 +1350,9 @@ pub extern "C" fn seds_pkt_get_typed(
         (SEDS_EK_SIGNED, 2) => extract_typed_into::<i16>(view, elem_size, needed, out as *mut i16),
         (SEDS_EK_SIGNED, 4) => extract_typed_into::<i32>(view, elem_size, needed, out as *mut i32),
         (SEDS_EK_SIGNED, 8) => extract_typed_into::<i64>(view, elem_size, needed, out as *mut i64),
-        (SEDS_EK_SIGNED, 16) => extract_typed_into::<i128>(view, elem_size, needed, out as *mut i128),
+        (SEDS_EK_SIGNED, 16) => {
+            extract_typed_into::<i128>(view, elem_size, needed, out as *mut i128)
+        }
 
         (SEDS_EK_FLOAT, 4) => extract_typed_into::<f32>(view, elem_size, needed, out as *mut f32),
         (SEDS_EK_FLOAT, 8) => extract_typed_into::<f64>(view, elem_size, needed, out as *mut f64),

sedsprintf_rs/src/config.rs

@@ -62,6 +62,7 @@ pub enum DataEndpoint {
     SdCard,
     GroundStation,
     FlightController,
+    FuelBoard,
 }
 
 impl DataEndpoint {
@@ -75,6 +76,7 @@ impl DataEndpoint {
             DataEndpoint::SdCard => "SD_CARD",
             DataEndpoint::GroundStation => "GROUND_STATION",
             DataEndpoint::FlightController => "FLIGHT_CONTROLLER",
+            DataEndpoint::FuelBoard => "FUEL_BOARD",
         }
     }
 }
@@ -107,6 +109,9 @@ pub enum DataType {
     BatteryVoltage,
     BatteryCurrent,
     BarometerData,
+    Abort,
+    FuelFlow,
+    FuelTankPressure,
     /// Generic string message payload.
     MessageData,
 }
@@ -127,6 +132,9 @@ impl DataType {
             DataType::BatteryVoltage => "BATTERY_VOLTAGE",
             DataType::BatteryCurrent => "BATTERY_CURRENT",
             DataType::BarometerData => "BAROMETER_DATA",
+            DataType::Abort => "ABORT",
+            DataType::FuelFlow => "FUEL_FLOW",
+            DataType::FuelTankPressure => "FUEL_TANK_PRESSURE",
             DataType::MessageData => "MESSAGE_DATA",
         }
     }
@@ -156,6 +164,9 @@ pub const fn get_message_data_type(data_type: DataType) -> MessageDataType {
         DataType::GyroData => MessageDataType::Float32,
         DataType::AccelData => MessageDataType::Float32,
         DataType::BarometerData => MessageDataType::Float32,
+        DataType::Abort => MessageDataType::Bool,
+        DataType::FuelFlow => MessageDataType::Float32,
+        DataType::FuelTankPressure => MessageDataType::Float32,
         DataType::MessageData => MessageDataType::String,
     }
 }
@@ -175,6 +186,9 @@ pub const fn get_message_info_types(message_type: DataType) -> MessageType {
         DataType::GyroData => MessageType::Info,
         DataType::AccelData => MessageType::Info,
         DataType::BarometerData => MessageType::Info,
+        DataType::Abort => MessageType::Error,
+        DataType::FuelFlow => MessageType::Info,
+        DataType::FuelTankPressure => MessageType::Info,
         DataType::MessageData => MessageType::Info,
     }
 }
@@ -208,7 +222,11 @@ pub const fn get_message_meta(data_type: DataType) -> MessageMeta {
             MessageMeta {
                 // GPS Data
                 element_count: MessageElementCount::Static(2), // GPS Data messages carry 3 float32 elements (latitude, longitude)
-                endpoints: &[DataEndpoint::GroundStation, DataEndpoint::SdCard, DataEndpoint::FlightController],
+                endpoints: &[
+                    DataEndpoint::GroundStation,
+                    DataEndpoint::SdCard,
+                    DataEndpoint::FlightController,
+                ],
             }
         }
         DataType::KalmanFilterData => {
@@ -235,7 +253,7 @@ pub const fn get_message_meta(data_type: DataType) -> MessageMeta {
         DataType::GyroData => {
             MessageMeta {
                 // System Status
-                element_count: MessageElementCount::Static(1), // Gyro data messages carry 3 float32 elements (Gyro x, y,z)
+                element_count: MessageElementCount::Static(3), // Gyro data messages carry 3 float32 elements (Gyro x, y,z)
                 endpoints: &[DataEndpoint::SdCard, DataEndpoint::GroundStation],
             }
         }
@@ -253,6 +271,32 @@ pub const fn get_message_meta(data_type: DataType) -> MessageMeta {
                 endpoints: &[DataEndpoint::GroundStation, DataEndpoint::SdCard],
             }
         }
+        DataType::Abort => {
+            MessageMeta {
+                // Abort Command
+                element_count: MessageElementCount::Static(1), // Abort messages carry 1 boolean element
+                endpoints: &[
+                    DataEndpoint::SdCard,
+                    DataEndpoint::GroundStation,
+                    DataEndpoint::FlightController,
+                    DataEndpoint::FuelBoard,
+                ],
+            }
+        }
+        DataType::FuelFlow => {
+            MessageMeta {
+                // Fuel Flow Data
+                element_count: MessageElementCount::Static(1), // Fuel Flow messages carry 1 float32 element
+                endpoints: &[DataEndpoint::GroundStation, DataEndpoint::SdCard],
+            }
+        }
+        DataType::FuelTankPressure => {
+            MessageMeta {
+                // Fuel Tank Pressure Data
+                element_count: MessageElementCount::Static(1), // Fuel Tank Pressure messages carry 1 float32 element
+                endpoints: &[DataEndpoint::GroundStation, DataEndpoint::SdCard],
+            }
+        }
         DataType::MessageData => {
             MessageMeta {
                 // Message Data

sedsprintf_rs/src/lib.rs

@@ -29,17 +29,20 @@ extern crate alloc;
 extern crate core;
 #[cfg(feature = "std")]
 extern crate std;
-
-
-use core::mem::size_of;
-use core::ops::Mul;
-use strum::EnumCount;
+#[cfg(feature = "std")]
+use std::io::Error;
 
 use crate::config::{
     get_message_data_type, get_message_info_types, get_message_meta, DataEndpoint, DataType,
     MAX_STATIC_HEX_LENGTH, MAX_STATIC_STRING_LENGTH,
 };
 use crate::macros::{ReprI32Enum, ReprU32Enum};
+use alloc::string::ToString;
+use alloc::sync::Arc;
+use core::fmt::Formatter;
+use core::mem::size_of;
+use core::ops::Mul;
+use strum::EnumCount;
 
 // ============================================================================
 //  Test / Python FFI modules (std-only)
@@ -69,7 +72,6 @@ unsafe extern "C" {
 mod embedded_alloc {
     use core::alloc::{GlobalAlloc, Layout};
 
-
     unsafe extern "C" {
         fn telemetryMalloc(size: usize) -> *mut core::ffi::c_void;
         fn telemetryFree(ptr: *mut core::ffi::c_void);
@@ -94,11 +96,9 @@ mod embedded_alloc {
     #[global_allocator]
     static A: TelemetryAlloc = TelemetryAlloc;
 
-
     // Panic handler for embedded
     use core::panic::PanicInfo;
 
-
     #[panic_handler]
     fn panic(_info: &PanicInfo) -> ! {
         // Halt forever after panic
@@ -315,8 +315,11 @@ pub enum MessageType {
 ///
 /// Most public APIs expose a `TelemetryResult<T>` alias for
 /// `Result<T, TelemetryError>`.
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 pub enum TelemetryError {
+    /// Generic / unspecified error.
+    GenericError(Option<Arc<str>>),
+
     /// Logical type ID is not a valid [`DataType`].
     InvalidType,
 
@@ -359,6 +362,7 @@ impl TelemetryError {
     /// used by the FFI layers.
     pub const fn to_error_code(&self) -> TelemetryErrorCode {
         match self {
+            TelemetryError::GenericError(_) => TelemetryErrorCode::GenericError,
             TelemetryError::InvalidType => TelemetryErrorCode::InvalidType,
             TelemetryError::SizeMismatch { .. } => TelemetryErrorCode::SizeMismatch,
             TelemetryError::SizeMismatchError => TelemetryErrorCode::SizeMismatchError,
@@ -375,25 +379,60 @@ impl TelemetryError {
     }
 }
 
+/// Allow conversion of `TelemetryError` to human-readable string.
+impl core::fmt::Display for TelemetryError {
+    fn fmt(&self, f: &mut Formatter<'_>) -> core::fmt::Result {
+        f.write_str(&TelemetryError::to_string(self))
+    }
+}
+
+/// Implement `std::error::Error` for `TelemetryError` when `std` is enabled.
+#[cfg(feature = "std")]
+impl std::error::Error for TelemetryError {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+        None
+    }
+}
+
+/// Allow the conversion from std error to telemetry error
+#[cfg(feature = "std")]
+impl From<Error> for TelemetryError {
+    fn from(error: Error) -> Self {
+        let str = error.to_string();
+        let astr: Arc<str> = Arc::from(str.as_str());
+        TelemetryError::GenericError(Some(astr))
+    }
+}
+
+#[cfg(feature = "std")]
+impl From<Box<dyn std::error::Error>> for TelemetryError {
+    fn from(err: Box<dyn std::error::Error>) -> Self {
+        let str = err.to_string();
+        let astr: Arc<str> = Arc::from(str.as_str());
+        TelemetryError::GenericError(Some(astr))
+    }
+}
+
 /// Numeric error codes used on the C/Python FFI boundary.
 ///
 /// Negative values are used to avoid collisions with success codes
 /// and other positive return values (e.g. lengths).
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 #[repr(i32)]
 pub enum TelemetryErrorCode {
-    InvalidType = -2,
-    SizeMismatch = -3,
-    SizeMismatchError = -4,
-    EmptyEndpoints = -5,
-    TimestampInvalid = -6,
-    MissingPayload = -7,
-    HandlerError = -8,
-    BadArg = -9,
-    Serialize = -10,
-    Deserialize = -11,
-    Io = -12,
-    InvalidUtf8 = -13,
+    GenericError = -2,
+    InvalidType = -3,
+    SizeMismatch = -4,
+    SizeMismatchError = -5,
+    EmptyEndpoints = -6,
+    TimestampInvalid = -7,
+    MissingPayload = -8,
+    HandlerError = -9,
+    BadArg = -10,
+    Serialize = -11,
+    Deserialize = -12,
+    Io = -13,
+    InvalidUtf8 = -14,
 }
 
 // Generate ReprI32Enum helpers for TelemetryErrorCode
@@ -416,6 +455,7 @@ impl TelemetryErrorCode {
     #[inline]
     pub fn as_str(&self) -> &'static str {
         match self {
+            TelemetryErrorCode::GenericError => "GenericError",
             TelemetryErrorCode::InvalidType => "{Invalid Type}",
             TelemetryErrorCode::SizeMismatch => "{Size Mismatch}",
             TelemetryErrorCode::SizeMismatchError => "{Size Mismatch Error}",

sedsprintf_rs/src/python_api.rs

@@ -920,14 +920,8 @@ pub fn make_packet(
     let payload_arc = AArc::<[u8]>::from(buf);
 
     // Go through TelemetryPacket::new for validation + consistency
-    let pkt = TelemetryPacket::new(
-        ty,
-        &eps,
-        AArc::<str>::from(sender),
-        timestamp_ms,
-        payload_arc,
-    )
-    .map_err(py_err_from)?;
+    let pkt =
+        TelemetryPacket::new(ty, &eps, sender, timestamp_ms, payload_arc).map_err(py_err_from)?;
 
     Ok(Py::new(py, PyPacket { inner: pkt })?.into_any())
 }

sedsprintf_rs/src/router.rs

@@ -11,7 +11,6 @@ use alloc::{boxed::Box, collections::VecDeque, format, sync::Arc, vec, vec::Vec}
 #[cfg(all(not(feature = "std"), target_os = "none"))]
 use crate::seds_error_msg;
 
-
 pub enum RxItem {
     Packet(TelemetryPacket),
     Serialized(Arc<[u8]>),
@@ -733,7 +732,7 @@ impl Router {
         let error_pkt = TelemetryPacket::new(
             DataType::TelemetryError,
             &locals,
-            env.sender.clone(),
+            &*env.sender.clone(),
             env.timestamp_ms,
             payload,
         )?;