Merge sedsprintf_rs upstream main

Author: Rylan-Meilutis

sedsprintf_rs/src/c_api.rs

@@ -928,7 +928,7 @@ pub extern "C" fn seds_router_receive_serialized(
     }
     let router = unsafe { &(*r).inner }; // shared borrow
     let slice = unsafe { slice::from_raw_parts(bytes, len) };
-    ok_or_status(router.receive_serialized(slice))
+    ok_or_status(router.rx_serialized(slice))
 }
 
 /// Feed a packet view (constructed on the C side) into the router RX path.
@@ -942,7 +942,7 @@ pub extern "C" fn seds_router_receive(r: *mut SedsRouter, view: *const SedsPacke
         Ok(p) => p,
         Err(_) => return status_from_err(TelemetryError::InvalidType),
     };
-    ok_or_status(router.receive(&pkt))
+    ok_or_status(router.rx(&pkt))
 }
 
 /// Transmit a packet view via the router’s TX queue immediately.
@@ -959,7 +959,7 @@ pub extern "C" fn seds_router_transmit_message_queue(
         Ok(p) => p,
         Err(_) => return status_from_err(TelemetryError::InvalidType),
     };
-    ok_or_status(router.transmit_message_queue(pkt))
+    ok_or_status(router.tx_queue(pkt))
 }
 
 // ----- Queue processing (no time budget) -----

sedsprintf_rs/src/config.rs

@@ -11,7 +11,7 @@
 #[allow(unused_imports)]
 use crate::{MessageDataType, MessageElementCount, MessageMeta, MessageType, STRING_VALUE_ELEMENT};
 use strum_macros::EnumCount;
-
+use crate::EndpointsBroadcastMode;
 // -----------------------------------------------------------------------------
 // User-editable configuration
 // -----------------------------------------------------------------------------
@@ -72,7 +72,7 @@ impl DataEndpoint {
     ///
     /// This should remain stable over time for compatibility with tests and
     /// external tooling.
-    pub fn as_str(self) -> &'static str {
+    pub fn as_str(&self) -> &'static str {
         match self {
             DataEndpoint::SdCard => "SD_CARD",
             DataEndpoint::GroundStation => "GROUND_STATION",
@@ -81,6 +81,16 @@ impl DataEndpoint {
             DataEndpoint::Abort => "ABORT",
         }
     }
+    
+    pub fn get_broadast_mode(&self) -> EndpointsBroadcastMode{
+        match self {
+            DataEndpoint::SdCard => EndpointsBroadcastMode::Default,
+            DataEndpoint::GroundStation => EndpointsBroadcastMode::Default,
+            DataEndpoint::FlightController => EndpointsBroadcastMode::Default,
+            DataEndpoint::FuelBoard => EndpointsBroadcastMode::Default,
+            DataEndpoint::Abort => EndpointsBroadcastMode::Always,
+        }
+    }
 }
 
 // -----------------------------------------------------------------------------

sedsprintf_rs/src/lib.rs

@@ -150,7 +150,6 @@ impl_repr_u32_enum!(DataEndpoint, MAX_VALUE_DATA_ENDPOINT);
 // ============================================================================
 
 /// Describes how many elements are present for a given message type.
-#[allow(dead_code)]
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Ord, PartialOrd)]
 pub enum MessageElementCount {
     /// Fixed number of elements.
@@ -159,6 +158,12 @@ pub enum MessageElementCount {
     Dynamic,
 }
 
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Ord, PartialOrd)]
+pub enum EndpointsBroadcastMode {
+    Always,
+    Never,
+    Default,
+}
 /// Static metadata for a message type: element count and valid endpoints.
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Ord, PartialOrd)]
 pub struct MessageMeta {
@@ -182,7 +187,8 @@ pub fn message_meta(ty: DataType) -> MessageMeta {
 
 impl Mul<MessageElementCount> for usize {
     type Output = usize;
-
+    
+    #[inline]
     fn mul(self, rhs: MessageElementCount) -> usize {
         self * rhs.into()
     }
@@ -191,6 +197,7 @@ impl Mul<MessageElementCount> for usize {
 impl Mul<usize> for MessageElementCount {
     type Output = usize;
 
+    #[inline]
     fn mul(self, rhs: usize) -> usize {
         self.into() * rhs
     }
@@ -201,6 +208,7 @@ impl MessageElementCount {
     ///
     /// - `Static(n)` → `n`
     /// - `Dynamic`   → `0` (caller must handle dynamic sizing separately)
+    #[inline]
     fn into(self) -> usize {
         match self {
             MessageElementCount::Static(a) => a,

sedsprintf_rs/src/router.rs

@@ -1,11 +1,4 @@
-use crate::{
-    config::{DataEndpoint, DataType, DEVICE_IDENTIFIER, MAX_HANDLER_RETRIES}, get_needed_message_size, impl_letype_num,
-    lock::RouterMutex,
-    message_meta, serialize,
-    telemetry_packet::TelemetryPacket,
-    MessageElementCount, TelemetryError,
-    TelemetryResult,
-};
+use crate::{config::{DataEndpoint, DataType, DEVICE_IDENTIFIER, MAX_HANDLER_RETRIES}, get_needed_message_size, impl_letype_num, lock::RouterMutex, message_meta, serialize, telemetry_packet::TelemetryPacket, EndpointsBroadcastMode, MessageElementCount, TelemetryError, TelemetryResult};
 use alloc::{boxed::Box, collections::VecDeque, format, sync::Arc, vec, vec::Vec};
 
 #[cfg(all(not(feature = "std"), target_os = "none"))]
@@ -357,7 +350,7 @@ impl Router {
             payload,
         )?;
 
-        self.transmit_message(&error_pkt)
+        self.tx(&error_pkt)
     }
 
     // ---------- PUBLIC API: now all &self (thread-safe via internal locking) ----------
@@ -374,7 +367,7 @@ impl Router {
                 st.transmit_queue.pop_front()
             };
             let Some(pkt) = pkt_opt else { break };
-            self.transmit_message(&pkt)?; // No lock held while calling user code
+            self.tx(&pkt)?; // No lock held while calling user code
         }
         Ok(())
     }
@@ -430,7 +423,7 @@ impl Router {
                 st.transmit_queue.pop_front()
             };
             let Some(pkt) = pkt_opt else { break };
-            self.transmit_message(&pkt)?;
+            self.tx(&pkt)?;
             if self.clock.now_ms().wrapping_sub(start) >= timeout_ms as u64 {
                 break;
             }
@@ -444,7 +437,7 @@ impl Router {
     /// # Returns
     /// A TelemetryResult indicating success or failure.
     fn process_rx_queue_item(&self, item: RxItem) -> TelemetryResult<()> {
-        self.receive_item(&item)
+        self.rx_item(&item)
     }
 
     /// Process packets in the receive queue for up to `timeout_ms` milliseconds.
@@ -491,7 +484,7 @@ impl Router {
                 let mut st = self.state.lock();
                 st.transmit_queue.pop_front()
             } {
-                self.transmit_message(&pkt)?;
+                self.tx(&pkt)?;
                 did_any = true;
             }
             if !drain_fully && self.clock.now_ms().wrapping_sub(start) >= timeout_ms as u64 {
@@ -525,7 +518,7 @@ impl Router {
     /// * `pkt` - The TelemetryPacket to enqueue.
     /// # Returns
     /// A TelemetryResult indicating success or failure.
-    pub fn transmit_message_queue(&self, pkt: TelemetryPacket) -> TelemetryResult<()> {
+    pub fn tx_queue(&self, pkt: TelemetryPacket) -> TelemetryResult<()> {
         pkt.validate()?;
         let mut st = self.state.lock();
         st.transmit_queue.push_back(pkt);
@@ -736,7 +729,7 @@ impl Router {
             env.timestamp_ms,
             payload,
         )?;
-        self.transmit_message(&error_pkt)
+        self.tx(&error_pkt)
     }
 
     /// Core receive function handling both Packet and Serialized RxItems.
@@ -745,7 +738,7 @@ impl Router {
     /// * `item` - The RxItem to process (either Packet or Serialized).
     /// # Returns
     /// A TelemetryResult indicating success or failure.
-    pub fn receive_item(&self, item: &RxItem) -> TelemetryResult<()> {
+    pub fn rx_item(&self, item: &RxItem) -> TelemetryResult<()> {
         match item {
             RxItem::Packet(pkt) => {
                 pkt.validate()?;
@@ -832,7 +825,7 @@ impl Router {
     /// * `pkt` - The TelemetryPacket to transmit.
     /// # Returns
     /// A TelemetryResult indicating success or failure.
-    pub fn transmit_message(&self, pkt: &TelemetryPacket) -> TelemetryResult<()> {
+    pub fn tx(&self, pkt: &TelemetryPacket) -> TelemetryResult<()> {
         pkt.validate()?;
 
         let has_serialized_local = pkt
@@ -843,7 +836,7 @@ impl Router {
         let send_remote = pkt
             .endpoints()
             .iter()
-            .any(|e| !self.cfg.is_local_endpoint(*e));
+            .any(|e| (!self.cfg.is_local_endpoint(*e) && e.get_broadast_mode() != EndpointsBroadcastMode::Never) || e.get_broadast_mode() == EndpointsBroadcastMode::Always);
 
         // Only serialize if needed.
         let bytes_opt = if has_serialized_local || send_remote {
@@ -892,9 +885,9 @@ impl Router {
     /// * `bytes` - The serialized telemetry packet as a byte slice.
     /// # Returns
     /// A TelemetryResult indicating success or failure.
-    pub fn receive_serialized(&self, bytes: &[u8]) -> TelemetryResult<()> {
+    pub fn rx_serialized(&self, bytes: &[u8]) -> TelemetryResult<()> {
         let item = RxItem::Serialized(Arc::from(bytes));
-        self.receive_item(&item)
+        self.rx_item(&item)
     }
 
     /// Enqueue and process a telemetry packet.
@@ -903,9 +896,9 @@ impl Router {
     /// * `pkt` - The TelemetryPacket to process.
     /// # Returns
     /// A TelemetryResult indicating success or failure.
-    pub fn receive(&self, pkt: &TelemetryPacket) -> TelemetryResult<()> {
+    pub fn rx(&self, pkt: &TelemetryPacket) -> TelemetryResult<()> {
         let item = RxItem::Packet(pkt.clone());
-        self.receive_item(&item)
+        self.rx_item(&item)
     }
 
     /// Build a packet then send immediately.
@@ -916,7 +909,7 @@ impl Router {
     /// A TelemetryResult indicating success or failure.
     pub fn log<T: LeBytes>(&self, ty: DataType, data: &[T]) -> TelemetryResult<()> {
         log_raw(self.sender, ty, data, self.clock.now_ms(), |pkt| {
-            self.transmit_message(&pkt)
+            self.tx(&pkt)
         })
     }
 
@@ -928,7 +921,7 @@ impl Router {
     /// A TelemetryResult indicating success or failure.
     pub fn log_queue<T: LeBytes>(&self, ty: DataType, data: &[T]) -> TelemetryResult<()> {
         log_raw(self.sender, ty, data, self.clock.now_ms(), |pkt| {
-            self.transmit_message_queue(pkt)
+            self.tx_queue(pkt)
         })
     }
 
@@ -946,7 +939,7 @@ impl Router {
         data: &[T],
     ) -> TelemetryResult<()> {
         log_raw(self.sender, ty, data, timestamp, |pkt| {
-            self.transmit_message(&pkt)
+            self.tx(&pkt)
         })
     }
 
@@ -964,7 +957,7 @@ impl Router {
         data: &[T],
     ) -> TelemetryResult<()> {
         log_raw(self.sender, ty, data, timestamp, |pkt| {
-            self.transmit_message_queue(pkt)
+            self.tx_queue(pkt)
         })
     }
 }

sedsprintf_rs/src/tests.rs

@@ -525,7 +525,7 @@ mod handler_failure_tests {
         )
         .unwrap();
 
-        handle_errors(router.transmit_message(&pkt));
+        handle_errors(router.tx(&pkt));
 
         // The capturing handler should have seen the original packet and then the error packet.
         assert!(
@@ -588,7 +588,7 @@ mod handler_failure_tests {
         )
         .unwrap();
 
-        handle_errors(router.transmit_message(&pkt));
+        handle_errors(router.tx(&pkt));
 
         assert!(
             saw_error.load(Ordering::SeqCst) >= 1,
@@ -1281,7 +1281,7 @@ mod tests_extra {
         )
         .unwrap();
 
-        r.transmit_message_queue(pkt_tx).unwrap();
+        r.tx_queue(pkt_tx).unwrap();
         r.rx_packet_to_queue(pkt_rx).unwrap();
 
         // Clearing should drop both queues before any processing.
@@ -1339,7 +1339,7 @@ mod tests_extra {
         .unwrap();
 
         // Sending should surface a HandlerError after all retries.
-        let res = r.transmit_message(&pkt);
+        let res = r.tx(&pkt);
         match res {
             Err(TelemetryError::HandlerError(_)) => {}
             other => panic!("expected HandlerError after retries, got {other:?}"),
@@ -1459,7 +1459,7 @@ mod tests_extra {
         )
         .unwrap();
 
-        let res = r.transmit_message(&pkt);
+        let res = r.tx(&pkt);
         match res {
             Err(TelemetryError::HandlerError(_)) => {} // TX path wraps as HandlerError
             other => panic!("expected HandlerError from TX failure, got {other:?}"),
@@ -1631,7 +1631,7 @@ mod tests_more {
             BoardConfig::new(vec![handler]),
             zero_clock(),
         );
-        r.receive_serialized(&wire).unwrap();
+        r.rx_serialized(&wire).unwrap();
         assert_eq!(called.load(Ordering::SeqCst), 1);
     }
 
@@ -1669,7 +1669,7 @@ mod tests_more {
             zero_clock(),
         );
 
-        r.receive_serialized(&wire).unwrap();
+        r.rx_serialized(&wire).unwrap();
         assert_eq!(packet_called.load(Ordering::SeqCst), 1);
         assert_eq!(serialized_called.load(Ordering::SeqCst), 1);
     }
@@ -1704,7 +1704,7 @@ mod tests_more {
             0,
         )
         .unwrap();
-        r.transmit_message(&pkt).unwrap();
+        r.tx(&pkt).unwrap();
 
         assert_eq!(tx_called.load(Ordering::SeqCst), 0);
         assert_eq!(hits.load(Ordering::SeqCst), 1);
@@ -1733,7 +1733,7 @@ mod tests_more {
             0,
         )
         .unwrap();
-        r.receive(&pkt).unwrap();
+        r.rx(&pkt).unwrap();
 
         assert_eq!(called.load(Ordering::SeqCst), 1);
     }
@@ -1769,7 +1769,7 @@ mod tests_more {
             1,
         )
         .unwrap();
-        let _ = r.transmit_message(&pkt);
+        let _ = r.tx(&pkt);
 
         let s = captured.lock().unwrap().clone();
         assert!(!s.is_empty());
@@ -2085,7 +2085,7 @@ mod concurrency_tests {
             threads_vec.push(thread::spawn(move || {
                 for _ in 0..ITERS_PER_THREAD {
                     r_cloned
-                        .receive_serialized(&w_cloned)
+                        .rx_serialized(&w_cloned)
                         .expect("receive_serialized failed");
                 }
             }));