clippy fixes, dep updates

dependency hell
some more fixes, git updates
2025-05-10 16:05:03 +02:00 · 2025-05-07 13:25:09 +02:00 · 2025-05-07 13:23:43 +02:00 · 2025-05-07 09:56:43 +02:00 · 2025-05-06 16:19:36 +02:00 · 2025-05-05 19:18:03 +02:00
37 changed files with 214 additions and 559 deletions
--- a/README.md
+++ b/README.md
@@ -38,7 +38,7 @@ This project currently contains following crates:
   Example of a simple example on-board software using various sat-rs components which can be run
   on a host computer or on any system with a standard runtime like a Raspberry Pi.
 * [`satrs-minisim`](https://egit.irs.uni-stuttgart.de/rust/sat-rs/src/branch/main/satrs-minisim):
-   Mini-Simulator based on [nexosim](https://github.com/asynchronics/nexosim) which
+   Mini-Simulator based on [asynchronix](https://github.com/asynchronics/asynchronix) which
   simulates some physical devices for the `satrs-example` application device handlers.
 * [`satrs-mib`](https://egit.irs.uni-stuttgart.de/rust/sat-rs/src/branch/main/satrs-mib):
   Components to build a mission information base from the on-board software directly.
--- a/experiments/satrs-gen/Cargo.toml
+++ b/experiments/satrs-gen/Cargo.toml
@@ -1,8 +0,0 @@
-[package]
-name = "satrs-gen"
-version = "0.1.0"
-edition = "2024"
-
-[dependencies]
-toml = "0.8"
-heck = "0.5"
--- a/experiments/satrs-gen/components.toml
+++ b/experiments/satrs-gen/components.toml
@@ -1,34 +0,0 @@
-[apid]
-Sched = 1
-GenericPus = 2
-Acs = 3
-Cfdp = 4
-Tmtc = 5
-Eps = 6
-
-
-[ids]
-[ids.Eps]
-Pcdu = 0
-Subsystem = 1
-
-[ids.Tmtc]
-UdpServer = 0
-TcpServer = 1
-
-[ids.GenericPus]
-PusEventManagement = 0
-PusRouting = 1
-PusTest = 2
-PusAction = 3
-PusMode = 4
-PusHk = 5
-
-[ids.Sched]
-PusSched = 0
-
-[ids.Acs]
-Subsystem = 1
-Assembly = 2
-Mgm0 = 3
-Mgm1 = 4
--- a/experiments/satrs-gen/src/main.rs
+++ b/experiments/satrs-gen/src/main.rs
@@ -1,91 +0,0 @@
-use heck::{ToShoutySnakeCase, ToSnakeCase};
-use std::{
-    collections::BTreeMap,
-    fs::{self, File},
-    io::{self, Write},
-};
-
-use toml::{Value, map::Map};
-
-fn main() -> io::Result<()> {
-    // Read the configuration file
-    let config_str = fs::read_to_string("components.toml").expect("Unable to read file");
-    let config: Value = toml::from_str(&config_str).expect("Unable to parse TOML");
-
-    let mut output = File::create("../satrs-example/src/ids.rs")?;
-
-    generate_rust_code(&config, &mut output);
-    Ok(())
-}
-
-fn sort_enum_table(table_map: &Map<String, Value>) -> BTreeMap<u64, &str> {
-    // Collect entries into a BTreeMap to sort them by key
-    let mut sorted_entries: BTreeMap<u64, &str> = BTreeMap::new();
-
-    for (key, value) in table_map {
-        if let Some(value) = value.as_integer() {
-            if !(0..=0x7FF).contains(&value) {
-                panic!("Invalid APID value: {}", value);
-            }
-            sorted_entries.insert(value as u64, key);
-        }
-    }
-    sorted_entries
-}
-
-fn generate_rust_code(config: &Value, writer: &mut impl Write) {
-    writeln!(
-        writer,
-        "//! This is an auto-generated configuration module."
-    )
-    .unwrap();
-    writeln!(writer, "use satrs::request::UniqueApidTargetId;").unwrap();
-    writeln!(writer).unwrap();
-
-    // Generate the main module
-    writeln!(
-        writer,
-        "#[derive(Debug, Copy, Clone, PartialEq, Eq, strum::EnumIter)]"
-    )
-    .unwrap();
-    writeln!(writer, "pub enum Apid {{").unwrap();
-
-    // Generate constants for the main module
-    if let Some(apid_table) = config.get("apid").and_then(Value::as_table) {
-        let sorted_entries = sort_enum_table(apid_table);
-        // Write the sorted entries to the writer
-        for (value, key) in sorted_entries {
-            writeln!(writer, "    {} = {},", key, value).unwrap();
-        }
-    }
-    writeln!(writer, "}}").unwrap();
-
-    // Generate ID tables.
-    if let Some(id_tables) = config.get("ids").and_then(Value::as_table) {
-        for (mod_name, table) in id_tables {
-            let mod_name_as_snake = mod_name.to_snake_case();
-            writeln!(writer).unwrap();
-            writeln!(writer, "pub mod {} {{", mod_name_as_snake).unwrap();
-            let sorted_entries = sort_enum_table(table.as_table().unwrap());
-            writeln!(writer, "    #[derive(Debug, Copy, Clone, PartialEq, Eq)]").unwrap();
-            writeln!(writer, "    pub enum Id {{").unwrap();
-            // Write the sorted entries to the writer
-            for (value, key) in &sorted_entries {
-                writeln!(writer, "        {} = {},", key, value).unwrap();
-            }
-            writeln!(writer, "    }}").unwrap();
-            writeln!(writer).unwrap();
-
-            for (_value, key) in sorted_entries {
-                let key_shouting = key.to_shouty_snake_case();
-                writeln!(
-                    writer,
-                    "    pub const {}: super::UniqueApidTargetId = super::UniqueApidTargetId::new(super::Apid::{} as u16, Id::{} as u32);",
-                key_shouting, mod_name, key
-                ).unwrap();
-            }
-
-            writeln!(writer, "}}").unwrap();
-        }
-    }
-}
--- a/satrs-book/src/constrained-systems.md
+++ b/satrs-book/src/constrained-systems.md
@@ -3,20 +3,20 @@
 Software for space systems oftentimes has different requirements than the software for host
 systems or servers. Currently, most space systems are considered embedded systems.

-For these systems, the computation power and the available heap are important resources
-which are also constrained. This might make completeley heap based memory management schemes which
+For these systems, the computation power and the available heap are the most important resources
+which are constrained. This might make completeley heap based memory management schemes which
 are oftentimes used on host and server based systems unfeasable. Still, completely forbidding
 heap allocations might make software development unnecessarilly difficult, especially in a
 time where the OBSW might be running on Linux based systems with hundreds of MBs of RAM.

-A useful pattern commonly used in space systems is to limit heap allocations to program
+A useful pattern used commonly in space systems is to limit heap allocations to program
 initialization time and avoid frequent run-time allocations. This prevents issues like
 running out of memory (something even Rust can not protect from) or heap fragmentation on systems
 without a MMU.

 # Using pre-allocated pool structures

-A candidate for heap allocations is the TMTC and  handling. TC, TMs and IPC data are all
+A huge candidate for heap allocations is the TMTC and  handling. TC, TMs and IPC data are all
 candidates where the data size might vary greatly. The regular solution for host systems
 might be to send around this data as a `Vec<u8>` until it is dropped. `sat-rs` provides
 another solution to avoid run-time allocations by offering pre-allocated static
--- a/satrs-example/src/acs/assembly.rs
+++ b/satrs-example/src/acs/assembly.rs
@@ -1,175 +1 @@
 // TODO: Write the assembly
-//
-
-use std::sync::mpsc;
-
-use satrs::{
-    dev_mgmt::{DevManagerCommandingHelper, DevManagerHelperResult, TransparentDevManagerHook},
-    mode::{
-        ModeAndSubmode, ModeError, ModeProvider, ModeReply, ModeReplyReceiver as _,
-        ModeReplySender as _, ModeRequest, ModeRequestHandler, ModeRequestReceiver as _,
-        ModeRequestorAndHandlerMpscBounded, UNKNOWN_MODE,
-    },
-    mode_tree::{ModeChild, ModeNode, ModeParent},
-    queue::GenericTargetedMessagingError,
-    request::{GenericMessage, MessageMetadata},
-    ComponentId,
-};
-use satrs_example::{ids, DeviceMode};
-
-pub type RequestSenderType = mpsc::SyncSender<GenericMessage<ModeRequest>>;
-pub type ReplySenderType = mpsc::SyncSender<GenericMessage<ModeReply>>;
-
-// TODO: Needs to perform same functions as the integration test assembly, but also needs
-// to track mode changes and health changes of children.
-pub struct MgmAssembly {
-    pub mode_node: ModeRequestorAndHandlerMpscBounded,
-    pub mode_requestor_info: Option<MessageMetadata>,
-    pub mode_and_submode: ModeAndSubmode,
-    pub commanding_helper: DevManagerCommandingHelper<TransparentDevManagerHook>,
-}
-
-impl MgmAssembly {
-    pub fn new(mode_node: ModeRequestorAndHandlerMpscBounded) -> Self {
-        Self {
-            mode_node,
-            mode_requestor_info: None,
-            mode_and_submode: UNKNOWN_MODE,
-            commanding_helper: DevManagerCommandingHelper::new(TransparentDevManagerHook::default()),
-        }
-    }
-
-    pub const fn id() -> ComponentId {
-        ids::acs::MGM_ASSEMBLY.raw()
-    }
-
-    pub fn periodic_operation(&mut self) {
-        self.check_mode_requests().expect("mode messaging error");
-        self.check_mode_replies().expect("mode messaging error");
-        // TODO: perform target keeping, check whether children are in correct mode.
-    }
-
-    pub fn check_mode_requests(&mut self) -> Result<(), GenericTargetedMessagingError> {
-        while let Some(request) = self.mode_node.try_recv_mode_request()? {
-            self.handle_mode_request(request).unwrap();
-        }
-        Ok(())
-    }
-
-    pub fn check_mode_replies(&mut self) -> Result<(), ModeError> {
-        while let Some(reply_and_id) = self.mode_node.try_recv_mode_reply()? {
-            match self.commanding_helper.handle_mode_reply(&reply_and_id) {
-                Ok(result) => {
-                    if let DevManagerHelperResult::ModeCommandingDone(context) = result {
-                        // Complete the mode command.
-                        self.mode_and_submode = context.target_mode;
-                        self.handle_mode_reached(self.mode_requestor_info)?;
-                    }
-                }
-                Err(err) => match err {
-                    satrs::dev_mgmt::DevManagerHelperError::ChildNotInStore => todo!(),
-                },
-            }
-        }
-        Ok(())
-    }
-}
-
-impl ModeNode for MgmAssembly {
-    fn id(&self) -> ComponentId {
-        Self::id()
-    }
-}
-impl ModeParent for MgmAssembly {
-    type Sender = RequestSenderType;
-
-    fn add_mode_child(&mut self, id: ComponentId, request_sender: RequestSenderType) {
-        self.mode_node.add_request_target(id, request_sender);
-        self.commanding_helper.add_mode_child(id, UNKNOWN_MODE);
-    }
-}
-
-impl ModeChild for MgmAssembly {
-    type Sender = ReplySenderType;
-
-    fn add_mode_parent(&mut self, id: ComponentId, reply_sender: ReplySenderType) {
-        self.mode_node.add_reply_target(id, reply_sender);
-    }
-}
-
-impl ModeProvider for MgmAssembly {
-    fn mode_and_submode(&self) -> ModeAndSubmode {
-        self.mode_and_submode
-    }
-}
-
-impl ModeRequestHandler for MgmAssembly {
-    type Error = ModeError;
-    fn start_transition(
-        &mut self,
-        requestor: MessageMetadata,
-        mode_and_submode: ModeAndSubmode,
-        forced: bool,
-    ) -> Result<(), Self::Error> {
-        // Always accept forced commands and commands to mode OFF.
-        if self.commanding_helper.target_mode().is_some()
-            && !forced
-            && mode_and_submode.mode() != DeviceMode::Off as u32
-        {
-            return Err(ModeError::Busy);
-        }
-        self.mode_requestor_info = Some(requestor);
-        self.commanding_helper.send_mode_cmd_to_all_children(
-            requestor.request_id(),
-            mode_and_submode,
-            forced,
-            &self.mode_node,
-        )?;
-        Ok(())
-    }
-
-    fn announce_mode(&self, requestor_info: Option<MessageMetadata>, recursive: bool) {
-        println!(
-            "TestAssembly: Announcing mode (recursively: {}): {:?}",
-            recursive, self.mode_and_submode
-        );
-        let request_id = requestor_info.map_or(0, |info| info.request_id());
-        self.commanding_helper
-            .send_announce_mode_cmd_to_children(request_id, &self.mode_node, recursive)
-            .expect("sending mode request failed");
-        // TODO: Send announce event.
-        log::info!(
-            "MGM assembly announcing mode: {:?}",
-            self.mode_and_submode()
-        );
-    }
-
-    fn handle_mode_reached(
-        &mut self,
-        mode_requestor: Option<MessageMetadata>,
-    ) -> Result<(), Self::Error> {
-        if let Some(requestor) = mode_requestor {
-            self.send_mode_reply(requestor, ModeReply::ModeReply(self.mode_and_submode))?;
-        }
-        self.announce_mode(mode_requestor, false);
-        Ok(())
-    }
-
-    fn handle_mode_info(
-        &mut self,
-        requestor_info: MessageMetadata,
-        info: ModeAndSubmode,
-    ) -> Result<(), Self::Error> {
-        // TODO: Perform mode keeping.
-        Ok(())
-    }
-
-    fn send_mode_reply(
-        &self,
-        requestor: MessageMetadata,
-        reply: ModeReply,
-    ) -> Result<(), Self::Error> {
-        self.mode_node.send_mode_reply(requestor, reply)?;
-        Ok(())
-    }
-}
--- a/satrs-example/src/acs/mgm.rs
+++ b/satrs-example/src/acs/mgm.rs
@@ -2,7 +2,7 @@ use derive_new::new;
 use satrs::hk::{HkRequest, HkRequestVariant};
 use satrs::mode_tree::{ModeChild, ModeNode};
 use satrs::power::{PowerSwitchInfo, PowerSwitcherCommandSender};
-use satrs_example::ids::generic_pus::PUS_MODE;
+use satrs_example::config::pus::PUS_MODE_SERVICE;
 use satrs_example::{DeviceMode, TimestampHelper};
 use satrs_minisim::acs::lis3mdl::{
    MgmLis3MdlReply, MgmLis3RawValues, FIELD_LSB_PER_GAUSS_4_SENS, GAUSS_TO_MICROTESLA_FACTOR,
@@ -400,7 +400,6 @@ impl<
    }

    fn announce_mode(&self, _requestor_info: Option<MessageMetadata>, _recursive: bool) {
-        // TODO: Event
        log::info!(
            "{} announcing mode: {:?}",
            self.dev_str,
@@ -418,7 +417,7 @@ impl<
            if requestor.sender_id() == NO_SENDER {
                return Ok(());
            }
-            if requestor.sender_id() != PUS_MODE.id() {
+            if requestor.sender_id() != PUS_MODE_SERVICE.id() {
                log::warn!(
                    "can not send back mode reply to sender {:x}",
                    requestor.sender_id()
@@ -435,7 +434,7 @@ impl<
        requestor: MessageMetadata,
        reply: ModeReply,
    ) -> Result<(), Self::Error> {
-        if requestor.sender_id() != PUS_MODE.id() {
+        if requestor.sender_id() != PUS_MODE_SERVICE.id() {
            log::warn!(
                "can not send back mode reply to sender {}",
                requestor.sender_id()
@@ -493,7 +492,7 @@ mod tests {
        tmtc::PacketAsVec,
        ComponentId,
    };
-    use satrs_example::ids::{acs::MGM_ASSEMBLY, Apid};
+    use satrs_example::config::{acs::MGM_ASSEMBLY, components::Apid};
    use satrs_minisim::acs::lis3mdl::MgmLis3RawValues;

    use crate::{eps::TestSwitchHelper, pus::hk::HkReply, requests::CompositeRequest};
@@ -539,7 +538,7 @@ mod tests {

    impl ModeNode for MgmAssemblyMock {
        fn id(&self) -> satrs::ComponentId {
-            PUS_MODE.into()
+            PUS_MODE_SERVICE.into()
        }
    }

@@ -558,7 +557,7 @@ mod tests {

    impl ModeNode for PusMock {
        fn id(&self) -> satrs::ComponentId {
-            PUS_MODE.into()
+            PUS_MODE_SERVICE.into()
        }
    }

@@ -593,7 +592,7 @@ mod tests {
                TestSpiInterface::default(),
                shared_mgm_set,
            );
-            handler.add_mode_parent(PUS_MODE.into(), reply_tx_to_pus);
+            handler.add_mode_parent(PUS_MODE_SERVICE.into(), reply_tx_to_pus);
            handler.add_mode_parent(MGM_ASSEMBLY.into(), reply_tx_to_parent);
            Self {
                mode_request_tx: request_tx,
@@ -632,7 +631,7 @@ mod tests {
        testbench
            .mode_request_tx
            .send(GenericMessage::new(
-                MessageMetadata::new(0, PUS_MODE.id()),
+                MessageMetadata::new(0, PUS_MODE_SERVICE.id()),
                ModeRequest::SetMode {
                    mode_and_submode: ModeAndSubmode::new(DeviceMode::Normal as u32, 0),
                    forced: false,
@@ -693,7 +692,7 @@ mod tests {
        testbench
            .mode_request_tx
            .send(GenericMessage::new(
-                MessageMetadata::new(0, PUS_MODE.id()),
+                MessageMetadata::new(0, PUS_MODE_SERVICE.id()),
                ModeRequest::SetMode {
                    mode_and_submode: ModeAndSubmode::new(DeviceMode::Normal as u32, 0),
                    forced: false,
--- a/satrs-example/src/bin/simpleclient.rs
+++ b/satrs-example/src/bin/simpleclient.rs
@@ -1,7 +1,10 @@
 use satrs::pus::verification::RequestId;
 use satrs::spacepackets::ecss::tc::PusTcCreator;
 use satrs::spacepackets::ecss::tm::PusTmReader;
-use satrs::{spacepackets::ecss::PusPacket, spacepackets::SpHeader};
+use satrs::{
+    spacepackets::ecss::{PusPacket, WritablePusPacket},
+    spacepackets::SpHeader,
+};
 use satrs_example::config::{OBSW_SERVER_ADDR, SERVER_PORT};
 use std::net::{IpAddr, SocketAddr, UdpSocket};
 use std::time::Duration;
--- a/satrs-example/src/config.rs
+++ b/satrs-example/src/config.rs
@@ -43,14 +43,14 @@ pub const TEST_EVENT: EventU32TypedSev<SeverityInfo> = EventU32TypedSev::<Severi
 lazy_static! {
    pub static ref PACKET_ID_VALIDATOR: HashSet<PacketId> = {
        let mut set = HashSet::new();
-        for id in crate::ids::Apid::iter() {
+        for id in components::Apid::iter() {
            set.insert(PacketId::new(PacketType::Tc, true, id as u16));
        }
        set
    };
    pub static ref APID_VALIDATOR: HashSet<u16> = {
        let mut set = HashSet::new();
-        for id in crate::ids::Apid::iter() {
+        for id in components::Apid::iter() {
            set.insert(id as u16);
        }
        set
@@ -122,11 +122,92 @@ pub mod mode_err {
 }

 pub mod components {
-    use satrs::ComponentId;
+    use satrs::{request::UniqueApidTargetId, ComponentId};
+    use strum::EnumIter;

+    #[derive(Copy, Clone, PartialEq, Eq, EnumIter)]
+    pub enum Apid {
+        Sched = 1,
+        GenericPus = 2,
+        Acs = 3,
+        Cfdp = 4,
+        Tmtc = 5,
+        Eps = 6,
+    }
+
+    #[derive(Copy, Clone, PartialEq, Eq)]
+    pub enum EpsId {
+        Pcdu = 0,
+        Subsystem = 1,
+    }
+
+    #[derive(Copy, Clone, PartialEq, Eq)]
+    pub enum TmtcId {
+        UdpServer = 0,
+        TcpServer = 1,
+    }
+
+    pub const EPS_SUBSYSTEM: UniqueApidTargetId =
+        UniqueApidTargetId::new(Apid::Eps as u16, EpsId::Subsystem as u32);
+    pub const PCDU_HANDLER: UniqueApidTargetId =
+        UniqueApidTargetId::new(Apid::Eps as u16, EpsId::Pcdu as u32);
+    pub const UDP_SERVER: UniqueApidTargetId =
+        UniqueApidTargetId::new(Apid::Tmtc as u16, TmtcId::UdpServer as u32);
+    pub const TCP_SERVER: UniqueApidTargetId =
+        UniqueApidTargetId::new(Apid::Tmtc as u16, TmtcId::TcpServer as u32);
    pub const NO_SENDER: ComponentId = ComponentId::MAX;
 }

+pub mod pus {
+    use super::components::Apid;
+    use satrs::request::UniqueApidTargetId;
+
+    // Component IDs for components with the PUS APID.
+    #[derive(Copy, Clone, PartialEq, Eq)]
+    pub enum PusId {
+        PusEventManagement = 0,
+        PusRouting = 1,
+        PusTest = 2,
+        PusAction = 3,
+        PusMode = 4,
+        PusHk = 5,
+    }
+    pub const PUS_ACTION_SERVICE: UniqueApidTargetId =
+        UniqueApidTargetId::new(Apid::GenericPus as u16, PusId::PusAction as u32);
+    pub const PUS_EVENT_MANAGEMENT: UniqueApidTargetId =
+        UniqueApidTargetId::new(Apid::GenericPus as u16, 0);
+    pub const PUS_ROUTING_SERVICE: UniqueApidTargetId =
+        UniqueApidTargetId::new(Apid::GenericPus as u16, PusId::PusRouting as u32);
+    pub const PUS_TEST_SERVICE: UniqueApidTargetId =
+        UniqueApidTargetId::new(Apid::GenericPus as u16, PusId::PusTest as u32);
+    pub const PUS_MODE_SERVICE: UniqueApidTargetId =
+        UniqueApidTargetId::new(Apid::GenericPus as u16, PusId::PusMode as u32);
+    pub const PUS_HK_SERVICE: UniqueApidTargetId =
+        UniqueApidTargetId::new(Apid::GenericPus as u16, PusId::PusHk as u32);
+    pub const PUS_SCHED_SERVICE: UniqueApidTargetId =
+        UniqueApidTargetId::new(Apid::Sched as u16, 0);
+}
+
+pub mod acs {
+    use super::components::Apid;
+    use satrs::request::UniqueApidTargetId;
+
+    #[derive(Copy, Clone, PartialEq, Eq)]
+    pub enum AcsId {
+        Subsystem = 1,
+        Assembly = 2,
+        Mgm0 = 3,
+        Mgm1 = 4,
+    }
+
+    pub const MGM_ASSEMBLY: UniqueApidTargetId =
+        UniqueApidTargetId::new(Apid::Acs as u16, AcsId::Assembly as u32);
+    pub const MGM_HANDLER_0: UniqueApidTargetId =
+        UniqueApidTargetId::new(Apid::Acs as u16, AcsId::Mgm0 as u32);
+    pub const MGM_HANDLER_1: UniqueApidTargetId =
+        UniqueApidTargetId::new(Apid::Acs as u16, AcsId::Mgm0 as u32);
+}
+
 pub mod pool {
    use super::*;
    pub fn create_static_pools() -> (StaticMemoryPool, StaticMemoryPool) {
--- a/satrs-example/src/eps/pcdu.rs
+++ b/satrs-example/src/eps/pcdu.rs
@@ -20,8 +20,10 @@ use satrs::{
    spacepackets::ByteConversionError,
 };
 use satrs_example::{
-    config::components::NO_SENDER,
-    ids::{eps::PCDU, generic_pus::PUS_MODE},
+    config::{
+        components::{NO_SENDER, PCDU_HANDLER},
+        pus::PUS_MODE_SERVICE,
+    },
    DeviceMode, TimestampHelper,
 };
 use satrs_minisim::{
@@ -450,7 +452,7 @@ impl<ComInterface: SerialInterface> ModeRequestHandler for PcduHandler<ComInterf
            if requestor.sender_id() == NO_SENDER {
                return Ok(());
            }
-            if requestor.sender_id() != PUS_MODE.id() {
+            if requestor.sender_id() != PUS_MODE_SERVICE.id() {
                log::warn!(
                    "can not send back mode reply to sender {}",
                    requestor.sender_id()
@@ -467,7 +469,7 @@ impl<ComInterface: SerialInterface> ModeRequestHandler for PcduHandler<ComInterf
        requestor: MessageMetadata,
        reply: ModeReply,
    ) -> Result<(), Self::Error> {
-        if requestor.sender_id() != PUS_MODE.id() {
+        if requestor.sender_id() != PUS_MODE_SERVICE.id() {
            log::warn!(
                "can not send back mode reply to sender {}",
                requestor.sender_id()
@@ -490,7 +492,7 @@ impl<ComInterface: SerialInterface> ModeRequestHandler for PcduHandler<ComInterf

 impl<ComInterface: SerialInterface> ModeNode for PcduHandler<ComInterface> {
    fn id(&self) -> satrs::ComponentId {
-        PCDU.into()
+        PCDU_HANDLER.into()
    }
 }

@@ -509,7 +511,10 @@ mod tests {
    use satrs::{
        mode::ModeRequest, power::SwitchStateBinary, request::GenericMessage, tmtc::PacketAsVec,
    };
-    use satrs_example::ids::{self, Apid};
+    use satrs_example::config::{
+        acs::MGM_HANDLER_0,
+        components::{Apid, EPS_SUBSYSTEM, PCDU_HANDLER},
+    };
    use satrs_minisim::eps::SwitchMapBinary;

    use super::*;
@@ -565,7 +570,8 @@ mod tests {
            let (mode_request_tx, mode_request_rx) = mpsc::sync_channel(5);
            let (mode_reply_tx_to_pus, mode_reply_rx_to_pus) = mpsc::sync_channel(5);
            let (mode_reply_tx_to_parent, mode_reply_rx_to_parent) = mpsc::sync_channel(5);
-            let mode_node = ModeRequestHandlerMpscBounded::new(PCDU.into(), mode_request_rx);
+            let mode_node =
+                ModeRequestHandlerMpscBounded::new(PCDU_HANDLER.into(), mode_request_rx);
            let (composite_request_tx, composite_request_rx) = mpsc::channel();
            let (hk_reply_tx, hk_reply_rx) = mpsc::sync_channel(10);
            let (tm_tx, tm_rx) = mpsc::sync_channel::<PacketAsVec>(5);
@@ -582,8 +588,8 @@ mod tests {
                SerialInterfaceTest::default(),
                shared_switch_map,
            );
-            handler.add_mode_parent(ids::eps::SUBSYSTEM.into(), mode_reply_tx_to_parent);
-            handler.add_mode_parent(PUS_MODE.into(), mode_reply_tx_to_pus);
+            handler.add_mode_parent(EPS_SUBSYSTEM.into(), mode_reply_tx_to_parent);
+            handler.add_mode_parent(PUS_MODE_SERVICE.into(), mode_reply_tx_to_pus);
            Self {
                mode_request_tx,
                mode_reply_rx_to_pus,
@@ -678,7 +684,7 @@ mod tests {
        testbench
            .mode_request_tx
            .send(GenericMessage::new(
-                MessageMetadata::new(0, PUS_MODE.id()),
+                MessageMetadata::new(0, PUS_MODE_SERVICE.id()),
                ModeRequest::SetMode {
                    mode_and_submode: ModeAndSubmode::new(DeviceMode::Normal as u32, 0),
                    forced: false,
@@ -713,7 +719,7 @@ mod tests {
        testbench
            .mode_request_tx
            .send(GenericMessage::new(
-                MessageMetadata::new(0, PUS_MODE.id()),
+                MessageMetadata::new(0, PUS_MODE_SERVICE.id()),
                ModeRequest::SetMode {
                    mode_and_submode: ModeAndSubmode::new(DeviceMode::Normal as u32, 0),
                    forced: false,
@@ -723,7 +729,7 @@ mod tests {
        testbench
            .switch_request_tx
            .send(GenericMessage::new(
-                MessageMetadata::new(0, ids::acs::MGM0.id()),
+                MessageMetadata::new(0, MGM_HANDLER_0.id()),
                SwitchRequest::new(0, SwitchStateBinary::On),
            ))
            .expect("failed to send switch request");
--- a/satrs-example/src/events.rs
+++ b/satrs-example/src/events.rs
@@ -16,7 +16,7 @@ use satrs::{
    },
    spacepackets::time::cds::CdsTime,
 };
-use satrs_example::ids::generic_pus::PUS_EVENT_MANAGEMENT;
+use satrs_example::config::pus::PUS_EVENT_MANAGEMENT;

 use crate::update_time;

--- a/satrs-example/src/ids.rs
+++ b/satrs-example/src/ids.rs
@@ -1,94 +0,0 @@
-//! This is an auto-generated configuration module.
-use satrs::request::UniqueApidTargetId;
-
-#[derive(Debug, Copy, Clone, PartialEq, Eq, strum::EnumIter)]
-pub enum Apid {
-    Sched = 1,
-    GenericPus = 2,
-    Acs = 3,
-    Cfdp = 4,
-    Tmtc = 5,
-    Eps = 6,
-}
-
-pub mod acs {
-    #[derive(Debug, Copy, Clone, PartialEq, Eq)]
-    pub enum Id {
-        Subsystem = 1,
-        MgmAssembly = 2,
-        Mgm0 = 3,
-        Mgm1 = 4,
-    }
-
-    pub const SUBSYSTEM: super::UniqueApidTargetId =
-        super::UniqueApidTargetId::new(super::Apid::Acs as u16, Id::Subsystem as u32);
-    pub const MGM_ASSEMBLY: super::UniqueApidTargetId =
-        super::UniqueApidTargetId::new(super::Apid::Acs as u16, Id::MgmAssembly as u32);
-    pub const MGM0: super::UniqueApidTargetId =
-        super::UniqueApidTargetId::new(super::Apid::Acs as u16, Id::Mgm0 as u32);
-    pub const MGM1: super::UniqueApidTargetId =
-        super::UniqueApidTargetId::new(super::Apid::Acs as u16, Id::Mgm1 as u32);
-}
-
-pub mod eps {
-    #[derive(Debug, Copy, Clone, PartialEq, Eq)]
-    pub enum Id {
-        Pcdu = 0,
-        Subsystem = 1,
-    }
-
-    pub const PCDU: super::UniqueApidTargetId =
-        super::UniqueApidTargetId::new(super::Apid::Eps as u16, Id::Pcdu as u32);
-    pub const SUBSYSTEM: super::UniqueApidTargetId =
-        super::UniqueApidTargetId::new(super::Apid::Eps as u16, Id::Subsystem as u32);
-}
-
-pub mod generic_pus {
-    #[derive(Debug, Copy, Clone, PartialEq, Eq)]
-    pub enum Id {
-        PusEventManagement = 0,
-        PusRouting = 1,
-        PusTest = 2,
-        PusAction = 3,
-        PusMode = 4,
-        PusHk = 5,
-    }
-
-    pub const PUS_EVENT_MANAGEMENT: super::UniqueApidTargetId = super::UniqueApidTargetId::new(
-        super::Apid::GenericPus as u16,
-        Id::PusEventManagement as u32,
-    );
-    pub const PUS_ROUTING: super::UniqueApidTargetId =
-        super::UniqueApidTargetId::new(super::Apid::GenericPus as u16, Id::PusRouting as u32);
-    pub const PUS_TEST: super::UniqueApidTargetId =
-        super::UniqueApidTargetId::new(super::Apid::GenericPus as u16, Id::PusTest as u32);
-    pub const PUS_ACTION: super::UniqueApidTargetId =
-        super::UniqueApidTargetId::new(super::Apid::GenericPus as u16, Id::PusAction as u32);
-    pub const PUS_MODE: super::UniqueApidTargetId =
-        super::UniqueApidTargetId::new(super::Apid::GenericPus as u16, Id::PusMode as u32);
-    pub const PUS_HK: super::UniqueApidTargetId =
-        super::UniqueApidTargetId::new(super::Apid::GenericPus as u16, Id::PusHk as u32);
-}
-
-pub mod sched {
-    #[derive(Debug, Copy, Clone, PartialEq, Eq)]
-    pub enum Id {
-        PusSched = 0,
-    }
-
-    pub const PUS_SCHED: super::UniqueApidTargetId =
-        super::UniqueApidTargetId::new(super::Apid::Sched as u16, Id::PusSched as u32);
-}
-
-pub mod tmtc {
-    #[derive(Debug, Copy, Clone, PartialEq, Eq)]
-    pub enum Id {
-        UdpServer = 0,
-        TcpServer = 1,
-    }
-
-    pub const UDP_SERVER: super::UniqueApidTargetId =
-        super::UniqueApidTargetId::new(super::Apid::Tmtc as u16, Id::UdpServer as u32);
-    pub const TCP_SERVER: super::UniqueApidTargetId =
-        super::UniqueApidTargetId::new(super::Apid::Tmtc as u16, Id::TcpServer as u32);
-}
--- a/satrs-example/src/interface/udp.rs
+++ b/satrs-example/src/interface/udp.rs
@@ -119,8 +119,7 @@ mod tests {
        },
        ComponentId,
    };
-    use satrs_example::config::OBSW_SERVER_ADDR;
-    use satrs_example::ids;
+    use satrs_example::config::{components, OBSW_SERVER_ADDR};

    use crate::tmtc::sender::{MockSender, TmTcSender};

@@ -176,7 +175,7 @@ mod tests {
            udp_tc_server,
            tm_handler,
        };
-        let sph = SpHeader::new_for_unseg_tc(ids::Apid::GenericPus as u16, 0, 0);
+        let sph = SpHeader::new_for_unseg_tc(components::Apid::GenericPus as u16, 0, 0);
        let ping_tc = PusTcCreator::new_simple(sph, 17, 1, &[], true)
            .to_vec()
            .unwrap();
--- a/satrs-example/src/lib.rs
+++ b/satrs-example/src/lib.rs
@@ -1,7 +1,6 @@
 use satrs::spacepackets::time::{cds::CdsTime, TimeWriter};

 pub mod config;
-pub mod ids;

 #[derive(Debug, PartialEq, Eq, Copy, Clone)]
 pub enum DeviceMode {
--- a/satrs-example/src/main.rs
+++ b/satrs-example/src/main.rs
@@ -5,10 +5,7 @@ use std::{
    time::Duration,
 };

-use acs::{
-    assembly::MgmAssembly,
-    mgm::{MgmHandlerLis3Mdl, SpiDummyInterface, SpiSimInterface, SpiSimInterfaceWrapper},
-};
+use acs::mgm::{MgmHandlerLis3Mdl, SpiDummyInterface, SpiSimInterface, SpiSimInterfaceWrapper};
 use eps::{
    pcdu::{PcduHandler, SerialInterfaceDummy, SerialInterfaceToSim, SerialSimInterfaceWrapper},
    PowerSwitchHelper,
@@ -34,10 +31,7 @@ use pus::{
 use requests::GenericRequestRouter;
 use satrs::{
    hal::std::{tcp_server::ServerConfig, udp_server::UdpTcServer},
-    mode::{
-        Mode, ModeAndSubmode, ModeRequest, ModeRequestHandlerMpscBounded,
-        ModeRequestorAndHandlerMpscBounded,
-    },
+    mode::{Mode, ModeAndSubmode, ModeRequest, ModeRequestHandlerMpscBounded},
    mode_tree::connect_mode_nodes,
    pus::{event_man::EventRequestWithToken, EcssTcInMemConverter, HandlingStatus},
    request::{GenericMessage, MessageMetadata},
@@ -45,16 +39,12 @@ use satrs::{
 };
 use satrs_example::{
    config::{
-        components::NO_SENDER,
+        acs::{MGM_HANDLER_0, MGM_HANDLER_1},
+        components::{NO_SENDER, PCDU_HANDLER, TCP_SERVER, UDP_SERVER},
        pool::create_sched_tc_pool,
        tasks::{FREQ_MS_AOCS, FREQ_MS_PUS_STACK, FREQ_MS_UDP_TMTC, SIM_CLIENT_IDLE_DELAY_MS},
        OBSW_SERVER_ADDR, PACKET_ID_VALIDATOR, SERVER_PORT,
    },
-    ids::{
-        acs::*,
-        eps::*,
-        tmtc::{TCP_SERVER, UDP_SERVER},
-    },
    DeviceMode,
 };
 use tmtc::sender::TmTcSender;
@@ -134,13 +124,13 @@ fn main() {
    let mut request_map = GenericRequestRouter::default();
    request_map
        .composite_router_map
-        .insert(MGM0.id(), mgm_0_handler_composite_tx);
+        .insert(MGM_HANDLER_0.id(), mgm_0_handler_composite_tx);
    request_map
        .composite_router_map
-        .insert(MGM1.id(), mgm_1_handler_composite_tx);
+        .insert(MGM_HANDLER_0.id(), mgm_1_handler_composite_tx);
    request_map
        .composite_router_map
-        .insert(PCDU.id(), pcdu_handler_composite_tx);
+        .insert(PCDU_HANDLER.id(), pcdu_handler_composite_tx);

    // This helper structure is used by all telecommand providers which need to send telecommands
    // to the TC source.
@@ -309,19 +299,12 @@ fn main() {
    let (switch_request_tx, switch_request_rx) = mpsc::sync_channel(20);
    let switch_helper = PowerSwitchHelper::new(switch_request_tx, shared_switch_set.clone());

-    let (mgm_assy_mode_req_tx, mgm_assy_mode_req_rx) = mpsc::sync_channel(20);
-    let (mgm_assy_mode_reply_tx, mgm_assy_mode_reply_rx) = mpsc::sync_channel(20);
-    let mgm_assembly_mode_node = ModeRequestorAndHandlerMpscBounded::new(
-        MgmAssembly::id(),
-        mgm_assy_mode_req_rx,
-        mgm_assy_mode_reply_rx,
-    );
-    let mut mgm_assembly = MgmAssembly::new(mgm_assembly_mode_node);
-
    let shared_mgm_0_set = Arc::default();
    let shared_mgm_1_set = Arc::default();
-    let mgm_0_mode_node = ModeRequestHandlerMpscBounded::new(MGM0.into(), mgm_0_handler_mode_rx);
-    let mgm_1_mode_node = ModeRequestHandlerMpscBounded::new(MGM1.into(), mgm_1_handler_mode_rx);
+    let mgm_0_mode_node =
+        ModeRequestHandlerMpscBounded::new(MGM_HANDLER_0.into(), mgm_0_handler_mode_rx);
+    let mgm_1_mode_node =
+        ModeRequestHandlerMpscBounded::new(MGM_HANDLER_1.into(), mgm_1_handler_mode_rx);
    let (mgm_0_spi_interface, mgm_1_spi_interface) =
        if let Some(sim_client) = opt_sim_client.as_mut() {
            sim_client
@@ -345,7 +328,7 @@ fn main() {
            )
        };
    let mut mgm_0_handler = MgmHandlerLis3Mdl::new(
-        MGM0,
+        MGM_HANDLER_0,
        "MGM_0",
        mgm_0_mode_node,
        mgm_0_handler_composite_rx,
@@ -356,7 +339,7 @@ fn main() {
        shared_mgm_0_set,
    );
    let mut mgm_1_handler = MgmHandlerLis3Mdl::new(
-        MGM1,
+        MGM_HANDLER_1,
        "MGM_1",
        mgm_1_mode_node,
        mgm_1_handler_composite_rx,
@@ -379,19 +362,6 @@ fn main() {
        &mut mgm_1_handler,
        pus_mode_reply_tx.clone(),
    );
-    // Connect assembly to device handlers.
-    connect_mode_nodes(
-        &mut mgm_assembly,
-        mgm_assy_mode_req_tx.clone(),
-        &mut mgm_1_handler,
-        mgm_assy_mode_reply_tx.clone(),
-    );
-    connect_mode_nodes(
-        &mut mgm_assembly,
-        mgm_assy_mode_req_tx,
-        &mut mgm_1_handler,
-        mgm_assy_mode_reply_tx,
-    );

    let pcdu_serial_interface = if let Some(sim_client) = opt_sim_client.as_mut() {
        sim_client.add_reply_recipient(satrs_minisim::SimComponent::Pcdu, pcdu_sim_reply_tx);
@@ -402,9 +372,10 @@ fn main() {
    } else {
        SerialSimInterfaceWrapper::Dummy(SerialInterfaceDummy::default())
    };
-    let pcdu_mode_node = ModeRequestHandlerMpscBounded::new(PCDU.into(), pcdu_handler_mode_rx);
+    let pcdu_mode_node =
+        ModeRequestHandlerMpscBounded::new(PCDU_HANDLER.into(), pcdu_handler_mode_rx);
    let mut pcdu_handler = PcduHandler::new(
-        PCDU,
+        PCDU_HANDLER,
        "PCDU",
        pcdu_mode_node,
        pcdu_handler_composite_rx,
@@ -483,7 +454,6 @@ fn main() {
    let jh_aocs = thread::Builder::new()
        .name("sat-rs aocs".to_string())
        .spawn(move || loop {
-            mgm_assembly.periodic_operation();
            mgm_0_handler.periodic_operation();
            mgm_1_handler.periodic_operation();
            thread::sleep(Duration::from_millis(FREQ_MS_AOCS));
--- a/satrs-example/src/pus/action.rs
+++ b/satrs-example/src/pus/action.rs
@@ -16,9 +16,8 @@ use satrs::pus::{
 use satrs::request::{GenericMessage, UniqueApidTargetId};
 use satrs::spacepackets::ecss::tc::PusTcReader;
 use satrs::spacepackets::ecss::{EcssEnumU16, PusPacket, PusServiceId};
+use satrs_example::config::pus::PUS_ACTION_SERVICE;
 use satrs_example::config::tmtc_err;
-use satrs_example::ids;
-use satrs_example::ids::generic_pus::PUS_ACTION;
 use std::sync::mpsc;
 use std::time::Duration;

@@ -215,10 +214,10 @@ pub fn create_action_service(
 ) -> ActionServiceWrapper {
    let action_request_handler = PusTargetedRequestService::new(
        PusServiceHelper::new(
-            ids::generic_pus::PUS_ACTION.id(),
+            PUS_ACTION_SERVICE.id(),
            pus_action_rx,
            tm_sender,
-            create_verification_reporter(PUS_ACTION.id(), PUS_ACTION.apid),
+            create_verification_reporter(PUS_ACTION_SERVICE.id(), PUS_ACTION_SERVICE.apid),
            tc_in_mem_converter,
        ),
        ActionRequestConverter::default(),
--- a/satrs-example/src/pus/event.rs
+++ b/satrs-example/src/pus/event.rs
@@ -10,7 +10,7 @@ use satrs::pus::{
    PartialPusHandlingError, PusServiceHelper,
 };
 use satrs::spacepackets::ecss::PusServiceId;
-use satrs_example::ids::generic_pus::PUS_EVENT_MANAGEMENT;
+use satrs_example::config::pus::PUS_EVENT_MANAGEMENT;

 use super::{DirectPusService, HandlingStatus};

--- a/satrs-example/src/pus/hk.rs
+++ b/satrs-example/src/pus/hk.rs
@@ -13,8 +13,8 @@ use satrs::request::{GenericMessage, UniqueApidTargetId};
 use satrs::res_code::ResultU16;
 use satrs::spacepackets::ecss::tc::PusTcReader;
 use satrs::spacepackets::ecss::{hk, PusPacket, PusServiceId};
+use satrs_example::config::pus::PUS_HK_SERVICE;
 use satrs_example::config::{hk_err, tmtc_err};
-use satrs_example::ids::generic_pus::PUS_HK;
 use std::sync::mpsc;
 use std::time::Duration;

@@ -249,10 +249,10 @@ pub fn create_hk_service(
 ) -> HkServiceWrapper {
    let pus_3_handler = PusTargetedRequestService::new(
        PusServiceHelper::new(
-            PUS_HK.id(),
+            PUS_HK_SERVICE.id(),
            pus_hk_rx,
            tm_sender,
-            create_verification_reporter(PUS_HK.id(), PUS_HK.apid),
+            create_verification_reporter(PUS_HK_SERVICE.id(), PUS_HK_SERVICE.apid),
            tc_in_mem_converter,
        ),
        HkRequestConverter::default(),
--- a/satrs-example/src/pus/mod.rs
+++ b/satrs-example/src/pus/mod.rs
@@ -18,8 +18,8 @@ use satrs::spacepackets::ecss::tc::PusTcReader;
 use satrs::spacepackets::ecss::{PusPacket, PusServiceId};
 use satrs::tmtc::{PacketAsVec, PacketInPool};
 use satrs::ComponentId;
+use satrs_example::config::pus::PUS_ROUTING_SERVICE;
 use satrs_example::config::{tmtc_err, CustomPusServiceId};
-use satrs_example::ids::generic_pus::PUS_ROUTING;
 use satrs_example::TimestampHelper;
 use std::fmt::Debug;
 use std::sync::mpsc;
@@ -62,9 +62,12 @@ pub struct PusTcDistributor {
 impl PusTcDistributor {
    pub fn new(tm_sender: TmTcSender, pus_router: PusTcMpscRouter) -> Self {
        Self {
-            id: PUS_ROUTING.raw(),
+            id: PUS_ROUTING_SERVICE.raw(),
            tm_sender,
-            verif_reporter: create_verification_reporter(PUS_ROUTING.id(), PUS_ROUTING.apid),
+            verif_reporter: create_verification_reporter(
+                PUS_ROUTING_SERVICE.id(),
+                PUS_ROUTING_SERVICE.apid,
+            ),
            pus_router,
            stamp_helper: TimestampHelper::default(),
        }
--- a/satrs-example/src/pus/mode.rs
+++ b/satrs-example/src/pus/mode.rs
@@ -1,6 +1,6 @@
 use derive_new::new;
 use satrs::mode_tree::{ModeNode, ModeParent};
-use satrs_example::ids;
+use satrs_example::config::pus::PUS_MODE_SERVICE;
 use std::sync::mpsc;
 use std::time::Duration;

@@ -217,18 +217,15 @@ pub fn create_mode_service(
 ) -> ModeServiceWrapper {
    let mode_request_handler = PusTargetedRequestService::new(
        PusServiceHelper::new(
-            ids::generic_pus::PUS_MODE.id(),
+            PUS_MODE_SERVICE.id(),
            pus_action_rx,
            tm_sender,
-            create_verification_reporter(
-                ids::generic_pus::PUS_MODE.id(),
-                ids::generic_pus::PUS_MODE.apid,
-            ),
+            create_verification_reporter(PUS_MODE_SERVICE.id(), PUS_MODE_SERVICE.apid),
            tc_in_mem_converter,
        ),
        ModeRequestConverter::default(),
        DefaultActiveRequestMap::default(),
-        ModeReplyHandler::new(ids::generic_pus::PUS_MODE.id()),
+        ModeReplyHandler::new(PUS_MODE_SERVICE.id()),
        mode_router,
        reply_receiver,
    );
--- a/satrs-example/src/pus/scheduler.rs
+++ b/satrs-example/src/pus/scheduler.rs
@@ -15,7 +15,7 @@ use satrs::pus::{
 use satrs::spacepackets::ecss::PusServiceId;
 use satrs::tmtc::{PacketAsVec, PacketInPool, PacketSenderWithSharedPool};
 use satrs::ComponentId;
-use satrs_example::ids::sched::PUS_SCHED;
+use satrs_example::config::pus::PUS_SCHED_SERVICE;

 use super::{DirectPusService, HandlingStatus};

@@ -183,10 +183,10 @@ pub fn create_scheduler_service(
        .expect("Creating PUS Scheduler failed");
    let pus_11_handler = PusSchedServiceHandler::new(
        PusServiceHelper::new(
-            PUS_SCHED.id(),
+            PUS_SCHED_SERVICE.id(),
            pus_sched_rx,
            tm_sender,
-            create_verification_reporter(PUS_SCHED.id(), PUS_SCHED.apid),
+            create_verification_reporter(PUS_SCHED_SERVICE.id(), PUS_SCHED_SERVICE.apid),
            tc_in_mem_converter,
        ),
        scheduler,
--- a/satrs-example/src/pus/test.rs
+++ b/satrs-example/src/pus/test.rs
@@ -11,8 +11,8 @@ use satrs::pus::{
 };
 use satrs::spacepackets::ecss::tc::PusTcReader;
 use satrs::spacepackets::ecss::{PusPacket, PusServiceId};
+use satrs_example::config::pus::PUS_TEST_SERVICE;
 use satrs_example::config::{tmtc_err, TEST_EVENT};
-use satrs_example::ids::generic_pus::PUS_TEST;
 use std::sync::mpsc;

 use super::{DirectPusService, HandlingStatus};
@@ -24,10 +24,10 @@ pub fn create_test_service(
    pus_test_rx: mpsc::Receiver<EcssTcAndToken>,
 ) -> TestCustomServiceWrapper {
    let pus17_handler = PusService17TestHandler::new(PusServiceHelper::new(
-        PUS_TEST.id(),
+        PUS_TEST_SERVICE.id(),
        pus_test_rx,
        tm_sender,
-        create_verification_reporter(PUS_TEST.id(), PUS_TEST.apid),
+        create_verification_reporter(PUS_TEST_SERVICE.id(), PUS_TEST_SERVICE.apid),
        tc_in_mem_converter,
    ));
    TestCustomServiceWrapper {
@@ -100,7 +100,7 @@ impl DirectPusService for TestCustomServiceWrapper {
                if subservice == 128 {
                    info!("generating test event");
                    self.event_tx
-                        .send(EventMessage::new(PUS_TEST.id(), TEST_EVENT.into()))
+                        .send(EventMessage::new(PUS_TEST_SERVICE.id(), TEST_EVENT.into()))
                        .expect("Sending test event failed");
                    match self.handler.service_helper.verif_reporter().start_success(
                        self.handler.service_helper.tm_sender(),
--- a/satrs-example/src/requests.rs
+++ b/satrs-example/src/requests.rs
@@ -14,8 +14,8 @@ use satrs::request::{GenericMessage, MessageMetadata, UniqueApidTargetId};
 use satrs::spacepackets::ecss::tc::PusTcReader;
 use satrs::spacepackets::ecss::PusPacket;
 use satrs::ComponentId;
+use satrs_example::config::pus::PUS_ROUTING_SERVICE;
 use satrs_example::config::tmtc_err;
-use satrs_example::ids;

 #[derive(Clone, Debug)]
 #[non_exhaustive]
@@ -37,7 +37,7 @@ pub struct GenericRequestRouter {
 impl Default for GenericRequestRouter {
    fn default() -> Self {
        Self {
-            id: ids::generic_pus::PUS_ROUTING.raw(),
+            id: PUS_ROUTING_SERVICE.raw(),
            composite_router_map: Default::default(),
            mode_router_map: Default::default(),
        }
--- a/satrs-example/src/tmtc/tc_source.rs
+++ b/satrs-example/src/tmtc/tc_source.rs
@@ -11,9 +11,7 @@ use crate::pus::PusTcDistributor;
 pub struct TcSourceTaskStatic {
    shared_tc_pool: SharedPacketPool,
    tc_receiver: mpsc::Receiver<PacketInPool>,
-    /// We allocate this buffer from the heap to avoid a clippy warning on large enum variant
-    /// differences.
-    tc_buf: Box<[u8; 4096]>,
+    tc_buf: [u8; 4096],
    pus_distributor: PusTcDistributor,
 }

@@ -27,7 +25,7 @@ impl TcSourceTaskStatic {
        Self {
            shared_tc_pool,
            tc_receiver,
-            tc_buf: Box::new([0; 4096]),
+            tc_buf: [0; 4096],
            pus_distributor: pus_receiver,
        }
    }
@@ -46,11 +44,11 @@ impl TcSourceTaskStatic {
                    .0
                    .read()
                    .expect("locking tc pool failed");
-                pool.read(&packet_in_pool.store_addr, self.tc_buf.as_mut_slice())
+                pool.read(&packet_in_pool.store_addr, &mut self.tc_buf)
                    .expect("reading pool failed");
                drop(pool);
                self.pus_distributor
-                    .handle_tc_packet_in_store(packet_in_pool, self.tc_buf.as_slice())
+                    .handle_tc_packet_in_store(packet_in_pool, &self.tc_buf)
                    .ok();
                HandlingStatus::HandledOne
            }
--- a/satrs-mib/Cargo.toml
+++ b/satrs-mib/Cargo.toml
@@ -23,7 +23,7 @@ version = "1"
 optional = true

 [dependencies.satrs-shared]
-version = "0.2.2"
+version = ">=0.1.3, <=0.2"
 path = "../satrs-shared"
 features = ["serde"]

--- a/satrs-mib/codegen/Cargo.toml
+++ b/satrs-mib/codegen/Cargo.toml
@@ -28,8 +28,8 @@ features = ["full"]
 trybuild = { version = "1", features = ["diff"] }

 [dev-dependencies.satrs-shared]
-version = "0.2.2"
 path = "../../satrs-shared"
+version = ">=0.1.3, <=0.2"

 [dev-dependencies.satrs-mib]
 path = ".."
--- a/satrs-shared/Cargo.toml
+++ b/satrs-shared/Cargo.toml
@@ -11,7 +11,6 @@ license = "Apache-2.0"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

 [dependencies]
-spacepackets = { version = ">=0.14, <=0.15", git = "https://egit.irs.uni-stuttgart.de/rust/spacepackets.git", default-features = false }

 [dependencies.serde]
 version = "1"
@@ -22,6 +21,9 @@ optional = true
 version = "1"
 optional = true

+[dependencies.spacepackets]
+version = "0.14"
+default-features = false

 [features]
 serde = ["dep:serde", "spacepackets/serde"]
--- a/satrs/Cargo.toml
+++ b/satrs/Cargo.toml
@@ -4,8 +4,8 @@ version = "0.3.0-alpha.0"
 edition = "2021"
 rust-version = "1.82.0"
 authors = ["Robin Mueller <muellerr@irs.uni-stuttgart.de>"]
-description = "A library collection to build software for remote systems"
-homepage = "https://github.com/us-irs/sat-rs"
+description = "A framework to build software for remote systems"
+homepage = "https://absatsw.irs.uni-stuttgart.de/projects/sat-rs/"
 repository = "https://egit.irs.uni-stuttgart.de/rust/sat-rs"
 license = "Apache-2.0"
 keywords = ["no-std", "space", "aerospace"]
@@ -13,13 +13,12 @@ keywords = ["no-std", "space", "aerospace"]
 categories = ["aerospace", "aerospace::space-protocols", "no-std", "hardware-support", "embedded"]

 [dependencies]
-satrs-shared = { version = "0.2.2", path = "../satrs-shared" }
-spacepackets = { version = ">=0.14, <=0.15", git = "https://egit.irs.uni-stuttgart.de/rust/spacepackets.git", default-features = false }
-
+satrs-shared = { version = ">=0.1.3, <=0.2", path = "../satrs-shared" }
 delegate = ">0.7, <=0.13"
 paste = "1"
 derive-new = ">=0.6, <=0.7"
 num_enum = { version = ">0.5, <=0.7", default-features = false }
+spacepackets = { version = "0.14", default-features = false }
 cobs = { version = "0.4", default-features = false, git = "https://github.com/jamesmunns/cobs.rs.git", branch = "main" }
 thiserror = { version = "2", default-features = false }

--- a/satrs/README.md
+++ b/satrs/README.md
@@ -4,5 +4,5 @@
 sat-rs
 ======

-This crate contains the primary components of the sat-rs library collection.
+This crate contains the primary components of the sat-rs framework.
 You can find more information on the [homepage](https://egit.irs.uni-stuttgart.de/rust/sat-rs).
--- a/satrs/src/encoding/cobs.rs
+++ b/satrs/src/encoding/cobs.rs
@@ -24,8 +24,8 @@ use cobs::{decode_in_place, encode, max_encoding_length};
 /// assert!(encode_packet_with_cobs(&INVERTED_PACKET, &mut encoding_buf, &mut current_idx));
 /// assert_eq!(encoding_buf[0], 0);
 /// let dec_report = decode_in_place_report(&mut encoding_buf[1..]).expect("decoding failed");
-/// assert_eq!(encoding_buf[1 + dec_report.parsed_size()], 0);
-/// assert_eq!(dec_report.frame_size(), 5);
+/// assert_eq!(encoding_buf[1 + dec_report.src_used], 0);
+/// assert_eq!(dec_report.dst_used, 5);
 /// assert_eq!(current_idx, 16);
 /// ```
 pub fn encode_packet_with_cobs(
--- a/satrs/src/pus/event_srv.rs
+++ b/satrs/src/pus/event_srv.rs
@@ -199,7 +199,7 @@ mod tests {
    }

    impl PusTestHarness for Pus5HandlerWithStoreTester {
-        fn start_verification(&mut self, tc: &PusTcCreator) -> VerificationToken<TcStateAccepted> {
+        fn init_verification(&mut self, tc: &PusTcCreator) -> VerificationToken<TcStateAccepted> {
            let init_token = self
                .handler
                .service_helper
@@ -249,7 +249,7 @@ mod tests {
            .write_to_be_bytes(&mut app_data)
            .expect("writing test event failed");
        let ping_tc = PusTcCreator::new(sp_header, sec_header, &app_data, true);
-        let token = test_harness.start_verification(&ping_tc);
+        let token = test_harness.init_verification(&ping_tc);
        test_harness.send_tc(&token, &ping_tc);
        let request_id = token.request_id();
        test_harness.handle_one_tc().unwrap();
@@ -310,7 +310,7 @@ mod tests {
        let sp_header = SpHeader::new_for_unseg_tc(TEST_APID, 0, 0);
        let sec_header = PusTcSecondaryHeader::new_simple(5, 200);
        let ping_tc = PusTcCreator::new_no_app_data(sp_header, sec_header, true);
-        let token = test_harness.start_verification(&ping_tc);
+        let token = test_harness.init_verification(&ping_tc);
        test_harness.send_tc(&token, &ping_tc);
        let result = test_harness.handle_one_tc();
        assert!(result.is_ok());
@@ -330,7 +330,7 @@ mod tests {
        let sec_header =
            PusTcSecondaryHeader::new_simple(5, Subservice::TcEnableEventGeneration as u8);
        let ping_tc = PusTcCreator::new(sp_header, sec_header, &[0, 1, 2], true);
-        let token = test_harness.start_verification(&ping_tc);
+        let token = test_harness.init_verification(&ping_tc);
        test_harness.send_tc(&token, &ping_tc);
        let result = test_harness.handle_one_tc();
        assert!(result.is_err());
--- a/satrs/src/pus/mod.rs
+++ b/satrs/src/pus/mod.rs
@@ -1275,7 +1275,7 @@ pub mod test_util {
        UniqueApidTargetId::new(TEST_APID, TEST_UNIQUE_ID_1);

    pub trait PusTestHarness {
-        fn start_verification(&mut self, tc: &PusTcCreator) -> VerificationToken<TcStateAccepted>;
+        fn init_verification(&mut self, tc: &PusTcCreator) -> VerificationToken<TcStateAccepted>;
        fn send_tc(&self, token: &VerificationToken<TcStateAccepted>, tc: &PusTcCreator);
        fn read_next_tm(&mut self) -> PusTmReader<'_>;
        fn check_no_tm_available(&self) -> bool;
--- a/satrs/src/pus/scheduler_srv.rs
+++ b/satrs/src/pus/scheduler_srv.rs
@@ -309,7 +309,7 @@ mod tests {
    }

    impl PusTestHarness for Pus11HandlerWithStoreTester {
-        fn start_verification(&mut self, tc: &PusTcCreator) -> VerificationToken<TcStateAccepted> {
+        fn init_verification(&mut self, tc: &PusTcCreator) -> VerificationToken<TcStateAccepted> {
            let init_token = self
                .handler
                .service_helper
@@ -387,7 +387,7 @@ mod tests {
        let reply_header = SpHeader::new_for_unseg_tm(TEST_APID, 0, 0);
        let tc_header = PusTcSecondaryHeader::new_simple(11, subservice as u8);
        let enable_scheduling = PusTcCreator::new(reply_header, tc_header, &[0; 7], true);
-        let token = test_harness.start_verification(&enable_scheduling);
+        let token = test_harness.init_verification(&enable_scheduling);
        test_harness.send_tc(&token, &enable_scheduling);

        let request_id = token.request_id();
@@ -449,7 +449,7 @@ mod tests {
            &sched_app_data[..written_len],
            true,
        );
-        let token = test_harness.start_verification(&enable_scheduling);
+        let token = test_harness.init_verification(&enable_scheduling);
        test_harness.send_tc(&token, &enable_scheduling);

        let request_id = token.request_id();
--- a/satrs/src/pus/test.rs
+++ b/satrs/src/pus/test.rs
@@ -180,7 +180,7 @@ mod tests {
    }

    impl PusTestHarness for Pus17HandlerWithStoreTester {
-        fn start_verification(&mut self, tc: &PusTcCreator) -> VerificationToken<TcStateAccepted> {
+        fn init_verification(&mut self, tc: &PusTcCreator) -> VerificationToken<TcStateAccepted> {
            let init_token = self
                .handler
                .service_helper
@@ -242,7 +242,7 @@ mod tests {
    }

    impl PusTestHarness for Pus17HandlerWithVecTester {
-        fn start_verification(&mut self, tc: &PusTcCreator) -> VerificationToken<TcStateAccepted> {
+        fn init_verification(&mut self, tc: &PusTcCreator) -> VerificationToken<TcStateAccepted> {
            let init_token = self
                .handler
                .service_helper
@@ -287,7 +287,7 @@ mod tests {
        let sp_header = SpHeader::new_for_unseg_tc(TEST_APID, 0, 0);
        let sec_header = PusTcSecondaryHeader::new_simple(17, 1);
        let ping_tc = PusTcCreator::new_no_app_data(sp_header, sec_header, true);
-        let token = test_harness.start_verification(&ping_tc);
+        let token = test_harness.init_verification(&ping_tc);
        test_harness.send_tc(&token, &ping_tc);
        let request_id = token.request_id();
        let result = test_harness.handle_one_tc();
@@ -342,7 +342,7 @@ mod tests {
        let sp_header = SpHeader::new_for_unseg_tc(TEST_APID, 0, 0);
        let sec_header = PusTcSecondaryHeader::new_simple(3, 1);
        let ping_tc = PusTcCreator::new_no_app_data(sp_header, sec_header, true);
-        let token = test_harness.start_verification(&ping_tc);
+        let token = test_harness.init_verification(&ping_tc);
        test_harness.send_tc(&token, &ping_tc);
        let result = test_harness.handle_one_tc();
        assert!(result.is_err());
@@ -363,7 +363,7 @@ mod tests {
        let sp_header = SpHeader::new_for_unseg_tc(TEST_APID, 0, 0);
        let sec_header = PusTcSecondaryHeader::new_simple(17, 200);
        let ping_tc = PusTcCreator::new_no_app_data(sp_header, sec_header, true);
-        let token = test_harness.start_verification(&ping_tc);
+        let token = test_harness.init_verification(&ping_tc);
        test_harness.send_tc(&token, &ping_tc);
        let result = test_harness.handle_one_tc();
        assert!(result.is_ok());
--- a/satrs/src/pus/verification.rs
+++ b/satrs/src/pus/verification.rs
@@ -47,7 +47,7 @@
 //!     tc_header,
 //!     true
 //! );
-//! let init_token = reporter.start_verification(&pus_tc_0);
+//! let init_token = reporter.add_tc(&pus_tc_0);
 //!
 //! // Complete success sequence for a telecommand
 //! let accepted_token = reporter.acceptance_success(&sender, init_token, &EMPTY_STAMP).unwrap();
@@ -65,7 +65,8 @@
 //!         let store_guard = rg.read_with_guard(tm_in_store.store_addr);
 //!         tm_len = store_guard.read(&mut tm_buf).expect("Error reading TM slice");
 //!     }
-//!     let pus_tm = PusTmReader::new(&tm_buf[0..tm_len], 7).expect("Error reading verification TM");
+//!     let (pus_tm, _) = PusTmReader::new(&tm_buf[0..tm_len], 7)
+//!        .expect("Error reading verification TM");
 //!     if packet_idx == 0 {
 //!         assert_eq!(pus_tm.subservice(), 1);
 //!     } else if packet_idx == 1 {
@@ -1829,7 +1830,7 @@ pub mod tests {
            }
        }

-        pub fn start_verification(&self) -> VerificationToken<TcStateNone> {
+        pub fn init_verification(&self) -> VerificationToken<TcStateNone> {
            let tc_reader = PusTcReader::new(&self.tc).unwrap();
            self.reporter.start_verification(&tc_reader)
        }
@@ -2089,7 +2090,7 @@ pub mod tests {
    #[test]
    fn test_basic_acceptance_success() {
        let testbench = VerificationReporterTestbench::new(0, create_generic_ping(), 16);
-        let token = testbench.start_verification();
+        let token = testbench.init_verification();
        testbench
            .acceptance_success(token, &EMPTY_STAMP)
            .expect("sending acceptance success failed");
@@ -2099,7 +2100,7 @@ pub mod tests {
    #[test]
    fn test_basic_acceptance_failure() {
        let mut testbench = VerificationReporterTestbench::new(0, create_generic_ping(), 16);
-        let init_token = testbench.start_verification();
+        let init_token = testbench.init_verification();
        let timestamp = [1, 2, 3, 4, 5, 6, 7];
        let fail_code = EcssEnumU16::new(2);
        let fail_params = FailParams::new_no_fail_data(timestamp.as_slice(), &fail_code);
@@ -2112,7 +2113,7 @@ pub mod tests {
    #[test]
    fn test_basic_acceptance_failure_with_helper() {
        let mut testbench = VerificationReporterTestbench::new(0, create_generic_ping(), 16);
-        let init_token = testbench.start_verification();
+        let init_token = testbench.init_verification();
        let timestamp = [1, 2, 3, 4, 5, 6, 7];
        let fail_code = EcssEnumU16::new(2);
        let fail_params = FailParams::new_no_fail_data(timestamp.as_slice(), &fail_code);
@@ -2125,7 +2126,7 @@ pub mod tests {
    #[test]
    fn test_acceptance_fail_data_too_large() {
        let testbench = VerificationReporterTestbench::new(0, create_generic_ping(), 8);
-        let init_token = testbench.start_verification();
+        let init_token = testbench.init_verification();
        let stamp_buf = [1, 2, 3, 4, 5, 6, 7];
        let fail_code = EcssEnumU16::new(2);
        let fail_data: [u8; 16] = [0; 16];
@@ -2162,7 +2163,7 @@ pub mod tests {
        let mut fail_data_raw = [0; 4];
        fail_data.write_to_be_bytes(&mut fail_data_raw).unwrap();
        let fail_params = FailParams::new(&EMPTY_STAMP, &fail_code, fail_data_raw.as_slice());
-        let init_token = testbench.start_verification();
+        let init_token = testbench.init_verification();
        testbench
            .acceptance_failure(init_token, fail_params)
            .expect("sending acceptance failure failed");
@@ -2180,7 +2181,7 @@ pub mod tests {
    #[test]
    fn test_start_failure() {
        let mut testbench = VerificationReporterTestbench::new(0, create_generic_ping(), 16);
-        let init_token = testbench.start_verification();
+        let init_token = testbench.init_verification();
        let fail_code = EcssEnumU8::new(22);
        let fail_data: i32 = -12;
        let mut fail_data_raw = [0; 4];
@@ -2199,7 +2200,7 @@ pub mod tests {
    #[test]
    fn test_start_failure_with_helper() {
        let mut testbench = VerificationReporterTestbench::new(0, create_generic_ping(), 16);
-        let token = testbench.start_verification();
+        let token = testbench.init_verification();
        let fail_code = EcssEnumU8::new(22);
        let fail_data: i32 = -12;
        let mut fail_data_raw = [0; 4];
@@ -2218,7 +2219,7 @@ pub mod tests {
    #[test]
    fn test_steps_success() {
        let mut testbench = VerificationReporterTestbench::new(0, create_generic_ping(), 16);
-        let token = testbench.start_verification();
+        let token = testbench.init_verification();
        let accepted_token = testbench
            .acceptance_success(token, &EMPTY_STAMP)
            .expect("acceptance  failed");
@@ -2241,7 +2242,7 @@ pub mod tests {
    #[test]
    fn test_step_failure() {
        let mut testbench = VerificationReporterTestbench::new(0, create_generic_ping(), 16);
-        let token = testbench.start_verification();
+        let token = testbench.init_verification();
        let fail_code = EcssEnumU32::new(0x1020);
        let fail_data: f32 = -22.3232;
        let mut fail_data_raw = [0; 4];
@@ -2275,7 +2276,7 @@ pub mod tests {
    #[test]
    fn test_completion_failure() {
        let mut testbench = VerificationReporterTestbench::new(0, create_generic_ping(), 16);
-        let token = testbench.start_verification();
+        let token = testbench.init_verification();
        let fail_code = EcssEnumU32::new(0x1020);
        let fail_params = FailParams::new_no_fail_data(&EMPTY_STAMP, &fail_code);

@@ -2298,7 +2299,7 @@ pub mod tests {
    fn test_complete_success_sequence() {
        let mut testbench =
            VerificationReporterTestbench::new(TEST_COMPONENT_ID_0.id(), create_generic_ping(), 16);
-        let token = testbench.start_verification();
+        let token = testbench.init_verification();
        let accepted_token = testbench
            .acceptance_success(token, &EMPTY_STAMP)
            .expect("Sending acceptance success failed");
@@ -2320,7 +2321,7 @@ pub mod tests {
            create_generic_ping(),
            SequenceCounterHook::default(),
        );
-        let token = testbench.start_verification();
+        let token = testbench.init_verification();
        let accepted_token = testbench
            .acceptance_success(token, &EMPTY_STAMP)
            .expect("Sending acceptance success failed");
@@ -2338,7 +2339,7 @@ pub mod tests {
    #[test]
    fn test_completion_failure_helper_string_param() {
        let mut testbench = VerificationReporterTestbench::new(0, create_generic_ping(), 32);
-        let token = testbench.start_verification();
+        let token = testbench.init_verification();
        let accepted_token = testbench
            .acceptance_success(token, &EMPTY_STAMP)
            .expect("Sending acceptance success failed");
@@ -2365,7 +2366,7 @@ pub mod tests {
    #[test]
    fn test_step_failure_helper_string_param() {
        let mut testbench = VerificationReporterTestbench::new(0, create_generic_ping(), 32);
-        let token = testbench.start_verification();
+        let token = testbench.init_verification();
        let accepted_token = testbench
            .acceptance_success(token, &EMPTY_STAMP)
            .expect("Sending acceptance success failed");
--- a/satrs/src/request.rs
+++ b/satrs/src/request.rs
@@ -39,7 +39,7 @@ impl UniqueApidTargetId {
        }
    }

-    pub const fn raw(&self) -> ComponentId {
+    pub fn raw(&self) -> ComponentId {
        ((self.apid as u64) << 32) | (self.unique_id as u64)
    }

--- a/satrs/src/subsystem.rs
+++ b/satrs/src/subsystem.rs
@@ -597,7 +597,7 @@ impl SubsystemCommandingHelper {
    }

    fn update_internal_req_id(&mut self) {
-        let new_internal_req_id = (self.request_id().unwrap() << 8)
+        let new_internal_req_id = self.request_id().unwrap() << 8
            | self.seq_exec_helper.current_sequence_index().unwrap() as u32;
        self.seq_exec_helper.set_request_id(new_internal_req_id);
        self.active_internal_request_id = Some(new_internal_req_id);
Author	SHA1	Message	Date
Robin Mueller	a710d7a9f8	clippy fixes, dep updates	2025-05-10 16:05:03 +02:00
Robin Mueller	e2b49d4573	dependency hell	2025-05-07 13:25:09 +02:00
Robin Mueller	d96d9b0aff	some more fixes, git updates	2025-05-07 13:23:43 +02:00
Robin Mueller	f7242de683	start fixing examples etc.	2025-05-07 09:56:43 +02:00
Robin Mueller	240868d1ce	remove some methods	2025-05-06 16:19:36 +02:00
Robin Mueller	a650773566	tweaks for msp430	2025-05-05 19:18:03 +02:00