Merge sedsprintf_rs upstream main

Author: Rylan-Meilutis

sedsprintf_rs/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
-version = "1.1.0"
 name = "sedsprintf_rs_2026"
+version = "1.1.1"
 edition = "2024"
 build = "build.rs"
 authors = ["Rylan Meilutis <[email protected]>"]

sedsprintf_rs/c-system-test/src/main.c

@@ -93,6 +93,9 @@ static void * sender_B(void * arg)
         make_series(buf, 3, 101.3f);
         assert(node_log(B, SEDS_DT_BAROMETER_DATA, buf, 3, sizeof(buf[0])) == SEDS_OK);
         usleep(gen_random_us());
+        uint8_t buff[0];
+        assert(node_log(B, SEDS_DT_HEARTBEAT, buff, 0, 0) == SEDS_OK);
+        usleep(gen_random_us());
     }
     return NULL;
 }
@@ -177,8 +180,8 @@ int main(void)
            powerBoard.radio_hits, powerBoard.sd_hits);
 
     // 7) Assertions (same as your single-thread example)
-    assert(radioBoard.radio_hits == 25);
-    assert(flightControllerBoard.sd_hits == 25);
+    assert(radioBoard.radio_hits == 30);
+    assert(flightControllerBoard.sd_hits == 30);
     assert(powerBoard.radio_hits == 0);
     assert(powerBoard.sd_hits == 0);
 

sedsprintf_rs/c-system-test/src/telemetry_sim.c

@@ -253,7 +253,7 @@ SedsResult node_log(
     size_t element_count,
     size_t element_size)
 {
-    if (!n || !n->r || !data || element_count == 0 || element_size == 0) return SEDS_ERR;
+    if (!n || !n->r || !data) return SEDS_ERR;
 
     const size_t total_bytes = element_count * element_size;
     // LOCK();

sedsprintf_rs/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "maturin"
 
 [project]
 name = "sedsprintf_rs_2026"
-version = "1.1.0"
+version = "1.1.1"
 description = "Rust telemetry and serialization library"
 authors = [{ name = "Rylan Meilutis", email = "[email protected]" }]
 readme = "README.md"

sedsprintf_rs/python-example/main.py

@@ -131,25 +131,36 @@ def producer_proc(name: str, cmd_q: mp.Queue, n_iters: int, seed: int):
     random.seed(seed + os.getpid())
     print(f"[{name}] start PID={os.getpid()} iters={n_iters}")
     for i in range(n_iters):
-        which = random.randint(0, 2)
+        # 0=log_bytes, 1=log_f32, 2=log, 3=empty NoData packet
+        which = random.randint(0, 3)
+
         if which == 0:
             msg = f"{name} hello there {i}".encode("utf-8")
             cmd_q.put(deep_coerce_enums(("log_bytes", {
                 "ty": DT.MESSAGE_DATA, "data": msg
             })))
+
         elif which == 1:
             vals = [101325.0 + random.random() * 100.0,
                     20.0 + random.random() * 10.0,
                     -0.5 + random.random()]
             cmd_q.put(deep_coerce_enums(("log_f32", {
                 "ty": DT.BAROMETER_DATA, "values": vals
             })))
-        else:
+
+        elif which == 2:
             arr = np.array([random.randint(0, 1000) for _ in range(8)], dtype=np.uint16)
             cmd_q.put(deep_coerce_enums(("log", {
                 "ty": DT.GPS_DATA, "data": arr,
                 "elem_size": 2, "elem_kind": EK.UNSIGNED
             })))
+
+        else:
+            # Replace DT.HEARTBEAT with your actual NoData DataType
+            cmd_q.put(deep_coerce_enums(("log_bytes", {
+                "ty": DT.HEARTBEAT,  # or whatever logical DataType uses MessageDataType::NoData
+                "data": b"",
+            })))
         time.sleep(random.random() * 0.002)  # 0–2ms jitter
     print(f"[{name}] done")
 

sedsprintf_rs/src/c_api.rs

@@ -19,7 +19,8 @@ use crate::{
 };
 use alloc::{boxed::Box, string::String, sync::Arc, vec, vec::Vec};
 use core::{ffi::c_char, ffi::c_void, mem::size_of, ptr, slice, str::from_utf8};
-
+use crate::config::get_message_data_type;
+use crate::MessageDataType::NoData;
 // ============================================================================
 //  Constants / basic types shared with the C side
 // ============================================================================
@@ -242,7 +243,7 @@ unsafe fn write_str_to_buf(s: &str, buf: *mut c_char, buf_len: usize) -> i32 {
 /// Used in FFI logging helpers.
 #[inline]
 fn width_is_valid(width: usize) -> bool {
-    matches!(width, 1 | 2 | 4 | 8 | 16)
+    matches!(width, 0| 1 | 2 | 4 | 8 | 16)
 }
 
 /// FFI-facing clock adapter that calls back into C when present.
@@ -593,6 +594,22 @@ fn finish_with<T: LeBytes + Copy>(
     required_elems: usize,
     elem_size: usize,
 ) -> i32 {
+    if get_message_data_type(ty) == NoData{
+        return ok_or_status(unsafe {
+            let router = &(*r).inner; // shared borrow
+            if queue {
+                match ts {
+                    Some(t) => router.log_queue_ts::<T>(ty, t, &[]),
+                    None => router.log_queue::<T>(ty, &[]),
+                }
+            } else {
+                match ts {
+                    Some(t) => router.log_ts::<T>(ty, t, &[]),
+                    None => router.log::<T>(ty, &[]),
+                }
+            }
+        });
+    }
     let mut tmp: Vec<T> = Vec::with_capacity(required_elems);
     // vectorize_data reads unaligned little-endian elements into tmp
     if let Err(_) = vectorize_data::<T>(padded.as_ptr(), required_elems, elem_size, &mut tmp) {
@@ -1136,7 +1153,6 @@ pub extern "C" fn seds_pkt_data_ptr(
     view.payload as *const c_void
 }
 
-
 macro_rules! impl_seds_pkt_get_typed_from_packet {
     ($fname:ident, $method:ident, $ty:ty) => {
         #[unsafe(no_mangle)]
@@ -1182,7 +1198,6 @@ macro_rules! impl_seds_pkt_get_typed_from_packet {
     };
 }
 
-
 // Typed getters using TelemetryPacket's data_as_* helpers.
 // All use "query" semantics like seds_pkt_copy_data:
 //   - If out is NULL or out_elems < needed, return needed (element count) and do not copy.
@@ -1191,12 +1206,12 @@ macro_rules! impl_seds_pkt_get_typed_from_packet {
 impl_seds_pkt_get_typed_from_packet!(seds_pkt_get_f32, data_as_f32, f32);
 impl_seds_pkt_get_typed_from_packet!(seds_pkt_get_f64, data_as_f64, f64);
 
-impl_seds_pkt_get_typed_from_packet!(seds_pkt_get_u8,  data_as_u8,  u8);
+impl_seds_pkt_get_typed_from_packet!(seds_pkt_get_u8, data_as_u8, u8);
 impl_seds_pkt_get_typed_from_packet!(seds_pkt_get_u16, data_as_u16, u16);
 impl_seds_pkt_get_typed_from_packet!(seds_pkt_get_u32, data_as_u32, u32);
 impl_seds_pkt_get_typed_from_packet!(seds_pkt_get_u64, data_as_u64, u64);
 
-impl_seds_pkt_get_typed_from_packet!(seds_pkt_get_i8,  data_as_i8,  i8);
+impl_seds_pkt_get_typed_from_packet!(seds_pkt_get_i8, data_as_i8, i8);
 impl_seds_pkt_get_typed_from_packet!(seds_pkt_get_i16, data_as_i16, i16);
 impl_seds_pkt_get_typed_from_packet!(seds_pkt_get_i32, data_as_i32, i32);
 impl_seds_pkt_get_typed_from_packet!(seds_pkt_get_i64, data_as_i64, i64);
@@ -1232,9 +1247,7 @@ pub extern "C" fn seds_pkt_get_string(
 }
 
 #[unsafe(no_mangle)]
-pub extern "C" fn seds_pkt_get_string_len(
-    pkt: *const SedsPacketView,
-) -> i32 {
+pub extern "C" fn seds_pkt_get_string_len(pkt: *const SedsPacketView) -> i32 {
     if pkt.is_null() {
         return status_from_err(TelemetryError::BadArg);
     }

sedsprintf_rs/src/config.rs

@@ -114,6 +114,8 @@ pub enum DataType {
     Abort,
     FuelFlow,
     FuelTankPressure,
+    FlightState,
+    Heartbeat,
     /// Generic string message payload.
     MessageData,
 }
@@ -137,6 +139,8 @@ impl DataType {
             DataType::Abort => "ABORT",
             DataType::FuelFlow => "FUEL_FLOW",
             DataType::FuelTankPressure => "FUEL_TANK_PRESSURE",
+            DataType::FlightState => "FLIGHT_STATE",
+            DataType::Heartbeat => "HEARTBEAT",
             DataType::MessageData => "MESSAGE_DATA",
         }
     }
@@ -166,10 +170,12 @@ 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::Abort => MessageDataType::NoData,
         DataType::FuelFlow => MessageDataType::Float32,
         DataType::FuelTankPressure => MessageDataType::Float32,
+        DataType::FlightState => MessageDataType::UInt8,
         DataType::MessageData => MessageDataType::String,
+        DataType::Heartbeat => MessageDataType::NoData,
     }
 }
 
@@ -191,7 +197,9 @@ pub const fn get_message_info_types(message_type: DataType) -> MessageType {
         DataType::Abort => MessageType::Error,
         DataType::FuelFlow => MessageType::Info,
         DataType::FuelTankPressure => MessageType::Info,
+        DataType::FlightState => MessageType::Info,
         DataType::MessageData => MessageType::Info,
+        DataType::Heartbeat => MessageType::Info,
     }
 }
 
@@ -276,7 +284,7 @@ pub const fn get_message_meta(data_type: DataType) -> MessageMeta {
         DataType::Abort => {
             MessageMeta {
                 // Abort Command
-                element_count: MessageElementCount::Static(1), // Abort messages carry 1 boolean element
+                element_count: MessageElementCount::Static(0), // Abort messages carry 1 boolean element
                 endpoints: &[
                     DataEndpoint::Abort,
                 ],
@@ -296,6 +304,20 @@ pub const fn get_message_meta(data_type: DataType) -> MessageMeta {
                 endpoints: &[DataEndpoint::GroundStation, DataEndpoint::SdCard],
             }
         }
+        DataType::FlightState => {
+            MessageMeta {
+                // Flight State Data
+                element_count: MessageElementCount::Static(1), // Flight State messages carry 1 uint8 element
+                endpoints: &[DataEndpoint::GroundStation, DataEndpoint::SdCard],
+            }
+        }
+        DataType::Heartbeat => {
+            MessageMeta {
+                // Heartbeat Data
+                element_count: MessageElementCount::Static(0), // Heartbeat messages carry 1 binary element
+                endpoints: &[DataEndpoint::GroundStation, DataEndpoint::SdCard],
+            }
+        }
         DataType::MessageData => {
             MessageMeta {
                 // Message Data

sedsprintf_rs/src/lib.rs

@@ -244,6 +244,15 @@ pub const fn get_data_type(ty: DataType) -> MessageDataType {
     get_message_data_type(ty)
 }
 
+/// Return the default endpoints for a given `DataType`.
+/// # Arguments
+/// - `ty`: Logical data type to query.
+/// # Returns
+/// - Slice of allowed `DataEndpoint` values.
+#[inline]
+pub const fn endpoints_from_datatype(ty: DataType) -> &'static [DataEndpoint] {
+    get_message_meta(ty).endpoints
+}
 /// Primitive element type used by a message.
 ///
 /// This is the underlying "slot" type, not the high-level `DataType`
@@ -266,6 +275,7 @@ pub enum MessageDataType {
     Bool,
     String,
     Binary,
+    NoData,
 }
 
 /// Size in bytes of a single element for the given [`MessageDataType`].
@@ -294,6 +304,7 @@ pub const fn data_type_size(dt: MessageDataType) -> usize {
         MessageDataType::Bool => size_of::<bool>(),
         MessageDataType::String => MAX_STATIC_STRING_LENGTH,
         MessageDataType::Binary => MAX_STATIC_HEX_LENGTH,
+        MessageDataType::NoData => 0,
     }
 }
 

sedsprintf_rs/src/macros.rs

@@ -199,3 +199,62 @@ macro_rules! do_vec_log_typed {
         }
     }};
 }
+
+/// Helper macros for implementing `TelemetryPacket` constructors and
+/// accessors for primitive slices.
+#[macro_export]
+macro_rules! impl_from_prim_slices {
+    ($($fn_name:ident, $elem_ty:ty);+ $(;)?) => {
+        $(
+            #[inline]
+            pub fn $fn_name(
+                ty: DataType,
+                values: &[$elem_ty],
+                endpoints: &[DataEndpoint],
+                timestamp: u64,
+            ) -> TelemetryResult<Self> {
+                Self::from_prim_le_slice(ty, values, endpoints, timestamp)
+            }
+        )+
+    };
+}
+/// Helper macros for implementing `TelemetryPacket` data accessors for
+/// primitive slices.
+#[macro_export]
+macro_rules! impl_data_as_prim {
+    ($($name:ident, $ty:ty, $variant:expr);+ $(;)?) => {
+        $(
+            #[doc = concat!("Decode payload as little-endian `", stringify!($ty), "` values.")]
+            #[inline]
+            pub fn $name(&self) -> TelemetryResult<Vec<$ty>> {
+                self._as_le_bytes::<$ty>($variant)
+            }
+        )+
+    };
+}
+
+/// Implement the [`LeDecode`] trait for a numeric type with fixed size.
+///
+/// This is used to unify little-endian deserialization for primitive types
+/// like `u16`, `u32`, `f32`, etc.
+///
+/// `$ty`: concrete numeric type (e.g. `u16`, `i32`, `f32`)
+///# Example
+/// ```text
+/// impl_ledecode_auto!(u32);
+/// impl_ledecode_auto!(f32);
+/// ```
+#[macro_export]
+macro_rules! impl_ledecode_auto {
+    ($ty:ty) => {
+        impl LeDecode for $ty {
+            const WIDTH: usize = core::mem::size_of::<$ty>();
+            #[inline]
+            fn from_le(slice: &[u8]) -> Self {
+                let arr: [u8; core::mem::size_of::<$ty>()] =
+                    slice.try_into().expect("slice length mismatch");
+                <$ty>::from_le_bytes(arr)
+            }
+        }
+    };
+}