now it compiles for no_std

satrs-core/Cargo.toml

@@ -36,7 +36,7 @@ optional = true
 
 [dependencies.spacepackets]
 path = "../spacepackets"
-features = ["serde"]
+default-features = false
 
 [dev-dependencies]
 serde = "1.0"
@@ -49,9 +49,9 @@ version = "1.0"
 
 [features]
 default = ["std"]
-std = ["downcast-rs/std", "alloc", "bus", "postcard/use-std", "crossbeam-channel/std", "serde/std"]
+std = ["downcast-rs/std", "alloc", "bus", "postcard/use-std", "crossbeam-channel/std", "serde/std", "spacepackets/std"]
-alloc = ["serde/alloc"]
+alloc = ["serde/alloc", "spacepackets/alloc"]
-serde = ["dep:serde"]
+serde = ["dep:serde", "spacepackets/serde"]
 heapless = []
 doc-images = []
 

satrs-core/src/event_man.rs

@@ -56,8 +56,11 @@ doc = ::embed_doc_image::embed_image!("event_man_arch", "images/event_man_arch.p
 //! different threads.
 use crate::events::{EventU16, EventU32, GenericEvent, LargestEventRaw, LargestGroupIdRaw};
 use crate::params::{Params, ParamsHeapless};
+#[cfg(feature = "alloc")]
 use alloc::boxed::Box;
+#[cfg(feature = "alloc")]
 use alloc::vec;
+#[cfg(feature = "alloc")]
 use alloc::vec::Vec;
 use core::slice::Iter;
 use hashbrown::HashMap;

satrs-core/src/events.rs

@@ -29,10 +29,10 @@
 //! ```
 use core::fmt::Debug;
 use core::hash::Hash;
+use core::marker::PhantomData;
 use delegate::delegate;
 use spacepackets::ecss::{EcssEnumeration, ToBeBytes};
 use spacepackets::{ByteConversionError, SizeMissmatch};
-use std::marker::PhantomData;
 
 /// Using a type definition allows to change this to u64 in the future more easily
 pub type LargestEventRaw = u32;

satrs-core/src/objects.rs

@@ -51,10 +51,10 @@
 //!  assert_eq!(example_obj.id, obj_id);
 //!  assert_eq!(example_obj.dummy, 42);
 //! ```
+#[cfg(feature = "alloc")]
 use alloc::boxed::Box;
-#[cfg(not(feature = "std"))]
-use alloc::vec::Vec;
 use downcast_rs::Downcast;
+#[cfg(feature = "alloc")]
 use hashbrown::HashMap;
 #[cfg(feature = "std")]
 use std::error::Error;

satrs-core/src/params.rs

@@ -43,21 +43,23 @@
 //! This includes the [ParamsHeapless] enumeration for contained values which do not require heap
 //! allocation, and the [Params] which enumerates [ParamsHeapless] and some additional types which
 //! require [alloc] support but allow for more flexbility.
+#[cfg(feature = "alloc")]
 use crate::pool::StoreAddr;
 #[cfg(feature = "alloc")]
-use alloc::string::String;
+use alloc::string::{String, ToString};
-#[cfg(feature = "alloc")]
-use alloc::string::ToString;
 #[cfg(feature = "alloc")]
 use alloc::vec::Vec;
 use core::fmt::Debug;
 use core::mem::size_of;
 use paste::paste;
-pub use spacepackets::ecss::ToBeBytes;
 use spacepackets::ecss::{EcssEnumU16, EcssEnumU32, EcssEnumU64, EcssEnumU8, EcssEnumeration};
 use spacepackets::ByteConversionError;
 use spacepackets::SizeMissmatch;
 
+#[cfg(feature = "alloc")]
+pub use alloc_mod::*;
+pub use spacepackets::ecss::ToBeBytes;
+
 /// Generic trait which is used for objects which can be converted into a raw network (big) endian
 /// byte format.
 pub trait WritableToBeBytes {
@@ -481,13 +483,6 @@ impl WritableToBeBytes for EcssEnumParams {
 pub enum ParamsHeapless {
     Raw(ParamsRaw),
     EcssEnum(EcssEnumParams),
-    Store(StoreAddr),
-}
-
-impl From<StoreAddr> for ParamsHeapless {
-    fn from(x: StoreAddr) -> Self {
-        Self::Store(x)
-    }
 }
 
 macro_rules! from_conversions_for_raw {
@@ -534,46 +529,56 @@ from_conversions_for_raw!(
     (f64, Self::F64),
 );
 
-/// Generic enumeration for additional parameters, including parameters which rely on heap
-/// allocations.
 #[cfg(feature = "alloc")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "alloc")))]
+mod alloc_mod {
-#[derive(Debug, Clone)]
+    use super::*;
-pub enum Params {
+    /// Generic enumeration for additional parameters, including parameters which rely on heap
-    Heapless(ParamsHeapless),
+    /// allocations.
-    Vec(Vec<u8>),
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "alloc")))]
-    String(String),
+    #[derive(Debug, Clone)]
-}
+    pub enum Params {
-
+        Heapless(ParamsHeapless),
-impl From<ParamsHeapless> for Params {
+        Store(StoreAddr),
-    fn from(x: ParamsHeapless) -> Self {
+        Vec(Vec<u8>),
-        Self::Heapless(x)
+        String(String),
     }
-}
 
-impl From<Vec<u8>> for Params {
+    impl From<StoreAddr> for Params {
-    fn from(val: Vec<u8>) -> Self {
+        fn from(x: StoreAddr) -> Self {
-        Self::Vec(val)
+            Self::Store(x)
+        }
     }
-}
 
-/// Converts a byte slice into the [Params::Vec] variant
+    impl From<ParamsHeapless> for Params {
-impl From<&[u8]> for Params {
+        fn from(x: ParamsHeapless) -> Self {
-    fn from(val: &[u8]) -> Self {
+            Self::Heapless(x)
-        Self::Vec(val.to_vec())
+        }
     }
-}
 
-impl From<String> for Params {
+    impl From<Vec<u8>> for Params {
-    fn from(val: String) -> Self {
+        fn from(val: Vec<u8>) -> Self {
-        Self::String(val)
+            Self::Vec(val)
+        }
     }
-}
 
-/// Converts a string slice into the [Params::String] variant
+    /// Converts a byte slice into the [Params::Vec] variant
-impl From<&str> for Params {
+    impl From<&[u8]> for Params {
-    fn from(val: &str) -> Self {
+        fn from(val: &[u8]) -> Self {
-        Self::String(val.to_string())
+            Self::Vec(val.to_vec())
+        }
+    }
+
+    impl From<String> for Params {
+        fn from(val: String) -> Self {
+            Self::String(val)
+        }
+    }
+
+    /// Converts a string slice into the [Params::String] variant
+    impl From<&str> for Params {
+        fn from(val: &str) -> Self {
+            Self::String(val.to_string())
+        }
     }
 }
 

satrs-core/src/pus/event_man.rs

@@ -1,4 +1,7 @@
-use crate::events::{EventU32, EventU32TypedSev, GenericEvent, HasSeverity, Severity};
+use crate::events::{EventU32, GenericEvent, Severity};
+#[cfg(feature = "alloc")]
+use crate::events::{EventU32TypedSev, HasSeverity};
+#[cfg(feature = "alloc")]
 use alloc::boxed::Box;
 use core::hash::Hash;
 use hashbrown::HashSet;
@@ -6,7 +9,12 @@ use hashbrown::HashSet;
 #[cfg(feature = "alloc")]
 pub use crate::pus::event::EventReporter;
 use crate::pus::verification::{TcStateStarted, VerificationToken};
-use crate::pus::{EcssTmError, EcssTmSender};
+use crate::pus::EcssTmError;
+#[cfg(feature = "alloc")]
+use crate::pus::EcssTmSender;
+#[cfg(feature = "alloc")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "alloc")))]
+pub use alloc_mod::*;
 #[cfg(feature = "heapless")]
 #[cfg_attr(doc_cfg, doc(cfg(feature = "heapless")))]
 pub use heapless_mod::*;
@@ -133,93 +141,97 @@ impl<SenderE> From<EcssTmError<SenderE>> for EventManError<SenderE> {
     }
 }
 
-pub struct PusEventDispatcher<BackendError, Provider: GenericEvent> {
+#[cfg(feature = "alloc")]
-    reporter: EventReporter,
+pub mod alloc_mod {
-    backend: Box<dyn PusEventMgmtBackendProvider<Provider, Error = BackendError>>,
+    use super::*;
-}
 
-/// Safety: All contained fields are send as well.
+    pub struct PusEventDispatcher<BackendError, Provider: GenericEvent> {
-unsafe impl<E: Send, Event: GenericEvent + Send> Send for PusEventDispatcher<E, Event> {}
-
-impl<BackendError, Provider: GenericEvent> PusEventDispatcher<BackendError, Provider> {
-    pub fn new(
         reporter: EventReporter,
         backend: Box<dyn PusEventMgmtBackendProvider<Provider, Error = BackendError>>,
-    ) -> Self {
-        Self { reporter, backend }
-    }
-}
-
-impl<BackendError, Event: GenericEvent> PusEventDispatcher<BackendError, Event> {
-    pub fn enable_tm_for_event(&mut self, event: &Event) -> Result<bool, BackendError> {
-        self.backend.enable_event_reporting(event)
     }
 
-    pub fn disable_tm_for_event(&mut self, event: &Event) -> Result<bool, BackendError> {
+    /// Safety: All contained fields are send as well.
-        self.backend.disable_event_reporting(event)
+    unsafe impl<E: Send, Event: GenericEvent + Send> Send for PusEventDispatcher<E, Event> {}
-    }
 
-    pub fn generate_pus_event_tm_generic<E>(
+    impl<BackendError, Provider: GenericEvent> PusEventDispatcher<BackendError, Provider> {
-        &mut self,
+        pub fn new(
-        sender: &mut (impl EcssTmSender<Error = E> + ?Sized),
+            reporter: EventReporter,
-        time_stamp: &[u8],
+            backend: Box<dyn PusEventMgmtBackendProvider<Provider, Error = BackendError>>,
-        event: Event,
+        ) -> Self {
-        aux_data: Option<&[u8]>,
+            Self { reporter, backend }
-    ) -> Result<bool, EventManError<E>> {
-        if !self.backend.event_enabled(&event) {
-            return Ok(false);
         }
-        match event.severity() {
+    }
-            Severity::INFO => self
+
-                .reporter
+    impl<BackendError, Event: GenericEvent> PusEventDispatcher<BackendError, Event> {
-                .event_info(sender, time_stamp, event, aux_data)
+        pub fn enable_tm_for_event(&mut self, event: &Event) -> Result<bool, BackendError> {
-                .map(|_| true)
+            self.backend.enable_event_reporting(event)
-                .map_err(|e| e.into()),
+        }
-            Severity::LOW => self
+
-                .reporter
+        pub fn disable_tm_for_event(&mut self, event: &Event) -> Result<bool, BackendError> {
-                .event_low_severity(sender, time_stamp, event, aux_data)
+            self.backend.disable_event_reporting(event)
-                .map(|_| true)
+        }
-                .map_err(|e| e.into()),
+
-            Severity::MEDIUM => self
+        pub fn generate_pus_event_tm_generic<E>(
-                .reporter
+            &mut self,
-                .event_medium_severity(sender, time_stamp, event, aux_data)
+            sender: &mut (impl EcssTmSender<Error = E> + ?Sized),
-                .map(|_| true)
+            time_stamp: &[u8],
-                .map_err(|e| e.into()),
+            event: Event,
-            Severity::HIGH => self
+            aux_data: Option<&[u8]>,
-                .reporter
+        ) -> Result<bool, EventManError<E>> {
-                .event_high_severity(sender, time_stamp, event, aux_data)
+            if !self.backend.event_enabled(&event) {
-                .map(|_| true)
+                return Ok(false);
-                .map_err(|e| e.into()),
+            }
+            match event.severity() {
+                Severity::INFO => self
+                    .reporter
+                    .event_info(sender, time_stamp, event, aux_data)
+                    .map(|_| true)
+                    .map_err(|e| e.into()),
+                Severity::LOW => self
+                    .reporter
+                    .event_low_severity(sender, time_stamp, event, aux_data)
+                    .map(|_| true)
+                    .map_err(|e| e.into()),
+                Severity::MEDIUM => self
+                    .reporter
+                    .event_medium_severity(sender, time_stamp, event, aux_data)
+                    .map(|_| true)
+                    .map_err(|e| e.into()),
+                Severity::HIGH => self
+                    .reporter
+                    .event_high_severity(sender, time_stamp, event, aux_data)
+                    .map(|_| true)
+                    .map_err(|e| e.into()),
+            }
+        }
+    }
+
+    impl<BackendError> PusEventDispatcher<BackendError, EventU32> {
+        pub fn enable_tm_for_event_with_sev<Severity: HasSeverity>(
+            &mut self,
+            event: &EventU32TypedSev<Severity>,
+        ) -> Result<bool, BackendError> {
+            self.backend.enable_event_reporting(event.as_ref())
+        }
+
+        pub fn disable_tm_for_event_with_sev<Severity: HasSeverity>(
+            &mut self,
+            event: &EventU32TypedSev<Severity>,
+        ) -> Result<bool, BackendError> {
+            self.backend.disable_event_reporting(event.as_ref())
+        }
+
+        pub fn generate_pus_event_tm<E, Severity: HasSeverity>(
+            &mut self,
+            sender: &mut (impl EcssTmSender<Error = E> + ?Sized),
+            time_stamp: &[u8],
+            event: EventU32TypedSev<Severity>,
+            aux_data: Option<&[u8]>,
+        ) -> Result<bool, EventManError<E>> {
+            self.generate_pus_event_tm_generic(sender, time_stamp, event.into(), aux_data)
         }
     }
 }
-
-impl<BackendError> PusEventDispatcher<BackendError, EventU32> {
-    pub fn enable_tm_for_event_with_sev<Severity: HasSeverity>(
-        &mut self,
-        event: &EventU32TypedSev<Severity>,
-    ) -> Result<bool, BackendError> {
-        self.backend.enable_event_reporting(event.as_ref())
-    }
-
-    pub fn disable_tm_for_event_with_sev<Severity: HasSeverity>(
-        &mut self,
-        event: &EventU32TypedSev<Severity>,
-    ) -> Result<bool, BackendError> {
-        self.backend.disable_event_reporting(event.as_ref())
-    }
-
-    pub fn generate_pus_event_tm<E, Severity: HasSeverity>(
-        &mut self,
-        sender: &mut (impl EcssTmSender<Error = E> + ?Sized),
-        time_stamp: &[u8],
-        event: EventU32TypedSev<Severity>,
-        aux_data: Option<&[u8]>,
-    ) -> Result<bool, EventManError<E>> {
-        self.generate_pus_event_tm_generic(sender, time_stamp, event.into(), aux_data)
-    }
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;

satrs-core/src/pus/verification.rs

@@ -77,6 +77,7 @@ use core::fmt::{Display, Formatter};
 use core::hash::{Hash, Hasher};
 use core::marker::PhantomData;
 use core::mem::size_of;
+#[cfg(feature = "alloc")]
 use delegate::delegate;
 use spacepackets::ecss::EcssEnumeration;
 use spacepackets::tc::PusTc;
@@ -87,7 +88,7 @@ use spacepackets::{SpHeader, MAX_APID};
 pub use crate::seq_count::SimpleSeqCountProvider;
 
 #[cfg(feature = "alloc")]
-pub use allocmod::{
+pub use alloc_mod::{
     VerificationReporterCfg, VerificationReporterWithBuf, VerificationReporterWithSender,
 };
 
@@ -656,7 +657,7 @@ impl VerificationReporterBasic {
 }
 
 #[cfg(feature = "alloc")]
-mod allocmod {
+mod alloc_mod {
     use super::*;
     use alloc::boxed::Box;
     use alloc::vec;
@@ -995,7 +996,7 @@ mod allocmod {
 
 #[cfg(feature = "std")]
 mod stdmod {
-    use super::allocmod::VerificationReporterWithSender;
+    use super::alloc_mod::VerificationReporterWithSender;
     use super::*;
     use crate::pool::{ShareablePoolProvider, SharedPool, StoreAddr, StoreError};
     use delegate::delegate;

satrs-core/src/res_code.rs

@@ -1,8 +1,10 @@
+#[cfg(feature = "serde")]
 use serde::{Deserialize, Serialize};
 use spacepackets::ecss::{EcssEnumU16, EcssEnumeration};
 use spacepackets::{ByteConversionError, SizeMissmatch};
 
-#[derive(Debug, Copy, Clone, PartialEq, Eq, Serialize, Deserialize)]
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 pub struct ResultU16 {
     group_id: u8,
     unique_id: u8,

satrs-core/src/tmtc/mod.rs

@@ -17,7 +17,9 @@ pub mod ccsds_distrib;
 pub mod pus_distrib;
 pub mod tm_helper;
 
+#[cfg(feature = "alloc")]
 pub use ccsds_distrib::{CcsdsDistributor, CcsdsError, CcsdsPacketHandler};
+#[cfg(feature = "alloc")]
 pub use pus_distrib::{PusDistributor, PusServiceProvider};
 
 #[derive(Copy, Clone, PartialEq, Eq, Debug, Hash)]

satrs-core/tests/pus_events.rs

@@ -78,10 +78,10 @@ fn test_threaded_usage() {
                                         .expect("Writing ECSS enum failed");
                                     gen_event(Some(&params_array[0..e.raw_len()]))
                                 }
-                                ParamsHeapless::Store(_) => gen_event(None),
                             },
                             Params::Vec(vec) => gen_event(Some(vec.as_slice())),
                             Params::String(str) => gen_event(Some(str.as_bytes())),
+                            Params::Store(_) => gen_event(None),
                         }
                     } else {
                         gen_event(None)

spacepackets

@@ -1 +1 @@
-Subproject commit 9b091e3a3a6f599b093c96327751bcf1bc911ca1
+Subproject commit ae55c394bb2455eed3b05a5b587048a931d27238