I don't think channel IDs are required anymore

satrs-example/src/acs/mgm.rs

@@ -0,0 +1,74 @@
+use std::sync::mpsc::{self};
+use std::sync::{Arc, Mutex};
+
+use satrs::mode::{ModeAndSubmode, ModeProvider, ModeReply, ModeRequest, ModeRequestHandler};
+use satrs::pus::EcssTmSenderCore;
+use satrs::request::GenericMessage;
+use satrs::ComponentId;
+
+use crate::pus::hk::HkReply;
+use crate::requests::RequestWithToken;
+
+pub trait SpiInterface {
+    type Error;
+    fn transfer(&mut self, data: &mut [u8]) -> Result<(), Self::Error>;
+}
+
+#[derive(Debug, Copy, Clone)]
+pub struct MgmData {
+    pub x: f32,
+    pub y: f32,
+    pub z: f32,
+}
+
+pub struct MgmHandler<ComInterface: SpiInterface, TmSender: EcssTmSenderCore> {
+    id: ComponentId,
+    dev_str: &'static str,
+    mode_request_receiver: mpsc::Receiver<GenericMessage<ModeRequest>>,
+    mode_reply_sender_to_pus: mpsc::Sender<GenericMessage<ModeReply>>,
+    mode_reply_sender_to_parent: mpsc::Sender<GenericMessage<ModeReply>>,
+    composite_request_receiver: mpsc::Receiver<RequestWithToken>,
+    hk_reply_sender: mpsc::Sender<GenericMessage<HkReply>>,
+    hk_tm_sender: TmSender,
+    mode: ModeAndSubmode,
+    spi_interface: ComInterface,
+    shared_mgm_set: Arc<Mutex<MgmData>>,
+}
+
+impl<ComInterface: SpiInterface, TmSender: EcssTmSenderCore> MgmHandler<ComInterface, TmSender> {
+    pub fn perform_operation(&mut self) {}
+}
+
+impl<ComInterface: SpiInterface, TmSender: EcssTmSenderCore> ModeProvider
+    for MgmHandler<ComInterface, TmSender>
+{
+    fn mode_and_submode(&self) -> ModeAndSubmode {
+        self.mode
+    }
+}
+
+impl<ComInterface: SpiInterface, TmSender: EcssTmSenderCore> ModeRequestHandler
+    for MgmHandler<ComInterface, TmSender>
+{
+    fn start_transition(
+        &mut self,
+        request_id: satrs::request::RequestId,
+        sender_id: ComponentId,
+        mode_and_submode: ModeAndSubmode,
+    ) -> Result<(), satrs::mode::ModeError> {
+        todo!()
+    }
+
+    fn announce_mode(
+        &self,
+        request_id: satrs::request::RequestId,
+        sender_id: satrs::ComponentId,
+        recursive: bool,
+    ) {
+        log::info!("{} announcing mode: {:?}", self.dev_str, self.mode);
+    }
+
+    fn handle_mode_reached(&mut self) -> Result<(), satrs::queue::GenericTargetedMessagingError> {
+        todo!()
+    }
+}

satrs-example/src/acs/mod.rs

@@ -1,26 +1,6 @@
-use std::sync::mpsc::{self, TryRecvError};
+mod mgm;
-
-use log::{info, warn};
-use satrs::pus::verification::VerificationReportingProvider;
-use satrs::pus::{EcssTmSender, PusTmWrapper};
-use satrs::request::TargetAndApidId;
-use satrs::spacepackets::ecss::hk::Subservice as HkSubservice;
-use satrs::{
-    hk::HkRequest,
-    spacepackets::{
-        ecss::tm::{PusTmCreator, PusTmSecondaryHeader},
-        time::cds::{DaysLen16Bits, TimeProvider},
-        SequenceFlags, SpHeader,
-    },
-};
-use satrs_example::config::{RequestTargetId, PUS_APID};
-
-use crate::{
-    hk::{AcsHkIds, HkUniqueId},
-    requests::{Request, RequestWithToken},
-    update_time,
-};
 
+/*
 pub struct AcsTask<VerificationReporter: VerificationReportingProvider> {
     timestamp: [u8; 7],
     time_provider: TimeProvider<DaysLen16Bits>,
@@ -112,3 +92,4 @@ impl<VerificationReporter: VerificationReportingProvider> AcsTask<VerificationRe
         }
     }
 }
+*/

satrs-example/src/config.rs

@@ -94,27 +94,16 @@ pub mod hk_err {
     ];
 }
 
-#[allow(clippy::enum_variant_names)]
 #[derive(Copy, Clone, PartialEq, Eq)]
-pub enum TmSenderId {
+pub enum ComponentIdList {
     PusVerification = 0,
-    PusTest = 1,
+    EventManagement = 1,
-    PusEvent = 2,
+    PusTest = 2,
-    PusHk = 3,
+    PusAction = 3,
-    PusAction = 4,
+    PusSched = 4,
-    PusSched = 5,
+    PusHk = 5,
-    AllEvents = 6,
-    AcsSubsystem = 7,
 }
 
-#[derive(Copy, Clone, PartialEq, Eq)]
-pub enum TcReceiverId {
-    PusTest = 1,
-    PusEvent = 2,
-    PusHk = 3,
-    PusAction = 4,
-    PusSched = 5,
-}
 pub mod pool {
     use super::*;
     pub fn create_static_pools() -> (StaticMemoryPool, StaticMemoryPool) {

satrs-example/src/events.rs

@@ -14,9 +14,9 @@ use satrs::{
         verification::{TcStateStarted, VerificationReportingProvider, VerificationToken},
         EcssTmSender,
     },
-    spacepackets::time::cds::{self, TimeProvider},
+    spacepackets::time::cds::{self, TimeProvider}, ComponentId,
 };
-use satrs_example::config::PUS_APID;
+use satrs_example::config::{PUS_APID, ComponentIdList};
 
 use crate::update_time;
 
@@ -48,9 +48,9 @@ impl<VerificationReporter: VerificationReportingProvider> PusEventHandler<Verifi
         let pus_event_dispatcher =
             DefaultPusEventU32Dispatcher::new_with_default_backend(event_reporter);
         let pus_event_man_send_provider =
-            EventU32SenderMpscBounded::new(1, pus_event_man_tx, event_queue_cap);
+            EventU32SenderMpscBounded::new(ComponentIdList::EventManagement as ComponentId, pus_event_man_tx, event_queue_cap);
 
-        event_manager.subscribe_all(pus_event_man_send_provider.channel_id());
+        event_manager.subscribe_all(pus_event_man_send_provider.target_id());
         event_manager.add_sender(pus_event_man_send_provider);
 
         Self {

satrs-example/src/main.rs

@@ -23,11 +23,13 @@ use satrs_example::config::pool::{create_sched_tc_pool, create_static_pools};
 use satrs_example::config::tasks::{
     FREQ_MS_AOCS, FREQ_MS_EVENT_HANDLING, FREQ_MS_PUS_STACK, FREQ_MS_UDP_TMTC,
 };
-use satrs_example::config::{RequestTargetId, TmSenderId, OBSW_SERVER_ADDR, PUS_APID, SERVER_PORT};
+use satrs_example::config::{
+    ComponentIdList, RequestTargetId, OBSW_SERVER_ADDR, PUS_APID, SERVER_PORT,
+};
 use tmtc::PusTcSourceProviderDynamic;
 use udp::DynamicUdpTmHandler;
 
-use crate::acs::AcsTask;
+// use crate::acs::AcsTask;
 use crate::ccsds::CcsdsReceiver;
 use crate::logger::setup_logger;
 use crate::pus::action::{create_action_service_dynamic, create_action_service_static};
@@ -47,7 +49,7 @@ use satrs::pus::verification::{VerificationReporterCfg, VerificationReporterWith
 use satrs::pus::{EcssTmSender, TmAsVecSenderWithId, TmInSharedPoolSenderWithId};
 use satrs::spacepackets::{time::cds::TimeProvider, time::TimeWriter};
 use satrs::tmtc::CcsdsDistributor;
-use satrs::ChannelId;
+use satrs::ComponentId;
 use std::net::{IpAddr, SocketAddr};
 use std::sync::mpsc::{self, channel};
 use std::sync::{Arc, RwLock};
@@ -77,7 +79,7 @@ fn static_tmtc_pool_main() {
     // Every software component which needs to generate verification telemetry, receives a cloned
     // verification reporter.
     let verif_reporter = create_verification_reporter(TmInSharedPoolSenderWithId::new(
-        TmSenderId::PusVerification as ChannelId,
+        ComponentIdList::PusVerification as ComponentId,
         "verif_sender",
         shared_tm_pool.clone(),
         tm_funnel_tx.clone(),
@@ -105,7 +107,7 @@ fn static_tmtc_pool_main() {
     // in the sat-rs documentation.
     let mut event_handler = EventHandler::new(
         TmInSharedPoolSenderWithId::new(
-            TmSenderId::AllEvents as ChannelId,
+            ComponentIdList::EventManagement as ComponentId,
             "ALL_EVENTS_TX",
             shared_tm_pool.clone(),
             tm_funnel_tx.clone(),
@@ -209,6 +211,7 @@ fn static_tmtc_pool_main() {
     )
     .expect("tcp server creation failed");
 
+    /*
     let mut acs_task = AcsTask::new(
         TmInSharedPoolSenderWithId::new(
             TmSenderId::AcsSubsystem as ChannelId,
@@ -219,6 +222,7 @@ fn static_tmtc_pool_main() {
         acs_thread_rx,
         verif_reporter,
     );
+    */
 
     let mut tm_funnel = TmFunnelStatic::new(
         shared_tm_pool,
@@ -272,7 +276,7 @@ fn static_tmtc_pool_main() {
     let jh_aocs = thread::Builder::new()
         .name("AOCS".to_string())
         .spawn(move || loop {
-            acs_task.periodic_operation();
+            // acs_task.periodic_operation();
             thread::sleep(Duration::from_millis(FREQ_MS_AOCS));
         })
         .unwrap();
@@ -312,7 +316,7 @@ fn dyn_tmtc_pool_main() {
     // Every software component which needs to generate verification telemetry, gets a cloned
     // verification reporter.
     let verif_reporter = create_verification_reporter(TmAsVecSenderWithId::new(
-        TmSenderId::PusVerification as ChannelId,
+        ComponentIdList::PusVerification as ComponentId,
         "verif_sender",
         tm_funnel_tx.clone(),
     ));
@@ -333,7 +337,7 @@ fn dyn_tmtc_pool_main() {
     // in the sat-rs documentation.
     let mut event_handler = EventHandler::new(
         TmAsVecSenderWithId::new(
-            TmSenderId::AllEvents as ChannelId,
+            ComponentIdList::EventManagement as ComponentId,
             "ALL_EVENTS_TX",
             tm_funnel_tx.clone(),
         ),
@@ -428,15 +432,17 @@ fn dyn_tmtc_pool_main() {
     )
     .expect("tcp server creation failed");
 
+    /*
     let mut acs_task = AcsTask::new(
         TmAsVecSenderWithId::new(
-            TmSenderId::AcsSubsystem as ChannelId,
+            TmSenderId::AcsSubsystem as ComponentId,
             "ACS_TASK_SENDER",
             tm_funnel_tx.clone(),
         ),
         acs_thread_rx,
         verif_reporter,
     );
+    */
     let mut tm_funnel = TmFunnelDynamic::new(sync_tm_tcp_source, tm_funnel_rx, tm_server_tx);
 
     info!("Starting TMTC and UDP task");
@@ -484,7 +490,7 @@ fn dyn_tmtc_pool_main() {
     let jh_aocs = thread::Builder::new()
         .name("AOCS".to_string())
         .spawn(move || loop {
-            acs_task.periodic_operation();
+            // acs_task.periodic_operation();
             thread::sleep(Duration::from_millis(FREQ_MS_AOCS));
         })
         .unwrap();

satrs-example/src/pus/action.rs

@@ -3,11 +3,11 @@ use satrs::action::{ActionRequest, ActionRequestVariant};
 use satrs::params::WritableToBeBytes;
 use satrs::pool::{SharedStaticMemoryPool, StoreAddr};
 use satrs::pus::action::{
-    ActionReplyPus, ActionReplyPusWithActionId, ActionRequestWithId, ActivePusActionRequestStd,
+    ActionReplyPus, ActionReplyPusWithActionId, ActivePusActionRequestStd,
     DefaultActiveActionRequestMap,
 };
 use satrs::pus::verification::{
-    self, FailParams, FailParamsWithStep, TcStateAccepted,
+    FailParams, FailParamsWithStep, TcStateAccepted,
     VerificationReporterWithSharedPoolMpscBoundedSender, VerificationReporterWithVecMpscSender,
     VerificationReportingProvider, VerificationToken,
 };
@@ -22,8 +22,8 @@ use satrs::request::{GenericMessage, TargetAndApidId};
 use satrs::spacepackets::ecss::tc::PusTcReader;
 use satrs::spacepackets::ecss::{EcssEnumU16, PusPacket};
 use satrs::tmtc::tm_helper::SharedTmPool;
-use satrs::ChannelId;
+use satrs::ComponentId;
-use satrs_example::config::{tmtc_err, TcReceiverId, TmSenderId, PUS_APID};
+use satrs_example::config::{tmtc_err, ComponentIdList, PUS_APID};
 use std::sync::mpsc::{self};
 use std::time::Duration;
 
@@ -135,7 +135,7 @@ impl PusReplyHandler<ActivePusActionRequestStd, ActionReplyPusWithActionId> for
 #[derive(Default)]
 pub struct ExampleActionRequestConverter {}
 
-impl PusTcToRequestConverter<ActivePusActionRequestStd, ActionRequestWithId>
+impl PusTcToRequestConverter<ActivePusActionRequestStd, ActionRequest>
     for ExampleActionRequestConverter
 {
     type Error = GenericConversionError;
@@ -146,7 +146,7 @@ impl PusTcToRequestConverter<ActivePusActionRequestStd, ActionRequestWithId>
         tc: &PusTcReader,
         time_stamp: &[u8],
         verif_reporter: &impl VerificationReportingProvider,
-    ) -> Result<(ActivePusActionRequestStd, ActionRequestWithId), Self::Error> {
+    ) -> Result<(ActivePusActionRequestStd, ActionRequest), Self::Error> {
         let subservice = tc.subservice();
         let user_data = tc.user_data();
         if user_data.len() < 8 {
@@ -174,13 +174,10 @@ impl PusTcToRequestConverter<ActivePusActionRequestStd, ActionRequestWithId>
                     token,
                     Duration::from_secs(30),
                 ),
-                ActionRequestWithId {
+                ActionRequest::new(
-                    request_id: verification::RequestId::new(tc).into(),
+                    action_id,
-                    request: ActionRequest::new(
+                    ActionRequestVariant::VecData(user_data[8..].to_vec()),
-                        action_id,
+                ),
-                        ActionRequestVariant::VecData(user_data[8..].to_vec()),
-                    ),
-                },
             ))
         } else {
             verif_reporter
@@ -209,13 +206,13 @@ pub fn create_action_service_static(
     VerificationReporterWithSharedPoolMpscBoundedSender,
 > {
     let action_srv_tm_sender = TmInSharedPoolSenderWithId::new(
-        TmSenderId::PusAction as ChannelId,
+        ComponentIdList::PusAction as ComponentId,
         "PUS_8_TM_SENDER",
         shared_tm_store.clone(),
         tm_funnel_tx.clone(),
     );
     let action_srv_receiver = MpscTcReceiver::new(
-        TcReceiverId::PusAction as ChannelId,
+        ComponentIdList::PusAction as ComponentId,
         "PUS_8_TC_RECV",
         pus_action_rx,
     );
@@ -253,12 +250,12 @@ pub fn create_action_service_dynamic(
     VerificationReporterWithVecMpscSender,
 > {
     let action_srv_tm_sender = TmAsVecSenderWithId::new(
-        TmSenderId::PusAction as ChannelId,
+        ComponentIdList::PusAction as ComponentId,
         "PUS_8_TM_SENDER",
         tm_funnel_tx.clone(),
     );
     let action_srv_receiver = MpscTcReceiver::new(
-        TcReceiverId::PusAction as ChannelId,
+        ComponentIdList::PusAction as ComponentId,
         "PUS_8_TC_RECV",
         pus_action_rx,
     );
@@ -296,7 +293,7 @@ pub struct Pus8Wrapper<
         ActionReplyHandler,
         DefaultActiveActionRequestMap,
         ActivePusActionRequestStd,
-        ActionRequestWithId,
+        ActionRequest,
         ActionReplyPusWithActionId,
     >,
 }

satrs-example/src/pus/event.rs

@@ -15,8 +15,8 @@ use satrs::pus::{
     TmInSharedPoolSenderWithId,
 };
 use satrs::tmtc::tm_helper::SharedTmPool;
-use satrs::ChannelId;
+use satrs::ComponentId;
-use satrs_example::config::{TcReceiverId, TmSenderId, PUS_APID};
+use satrs_example::config::{ComponentIdList, PUS_APID};
 
 pub fn create_event_service_static(
     shared_tm_store: SharedTmPool,
@@ -32,13 +32,13 @@ pub fn create_event_service_static(
     VerificationReporterWithSharedPoolMpscBoundedSender,
 > {
     let event_srv_tm_sender = TmInSharedPoolSenderWithId::new(
-        TmSenderId::PusEvent as ChannelId,
+        ComponentIdList::EventManagement as ComponentId,
         "PUS_5_TM_SENDER",
         shared_tm_store.clone(),
         tm_funnel_tx.clone(),
     );
     let event_srv_receiver = MpscTcReceiver::new(
-        TcReceiverId::PusEvent as ChannelId,
+        ComponentIdList::EventManagement as ComponentId,
         "PUS_5_TC_RECV",
         pus_event_rx,
     );
@@ -69,12 +69,12 @@ pub fn create_event_service_dynamic(
     VerificationReporterWithVecMpscSender,
 > {
     let event_srv_tm_sender = TmAsVecSenderWithId::new(
-        TmSenderId::PusEvent as ChannelId,
+        ComponentIdList::EventManagement as ComponentId,
         "PUS_5_TM_SENDER",
         tm_funnel_tx,
     );
     let event_srv_receiver = MpscTcReceiver::new(
-        TcReceiverId::PusEvent as ChannelId,
+        ComponentIdList::EventManagement as ComponentId,
         "PUS_5_TC_RECV",
         pus_event_rx,
     );

satrs-example/src/pus/hk.rs

@@ -17,8 +17,8 @@ use satrs::request::{GenericMessage, TargetAndApidId};
 use satrs::spacepackets::ecss::tc::PusTcReader;
 use satrs::spacepackets::ecss::{hk, PusPacket};
 use satrs::tmtc::tm_helper::SharedTmPool;
-use satrs::ChannelId;
+use satrs::ComponentId;
-use satrs_example::config::{hk_err, tmtc_err, TcReceiverId, TmSenderId, PUS_APID};
+use satrs_example::config::{hk_err, tmtc_err, ComponentIdList, PUS_APID};
 use std::sync::mpsc::{self};
 use std::time::Duration;
 
@@ -227,13 +227,16 @@ pub fn create_hk_service_static(
     VerificationReporterWithSharedPoolMpscBoundedSender,
 > {
     let hk_srv_tm_sender = TmInSharedPoolSenderWithId::new(
-        TmSenderId::PusHk as ChannelId,
+        ComponentIdList::PusHk as ComponentId,
         "PUS_3_TM_SENDER",
         shared_tm_store.clone(),
         tm_funnel_tx.clone(),
     );
-    let hk_srv_receiver =
+    let hk_srv_receiver = MpscTcReceiver::new(
-        MpscTcReceiver::new(TcReceiverId::PusHk as ChannelId, "PUS_8_TC_RECV", pus_hk_rx);
+        ComponentIdList::PusHk as ComponentId,
+        "PUS_8_TC_RECV",
+        pus_hk_rx,
+    );
     let pus_3_handler = PusTargetedRequestService::new(
         PusServiceHelper::new(
             hk_srv_receiver,
@@ -266,12 +269,15 @@ pub fn create_hk_service_dynamic(
     VerificationReporterWithVecMpscSender,
 > {
     let hk_srv_tm_sender = TmAsVecSenderWithId::new(
-        TmSenderId::PusHk as ChannelId,
+        ComponentIdList::PusHk as ComponentId,
         "PUS_3_TM_SENDER",
         tm_funnel_tx.clone(),
     );
-    let hk_srv_receiver =
+    let hk_srv_receiver = MpscTcReceiver::new(
-        MpscTcReceiver::new(TcReceiverId::PusHk as ChannelId, "PUS_8_TC_RECV", pus_hk_rx);
+        ComponentIdList::PusHk as ComponentId,
+        "PUS_8_TC_RECV",
+        pus_hk_rx,
+    );
     let pus_3_handler = PusTargetedRequestService::new(
         PusServiceHelper::new(
             hk_srv_receiver,

satrs-example/src/pus/mod.rs

@@ -199,15 +199,17 @@ where
                 return Err(e.into());
             }
         };
-        let verif_request_id = verification::RequestId::new(&tc);
+        let verif_request_id = verification::RequestId::new(&tc).raw();
         //if let Err(e) =
-        match self
+        match self.request_router.route(
-            .request_router
+            request_info.target_id(),
-            .route(request_info.target_id(), request, request_info.token())
+            verif_request_id,
-        {
+            request,
+            request_info.token(),
+        ) {
             Ok(()) => {
                 self.active_request_map
-                    .insert(&verif_request_id.into(), request_info);
+                    .insert(&verif_request_id, request_info);
             }
             Err(e) => {
                 self.request_router.handle_error_generic(

satrs-example/src/pus/scheduler.rs

@@ -16,8 +16,8 @@ use satrs::pus::{
     TmInSharedPoolSenderWithId,
 };
 use satrs::tmtc::tm_helper::SharedTmPool;
-use satrs::ChannelId;
+use satrs::ComponentId;
-use satrs_example::config::{TcReceiverId, TmSenderId, PUS_APID};
+use satrs_example::config::{ComponentIdList, PUS_APID};
 
 use crate::tmtc::PusTcSourceProviderSharedPool;
 
@@ -145,13 +145,13 @@ pub fn create_scheduler_service_static(
     VerificationReporterWithSharedPoolMpscBoundedSender,
 > {
     let sched_srv_tm_sender = TmInSharedPoolSenderWithId::new(
-        TmSenderId::PusSched as ChannelId,
+        ComponentIdList::PusSched as ComponentId,
         "PUS_11_TM_SENDER",
         shared_tm_store.clone(),
         tm_funnel_tx.clone(),
     );
     let sched_srv_receiver = MpscTcReceiver::new(
-        TcReceiverId::PusSched as ChannelId,
+        ComponentIdList::PusSched as ComponentId,
         "PUS_11_TC_RECV",
         pus_sched_rx,
     );
@@ -188,12 +188,12 @@ pub fn create_scheduler_service_dynamic(
     VerificationReporterWithVecMpscSender,
 > {
     let sched_srv_tm_sender = TmAsVecSenderWithId::new(
-        TmSenderId::PusSched as ChannelId,
+        ComponentIdList::PusSched as ComponentId,
         "PUS_11_TM_SENDER",
         tm_funnel_tx,
     );
     let sched_srv_receiver = MpscTcReceiver::new(
-        TcReceiverId::PusSched as ChannelId,
+        ComponentIdList::PusSched as ComponentId,
         "PUS_11_TC_RECV",
         pus_sched_rx,
     );

satrs-example/src/pus/test.rs

@@ -17,9 +17,9 @@ use satrs::spacepackets::ecss::PusPacket;
 use satrs::spacepackets::time::cds::TimeProvider;
 use satrs::spacepackets::time::TimeWriter;
 use satrs::tmtc::tm_helper::SharedTmPool;
-use satrs::ChannelId;
+use satrs::ComponentId;
 use satrs::{events::EventU32, pus::EcssTcInSharedStoreConverter};
-use satrs_example::config::{tmtc_err, TcReceiverId, TmSenderId, PUS_APID, TEST_EVENT};
+use satrs_example::config::{tmtc_err, ComponentIdList, PUS_APID, TEST_EVENT};
 use std::sync::mpsc::{self, Sender};
 
 pub fn create_test_service_static(
@@ -36,13 +36,13 @@ pub fn create_test_service_static(
     VerificationReporterWithSharedPoolMpscBoundedSender,
 > {
     let test_srv_tm_sender = TmInSharedPoolSenderWithId::new(
-        TmSenderId::PusTest as ChannelId,
+        ComponentIdList::PusTest as ComponentId,
         "PUS_17_TM_SENDER",
         shared_tm_store.clone(),
         tm_funnel_tx.clone(),
     );
     let test_srv_receiver = MpscTcReceiver::new(
-        TcReceiverId::PusTest as ChannelId,
+        ComponentIdList::PusTest as ComponentId,
         "PUS_17_TC_RECV",
         pus_test_rx,
     );
@@ -71,12 +71,12 @@ pub fn create_test_service_dynamic(
     VerificationReporterWithVecMpscSender,
 > {
     let test_srv_tm_sender = TmAsVecSenderWithId::new(
-        TmSenderId::PusTest as ChannelId,
+        ComponentIdList::PusTest as ComponentId,
         "PUS_17_TM_SENDER",
         tm_funnel_tx.clone(),
     );
     let test_srv_receiver = MpscTcReceiver::new(
-        TcReceiverId::PusTest as ChannelId,
+        ComponentIdList::PusTest as ComponentId,
         "PUS_17_TC_RECV",
         pus_test_rx,
     );

satrs-example/src/requests.rs

@@ -1,50 +1,42 @@
 use std::collections::HashMap;
 use std::sync::mpsc;
 
-use derive_new::new;
 use log::warn;
+use satrs::action::ActionRequest;
 use satrs::hk::HkRequest;
-use satrs::mode::ModeRequest;
-use satrs::pus::action::ActionRequestWithId;
 use satrs::pus::verification::{
     FailParams, TcStateStarted, VerificationReportingProvider, VerificationToken,
 };
 use satrs::pus::{ActiveRequestProvider, GenericRoutingError, PusRequestRouter};
 use satrs::queue::GenericSendError;
+use satrs::request::{GenericMessage, RequestId};
 use satrs::spacepackets::ecss::tc::PusTcReader;
 use satrs::spacepackets::ecss::PusPacket;
 use satrs::ComponentId;
 use satrs_example::config::tmtc_err;
 
-#[allow(dead_code)]
 #[derive(Clone, Debug)]
 #[non_exhaustive]
-pub enum Request {
+pub enum CompositeRequest {
     Hk(HkRequest),
-    Mode(ModeRequest),
+    Action(ActionRequest),
-    Action(ActionRequestWithId),
-}
-
-#[derive(Clone, Debug, new)]
-pub struct TargetedRequest {
-    pub(crate) target_id: ComponentId,
-    pub(crate) request: Request,
 }
 
 #[derive(Clone, Debug)]
 pub struct RequestWithToken {
-    pub(crate) targeted_request: TargetedRequest,
+    pub(crate) targeted_request: GenericMessage<CompositeRequest>,
     pub(crate) token: VerificationToken<TcStateStarted>,
 }
 
 impl RequestWithToken {
     pub fn new(
         target_id: ComponentId,
-        request: Request,
+        request_id: RequestId,
+        request: CompositeRequest,
         token: VerificationToken<TcStateStarted>,
     ) -> Self {
         Self {
-            targeted_request: TargetedRequest::new(target_id, request),
+            targeted_request: GenericMessage::new(request_id, target_id, request),
             token,
         }
     }
@@ -96,6 +88,7 @@ impl PusRequestRouter<HkRequest> for GenericRequestRouter {
     fn route(
         &self,
         target_id: ComponentId,
+        request_id: RequestId,
         hk_request: HkRequest,
         token: VerificationToken<TcStateStarted>,
     ) -> Result<(), Self::Error> {
@@ -103,7 +96,8 @@ impl PusRequestRouter<HkRequest> for GenericRequestRouter {
             sender
                 .send(RequestWithToken::new(
                     target_id,
-                    Request::Hk(hk_request),
+                    request_id,
+                    CompositeRequest::Hk(hk_request),
                     token,
                 ))
                 .map_err(|_| GenericRoutingError::Send(GenericSendError::RxDisconnected))?;
@@ -112,20 +106,22 @@ impl PusRequestRouter<HkRequest> for GenericRequestRouter {
     }
 }
 
-impl PusRequestRouter<ActionRequestWithId> for GenericRequestRouter {
+impl PusRequestRouter<ActionRequest> for GenericRequestRouter {
     type Error = GenericRoutingError;
 
     fn route(
         &self,
         target_id: ComponentId,
-        action_request: ActionRequestWithId,
+        request_id: RequestId,
+        action_request: ActionRequest,
         token: VerificationToken<TcStateStarted>,
     ) -> Result<(), Self::Error> {
         if let Some(sender) = self.0.get(&target_id) {
             sender
                 .send(RequestWithToken::new(
                     target_id,
-                    Request::Action(action_request),
+                    request_id,
+                    CompositeRequest::Action(action_request),
                     token,
                 ))
                 .map_err(|_| GenericRoutingError::Send(GenericSendError::RxDisconnected))?;

satrs/src/event_man.rs

@@ -11,7 +11,7 @@
 //! about events first:
 //!
 //! The event manager has a listener table abstracted by the [ListenerMapProvider], which maps
-//! listener groups identified by [ListenerKey]s to a [sender ID][ChannelId].
+//! listener groups identified by [ListenerKey]s to a [sender ID][ComponentId].
 //! It also contains a sender table abstracted by the [SenderMapProvider] which maps these sender
 //! IDs to concrete [EventSendProvider]s. A simple approach would be to use one send event provider
 //! for each OBSW thread and then subscribe for all interesting events for a particular thread
@@ -50,7 +50,7 @@ use crate::queue::GenericSendError;
 use core::marker::PhantomData;
 use core::slice::Iter;
 
-use crate::ChannelId;
+use crate::ComponentId;
 
 #[cfg(feature = "alloc")]
 pub use alloc_mod::*;
@@ -74,7 +74,7 @@ pub type EventU32WithAuxData = EventWithAuxData<EventU32>;
 pub type EventU16WithAuxData = EventWithAuxData<EventU16>;
 
 pub trait EventSendProvider<EV: GenericEvent, AuxDataProvider = Params> {
-    fn channel_id(&self) -> ChannelId;
+    fn target_id(&self) -> ComponentId;
 
     fn send_no_data(&self, event: EV) -> Result<(), GenericSendError> {
         self.send(event, None)
@@ -95,8 +95,8 @@ pub trait ListenerMapProvider {
     #[cfg_attr(doc_cfg, doc(cfg(feature = "alloc")))]
     fn get_listeners(&self) -> alloc::vec::Vec<ListenerKey>;
     fn contains_listener(&self, key: &ListenerKey) -> bool;
-    fn get_listener_ids(&self, key: &ListenerKey) -> Option<Iter<ChannelId>>;
+    fn get_listener_ids(&self, key: &ListenerKey) -> Option<Iter<ComponentId>>;
-    fn add_listener(&mut self, key: ListenerKey, sender_id: ChannelId) -> bool;
+    fn add_listener(&mut self, key: ListenerKey, sender_id: ComponentId) -> bool;
     fn remove_duplicates(&mut self, key: &ListenerKey);
 }
 
@@ -106,9 +106,9 @@ pub trait SenderMapProvider<
     Data = Params,
 >
 {
-    fn contains_send_event_provider(&self, id: &ChannelId) -> bool;
+    fn contains_send_event_provider(&self, target_id: &ComponentId) -> bool;
 
-    fn get_send_event_provider(&self, id: &ChannelId) -> Option<&EventSender>;
+    fn get_send_event_provider(&self, target_id: &ComponentId) -> Option<&EventSender>;
     fn add_send_event_provider(&mut self, send_provider: EventSender) -> bool;
 }
 
@@ -153,7 +153,7 @@ pub enum EventRoutingResult<EV: GenericEvent, AUX> {
 pub enum EventRoutingError {
     Send(GenericSendError),
     NoSendersForKey(ListenerKey),
-    NoSenderForId(ChannelId),
+    NoSenderForId(ComponentId),
 }
 
 #[derive(Debug)]
@@ -176,12 +176,12 @@ impl<
     }
 
     /// Subscribe for a unique event.
-    pub fn subscribe_single(&mut self, event: &Ev, sender_id: ChannelId) {
+    pub fn subscribe_single(&mut self, event: &Ev, sender_id: ComponentId) {
         self.update_listeners(ListenerKey::Single(event.raw_as_largest_type()), sender_id);
     }
 
     /// Subscribe for an event group.
-    pub fn subscribe_group(&mut self, group_id: LargestGroupIdRaw, sender_id: ChannelId) {
+    pub fn subscribe_group(&mut self, group_id: LargestGroupIdRaw, sender_id: ComponentId) {
         self.update_listeners(ListenerKey::Group(group_id), sender_id);
     }
 
@@ -189,7 +189,7 @@ impl<
     ///
     /// For example, this can be useful for a handler component which sends every event as
     /// a telemetry packet.
-    pub fn subscribe_all(&mut self, sender_id: ChannelId) {
+    pub fn subscribe_all(&mut self, sender_id: ComponentId) {
         self.update_listeners(ListenerKey::All, sender_id);
     }
 }
@@ -216,14 +216,14 @@ impl<
     pub fn add_sender(&mut self, send_provider: SP) {
         if !self
             .sender_map
-            .contains_send_event_provider(&send_provider.channel_id())
+            .contains_send_event_provider(&send_provider.target_id())
         {
             self.sender_map.add_send_event_provider(send_provider);
         }
     }
 
     /// Generic function to update the event subscribers.
-    fn update_listeners(&mut self, key: ListenerKey, sender_id: ChannelId) {
+    fn update_listeners(&mut self, key: ListenerKey, sender_id: ComponentId) {
         self.listener_map.add_listener(key, sender_id);
     }
 
@@ -342,7 +342,7 @@ pub mod alloc_mod {
     /// Simple implementation which uses a [HashMap] and a [Vec] internally.
     #[derive(Default)]
     pub struct DefaultListenerMap {
-        listeners: HashMap<ListenerKey, Vec<ChannelId>>,
+        listeners: HashMap<ListenerKey, Vec<ComponentId>>,
     }
 
     impl ListenerMapProvider for DefaultListenerMap {
@@ -358,11 +358,11 @@ pub mod alloc_mod {
             self.listeners.contains_key(key)
         }
 
-        fn get_listener_ids(&self, key: &ListenerKey) -> Option<Iter<ChannelId>> {
+        fn get_listener_ids(&self, key: &ListenerKey) -> Option<Iter<ComponentId>> {
             self.listeners.get(key).map(|vec| vec.iter())
         }
 
-        fn add_listener(&mut self, key: ListenerKey, sender_id: ChannelId) -> bool {
+        fn add_listener(&mut self, key: ListenerKey, sender_id: ComponentId) -> bool {
             if let Some(existing_list) = self.listeners.get_mut(&key) {
                 existing_list.push(sender_id);
             } else {
@@ -388,7 +388,7 @@ pub mod alloc_mod {
         EV: GenericEvent = EventU32,
         AUX = Params,
     > {
-        senders: HashMap<ChannelId, SP>,
+        senders: HashMap<ComponentId, SP>,
         phantom: PhantomData<(EV, AUX)>,
     }
 
@@ -406,18 +406,18 @@ pub mod alloc_mod {
     impl<SP: EventSendProvider<EV, AUX>, EV: GenericEvent, AUX> SenderMapProvider<SP, EV, AUX>
         for DefaultSenderMap<SP, EV, AUX>
     {
-        fn contains_send_event_provider(&self, id: &ChannelId) -> bool {
+        fn contains_send_event_provider(&self, id: &ComponentId) -> bool {
             self.senders.contains_key(id)
         }
 
-        fn get_send_event_provider(&self, id: &ChannelId) -> Option<&SP> {
+        fn get_send_event_provider(&self, id: &ComponentId) -> Option<&SP> {
             self.senders
                 .get(id)
-                .filter(|sender| sender.channel_id() == *id)
+                .filter(|sender| sender.target_id() == *id)
         }
 
         fn add_send_event_provider(&mut self, send_provider: SP) -> bool {
-            let id = send_provider.channel_id();
+            let id = send_provider.target_id();
             if self.senders.contains_key(&id) {
                 return false;
             }
@@ -458,19 +458,19 @@ pub mod std_mod {
     /// send events.
     #[derive(Clone)]
     pub struct EventSenderMpsc<Event: GenericEvent + Send> {
-        id: u32,
+        target_id: ComponentId,
         sender: mpsc::Sender<(Event, Option<Params>)>,
     }
 
     impl<Event: GenericEvent + Send> EventSenderMpsc<Event> {
-        pub fn new(id: u32, sender: mpsc::Sender<(Event, Option<Params>)>) -> Self {
+        pub fn new(target_id: ComponentId, sender: mpsc::Sender<(Event, Option<Params>)>) -> Self {
-            Self { id, sender }
+            Self { target_id, sender }
         }
     }
 
     impl<Event: GenericEvent + Send> EventSendProvider<Event> for EventSenderMpsc<Event> {
-        fn channel_id(&self) -> u32 {
+        fn target_id(&self) -> ComponentId {
-            self.id
+            self.target_id
         }
         fn send(&self, event: Event, aux_data: Option<Params>) -> Result<(), GenericSendError> {
             self.sender
@@ -483,19 +483,19 @@ pub mod std_mod {
     /// events. This has the advantage that the channel is bounded and thus more deterministic.
     #[derive(Clone)]
     pub struct EventSenderMpscBounded<Event: GenericEvent + Send> {
-        channel_id: u32,
+        target_id: ComponentId,
         sender: mpsc::SyncSender<(Event, Option<Params>)>,
         capacity: usize,
     }
 
     impl<Event: GenericEvent + Send> EventSenderMpscBounded<Event> {
         pub fn new(
-            channel_id: u32,
+            target_id: ComponentId,
             sender: mpsc::SyncSender<(Event, Option<Params>)>,
             capacity: usize,
         ) -> Self {
             Self {
-                channel_id,
+                target_id,
                 sender,
                 capacity,
             }
@@ -503,8 +503,8 @@ pub mod std_mod {
     }
 
     impl<Event: GenericEvent + Send> EventSendProvider<Event> for EventSenderMpscBounded<Event> {
-        fn channel_id(&self) -> u32 {
+        fn target_id(&self) -> ComponentId {
-            self.channel_id
+            self.target_id
         }
         fn send(&self, event: Event, aux_data: Option<Params>) -> Result<(), GenericSendError> {
             if let Err(e) = self.sender.try_send((event, aux_data)) {
@@ -577,11 +577,11 @@ mod tests {
         let event_grp_1_0 = EventU32::new(Severity::HIGH, 1, 0).unwrap();
         let (single_event_sender, single_event_receiver) = channel();
         let single_event_listener = EventSenderMpsc::new(0, single_event_sender);
-        event_man.subscribe_single(&event_grp_0, single_event_listener.channel_id());
+        event_man.subscribe_single(&event_grp_0, single_event_listener.target_id());
         event_man.add_sender(single_event_listener);
         let (group_event_sender_0, group_event_receiver_0) = channel();
         let group_event_listener = EventU32SenderMpsc::new(1, group_event_sender_0);
-        event_man.subscribe_group(event_grp_1_0.group_id(), group_event_listener.channel_id());
+        event_man.subscribe_group(event_grp_1_0.group_id(), group_event_listener.target_id());
         event_man.add_sender(group_event_listener);
 
         // Test event with one listener
@@ -609,7 +609,7 @@ mod tests {
         let event_grp_0 = EventU32::new(Severity::INFO, 0, 0).unwrap();
         let (single_event_sender, single_event_receiver) = channel();
         let single_event_listener = EventSenderMpsc::new(0, single_event_sender);
-        event_man.subscribe_single(&event_grp_0, single_event_listener.channel_id());
+        event_man.subscribe_single(&event_grp_0, single_event_listener.target_id());
         event_man.add_sender(single_event_listener);
         event_sender
             .send((event_grp_0, Some(Params::Heapless((2_u32, 3_u32).into()))))
@@ -643,11 +643,11 @@ mod tests {
         let event_grp_0_and_1_listener = EventU32SenderMpsc::new(0, event_grp_0_sender);
         event_man.subscribe_group(
             event_grp_0.group_id(),
-            event_grp_0_and_1_listener.channel_id(),
+            event_grp_0_and_1_listener.target_id(),
         );
         event_man.subscribe_group(
             event_grp_1_0.group_id(),
-            event_grp_0_and_1_listener.channel_id(),
+            event_grp_0_and_1_listener.target_id(),
         );
         event_man.add_sender(event_grp_0_and_1_listener);
 
@@ -679,10 +679,10 @@ mod tests {
         let (event_0_tx_1, event_0_rx_1) = channel();
         let event_listener_0 = EventU32SenderMpsc::new(0, event_0_tx_0);
         let event_listener_1 = EventU32SenderMpsc::new(1, event_0_tx_1);
-        let event_listener_0_sender_id = event_listener_0.channel_id();
+        let event_listener_0_sender_id = event_listener_0.target_id();
         event_man.subscribe_single(&event_0, event_listener_0_sender_id);
         event_man.add_sender(event_listener_0);
-        let event_listener_1_sender_id = event_listener_1.channel_id();
+        let event_listener_1_sender_id = event_listener_1.target_id();
         event_man.subscribe_single(&event_0, event_listener_1_sender_id);
         event_man.add_sender(event_listener_1);
         event_sender
@@ -732,7 +732,7 @@ mod tests {
         let event_1 = EventU32::new(Severity::HIGH, 1, 0).unwrap();
         let (event_0_tx_0, all_events_rx) = channel();
         let all_events_listener = EventU32SenderMpsc::new(0, event_0_tx_0);
-        event_man.subscribe_all(all_events_listener.channel_id());
+        event_man.subscribe_all(all_events_listener.target_id());
         event_man.add_sender(all_events_listener);
         event_sender
             .send((event_0, None))

satrs/src/mode.rs

@@ -13,7 +13,7 @@ pub use std_mod::*;
 use crate::{
     queue::GenericTargetedMessagingError,
     request::{GenericMessage, MessageReceiver, MessageReceiverWithId, RequestId},
-    ChannelId, ComponentId,
+    ComponentId,
 };
 
 pub type Mode = u32;
@@ -140,11 +140,11 @@ pub enum ModeReply {
 pub type GenericModeReply = GenericMessage<ModeReply>;
 
 pub trait ModeRequestSender {
-    fn local_channel_id(&self) -> ChannelId;
+    fn local_channel_id(&self) -> ComponentId;
     fn send_mode_request(
         &self,
         request_id: RequestId,
-        target_id: ChannelId,
+        target_id: ComponentId,
         request: ModeRequest,
     ) -> Result<(), GenericTargetedMessagingError>;
 }
@@ -184,11 +184,11 @@ pub trait ModeRequestHandler: ModeProvider {
     fn start_transition(
         &mut self,
         request_id: RequestId,
-        sender_id: ChannelId,
+        sender_id: ComponentId,
         mode_and_submode: ModeAndSubmode,
     ) -> Result<(), ModeError>;
 
-    fn announce_mode(&self, request_id: RequestId, sender_id: ChannelId, recursive: bool);
+    fn announce_mode(&self, request_id: RequestId, sender_id: ComponentId, recursive: bool);
     fn handle_mode_reached(&mut self) -> Result<(), GenericTargetedMessagingError>;
 }
 
@@ -207,12 +207,12 @@ impl<R: MessageReceiver<ModeReply>> ModeReplyReceiver for MessageReceiverWithId<
 }
 
 pub trait ModeReplySender {
-    fn local_channel_id(&self) -> ChannelId;
+    fn local_channel_id(&self) -> ComponentId;
 
     fn send_mode_reply(
         &self,
         request_id: RequestId,
-        target_id: ChannelId,
+        target_id: ComponentId,
         reply: ModeReply,
     ) -> Result<(), GenericTargetedMessagingError>;
 }
@@ -227,7 +227,7 @@ pub mod alloc_mod {
             MessageSender, MessageSenderAndReceiver, MessageSenderMap, MessageSenderMapWithId,
             RequestAndReplySenderAndReceiver, RequestId,
         },
-        ChannelId,
+        ComponentId,
     };
 
     use super::*;
@@ -236,14 +236,14 @@ pub mod alloc_mod {
         pub fn send_mode_reply(
             &self,
             request_id: RequestId,
-            local_id: ChannelId,
+            local_id: ComponentId,
-            target_id: ChannelId,
+            target_id: ComponentId,
             request: ModeReply,
         ) -> Result<(), GenericTargetedMessagingError> {
             self.send_message(request_id, local_id, target_id, request)
         }
 
-        pub fn add_reply_target(&mut self, target_id: ChannelId, request_sender: S) {
+        pub fn add_reply_target(&mut self, target_id: ComponentId, request_sender: S) {
             self.add_message_target(target_id, request_sender)
         }
     }
@@ -252,13 +252,13 @@ pub mod alloc_mod {
         fn send_mode_reply(
             &self,
             request_id: RequestId,
-            target_channel_id: ChannelId,
+            target_channel_id: ComponentId,
             reply: ModeReply,
         ) -> Result<(), GenericTargetedMessagingError> {
             self.send_message(request_id, target_channel_id, reply)
         }
 
-        fn local_channel_id(&self) -> ChannelId {
+        fn local_channel_id(&self) -> ComponentId {
             self.local_channel_id
         }
     }
@@ -266,14 +266,14 @@ pub mod alloc_mod {
     impl<FROM, S: MessageSender<ModeReply>, R: MessageReceiver<FROM>> ModeReplySender
         for MessageSenderAndReceiver<ModeReply, FROM, S, R>
     {
-        fn local_channel_id(&self) -> ChannelId {
+        fn local_channel_id(&self) -> ComponentId {
             self.local_channel_id_generic()
         }
 
         fn send_mode_reply(
             &self,
             request_id: RequestId,
-            target_id: ChannelId,
+            target_id: ComponentId,
             request: ModeReply,
         ) -> Result<(), GenericTargetedMessagingError> {
             self.message_sender_map.send_mode_reply(
@@ -303,7 +303,7 @@ pub mod alloc_mod {
             R1: MessageReceiver<REQUEST>,
         > RequestAndReplySenderAndReceiver<REQUEST, ModeReply, S0, R0, S1, R1>
     {
-        pub fn add_reply_target(&mut self, target_id: ChannelId, reply_sender: S1) {
+        pub fn add_reply_target(&mut self, target_id: ComponentId, reply_sender: S1) {
             self.reply_sender_map
                 .add_message_target(target_id, reply_sender)
         }
@@ -317,14 +317,14 @@ pub mod alloc_mod {
             R1: MessageReceiver<REQUEST>,
         > ModeReplySender for RequestAndReplySenderAndReceiver<REQUEST, ModeReply, S0, R0, S1, R1>
     {
-        fn local_channel_id(&self) -> ChannelId {
+        fn local_channel_id(&self) -> ComponentId {
             self.local_channel_id_generic()
         }
 
         fn send_mode_reply(
             &self,
             request_id: RequestId,
-            target_id: ChannelId,
+            target_id: ComponentId,
             request: ModeReply,
         ) -> Result<(), GenericTargetedMessagingError> {
             self.reply_sender_map.send_mode_reply(
@@ -368,7 +368,7 @@ pub mod alloc_mod {
         pub fn send_mode_reply(
             &self,
             request_id: RequestId,
-            target_id: ChannelId,
+            target_id: ComponentId,
             reply: ModeReply,
         ) -> Result<(), GenericTargetedMessagingError> {
             self.send_message(request_id, target_id, reply)
@@ -389,7 +389,7 @@ pub mod alloc_mod {
         pub fn send_mode_request(
             &self,
             request_id: RequestId,
-            target_id: ChannelId,
+            target_id: ComponentId,
             reply: ModeRequest,
         ) -> Result<(), GenericTargetedMessagingError> {
             self.send_message(request_id, target_id, reply)
@@ -405,27 +405,27 @@ pub mod alloc_mod {
         pub fn send_mode_request(
             &self,
             request_id: RequestId,
-            local_id: ChannelId,
+            local_id: ComponentId,
-            target_id: ChannelId,
+            target_id: ComponentId,
             request: ModeRequest,
         ) -> Result<(), GenericTargetedMessagingError> {
             self.send_message(request_id, local_id, target_id, request)
         }
 
-        pub fn add_request_target(&mut self, target_id: ChannelId, request_sender: S) {
+        pub fn add_request_target(&mut self, target_id: ComponentId, request_sender: S) {
             self.add_message_target(target_id, request_sender)
         }
     }
 
     impl<S: MessageSender<ModeRequest>> ModeRequestSender for MessageSenderMapWithId<ModeRequest, S> {
-        fn local_channel_id(&self) -> ChannelId {
+        fn local_channel_id(&self) -> ComponentId {
             self.local_channel_id
         }
 
         fn send_mode_request(
             &self,
             request_id: RequestId,
-            target_id: ChannelId,
+            target_id: ComponentId,
             request: ModeRequest,
         ) -> Result<(), GenericTargetedMessagingError> {
             self.send_message(request_id, target_id, request)
@@ -445,14 +445,14 @@ pub mod alloc_mod {
     impl<FROM, S: MessageSender<ModeRequest>, R: MessageReceiver<FROM>> ModeRequestSender
         for MessageSenderAndReceiver<ModeRequest, FROM, S, R>
     {
-        fn local_channel_id(&self) -> ChannelId {
+        fn local_channel_id(&self) -> ComponentId {
             self.local_channel_id_generic()
         }
 
         fn send_mode_request(
             &self,
             request_id: RequestId,
-            target_id: ChannelId,
+            target_id: ComponentId,
             request: ModeRequest,
         ) -> Result<(), GenericTargetedMessagingError> {
             self.message_sender_map.send_mode_request(
@@ -472,7 +472,7 @@ pub mod alloc_mod {
             R1: MessageReceiver<ModeRequest>,
         > RequestAndReplySenderAndReceiver<ModeRequest, REPLY, S0, R0, S1, R1>
     {
-        pub fn add_request_target(&mut self, target_id: ChannelId, request_sender: S0) {
+        pub fn add_request_target(&mut self, target_id: ComponentId, request_sender: S0) {
             self.request_sender_map
                 .add_message_target(target_id, request_sender)
         }
@@ -487,14 +487,14 @@ pub mod alloc_mod {
         > ModeRequestSender
         for RequestAndReplySenderAndReceiver<ModeRequest, REPLY, S0, R0, S1, R1>
     {
-        fn local_channel_id(&self) -> ChannelId {
+        fn local_channel_id(&self) -> ComponentId {
             self.local_channel_id_generic()
         }
 
         fn send_mode_request(
             &self,
             request_id: RequestId,
-            target_id: ChannelId,
+            target_id: ComponentId,
             request: ModeRequest,
         ) -> Result<(), GenericTargetedMessagingError> {
             self.request_sender_map.send_mode_request(

satrs/src/mode_tree.rs

@@ -3,7 +3,7 @@ use hashbrown::HashMap;
 
 use crate::{
     mode::{Mode, ModeAndSubmode, Submode},
-    ChannelId,
+    ComponentId,
 };
 
 #[derive(Debug, Copy, Clone, PartialEq, Eq)]
@@ -19,7 +19,7 @@ pub struct ModeTableEntry {
     /// Name of respective table entry.
     pub name: &'static str,
     /// Target channel ID.
-    pub channel_id: ChannelId,
+    pub channel_id: ComponentId,
     pub mode_submode: ModeAndSubmode,
     pub allowed_submode_mask: Option<Submode>,
     pub check_success: bool,

satrs/src/pus/action.rs

@@ -2,7 +2,7 @@ use crate::{
     action::{ActionId, ActionRequest},
     params::Params,
     request::{GenericMessage, RequestId},
-    ChannelId,
+    ComponentId,
 };
 
 use super::{verification::VerificationToken, ActivePusRequestStd, ActiveRequestProvider};
@@ -61,7 +61,7 @@ pub type GenericActionReplyPus = GenericMessage<ActionReplyPusWithActionId>;
 impl GenericActionReplyPus {
     pub fn new_action_reply(
         request_id: RequestId,
-        sender_id: ChannelId,
+        sender_id: ComponentId,
         action_id: ActionId,
         reply: ActionReplyPus,
     ) -> Self {
@@ -82,7 +82,7 @@ pub mod alloc_mod {
         request::{
             GenericMessage, MessageReceiver, MessageSender, MessageSenderAndReceiver, RequestId,
         },
-        ChannelId,
+        ComponentId,
     };
 
     use super::ActionReplyPusWithActionId;
@@ -103,7 +103,7 @@ pub mod alloc_mod {
         pub fn send_action_reply(
             &self,
             request_id: RequestId,
-            target_id: ChannelId,
+            target_id: ComponentId,
             reply: ActionReplyPusWithActionId,
         ) -> Result<(), GenericTargetedMessagingError> {
             self.send_message(request_id, target_id, reply)
@@ -128,7 +128,7 @@ pub mod alloc_mod {
         pub fn send_action_request(
             &self,
             request_id: RequestId,
-            target_id: ChannelId,
+            target_id: ComponentId,
             request: ActionRequest,
         ) -> Result<(), GenericTargetedMessagingError> {
             self.send_message(request_id, target_id, request)

satrs/src/pus/event.rs

@@ -244,7 +244,7 @@ mod tests {
     use crate::events::{EventU32, Severity};
     use crate::pus::tests::CommonTmInfo;
     use crate::pus::{EcssChannel, PusTmWrapper};
-    use crate::ChannelId;
+    use crate::ComponentId;
     use spacepackets::ByteConversionError;
     use std::cell::RefCell;
     use std::collections::VecDeque;
@@ -269,7 +269,7 @@ mod tests {
     }
 
     impl EcssChannel for TestSender {
-        fn channel_id(&self) -> ChannelId {
+        fn channel_id(&self) -> ComponentId {
             0
         }
     }

satrs/src/pus/mod.rs

@@ -6,7 +6,7 @@ use crate::pool::{StoreAddr, StoreError};
 use crate::pus::verification::{TcStateAccepted, TcStateToken, VerificationToken};
 use crate::queue::{GenericReceiveError, GenericSendError};
 use crate::request::{GenericMessage, RequestId};
-use crate::{ChannelId, ComponentId};
+use crate::ComponentId;
 use core::fmt::{Display, Formatter};
 use core::time::Duration;
 #[cfg(feature = "alloc")]
@@ -144,7 +144,7 @@ impl Error for EcssTmtcError {
 }
 pub trait EcssChannel: Send {
     /// Each sender can have an ID associated with it
-    fn channel_id(&self) -> ChannelId;
+    fn channel_id(&self) -> ComponentId;
     fn name(&self) -> &'static str {
         "unset"
     }
@@ -301,6 +301,7 @@ pub trait PusRequestRouter<Request> {
     fn route(
         &self,
         target_id: ComponentId,
+        request_id: RequestId,
         request: Request,
         token: VerificationToken<TcStateStarted>,
     ) -> Result<(), Self::Error>;
@@ -649,7 +650,7 @@ pub mod std_mod {
         GenericReceiveError, GenericSendError, PusTmWrapper, TryRecvTmtcError,
     };
     use crate::tmtc::tm_helper::SharedTmPool;
-    use crate::{ChannelId, ComponentId};
+    use crate::ComponentId;
     use alloc::vec::Vec;
     use core::time::Duration;
     use spacepackets::ecss::tc::PusTcReader;
@@ -724,14 +725,14 @@ pub mod std_mod {
 
     #[derive(Clone)]
     pub struct TmInSharedPoolSenderWithId<Sender: EcssTmSenderCore> {
-        channel_id: ChannelId,
+        channel_id: ComponentId,
         name: &'static str,
         shared_tm_store: SharedTmPool,
         sender: Sender,
     }
 
     impl<Sender: EcssTmSenderCore> EcssChannel for TmInSharedPoolSenderWithId<Sender> {
-        fn channel_id(&self) -> ChannelId {
+        fn channel_id(&self) -> ComponentId {
             self.channel_id
         }
 
@@ -758,7 +759,7 @@ pub mod std_mod {
 
     impl<Sender: EcssTmSenderCore> TmInSharedPoolSenderWithId<Sender> {
         pub fn new(
-            id: ChannelId,
+            id: ComponentId,
             name: &'static str,
             shared_tm_store: SharedTmPool,
             sender: Sender,
@@ -782,7 +783,7 @@ pub mod std_mod {
     /// going to be called with direct packets.
     #[derive(Clone)]
     pub struct TmAsVecSenderWithId<Sender: EcssTmSenderCore> {
-        id: ChannelId,
+        id: ComponentId,
         name: &'static str,
         sender: Sender,
     }
@@ -794,13 +795,13 @@ pub mod std_mod {
     }
 
     impl<Sender: EcssTmSenderCore> TmAsVecSenderWithId<Sender> {
-        pub fn new(id: u32, name: &'static str, sender: Sender) -> Self {
+        pub fn new(id: ComponentId, name: &'static str, sender: Sender) -> Self {
             Self { id, sender, name }
         }
     }
 
     impl<Sender: EcssTmSenderCore> EcssChannel for TmAsVecSenderWithId<Sender> {
-        fn channel_id(&self) -> ChannelId {
+        fn channel_id(&self) -> ComponentId {
             self.id
         }
         fn name(&self) -> &'static str {
@@ -818,13 +819,13 @@ pub mod std_mod {
     pub type TmAsVecSenderWithBoundedMpsc = TmAsVecSenderWithId<mpsc::SyncSender<Vec<u8>>>;
 
     pub struct MpscTcReceiver {
-        id: ChannelId,
+        id: ComponentId,
         name: &'static str,
         receiver: mpsc::Receiver<EcssTcAndToken>,
     }
 
     impl EcssChannel for MpscTcReceiver {
-        fn channel_id(&self) -> ChannelId {
+        fn channel_id(&self) -> ComponentId {
             self.id
         }
 
@@ -846,7 +847,7 @@ pub mod std_mod {
 
     impl MpscTcReceiver {
         pub fn new(
-            id: ChannelId,
+            id: ComponentId,
             name: &'static str,
             receiver: mpsc::Receiver<EcssTcAndToken>,
         ) -> Self {
@@ -903,14 +904,14 @@ pub mod std_mod {
         }
 
         pub struct CrossbeamTcReceiver {
-            id: ChannelId,
+            id: ComponentId,
             name: &'static str,
             receiver: cb::Receiver<EcssTcAndToken>,
         }
 
         impl CrossbeamTcReceiver {
             pub fn new(
-                id: ChannelId,
+                id: ComponentId,
                 name: &'static str,
                 receiver: cb::Receiver<EcssTcAndToken>,
             ) -> Self {
@@ -919,7 +920,7 @@ pub mod std_mod {
         }
 
         impl EcssChannel for CrossbeamTcReceiver {
-            fn channel_id(&self) -> ChannelId {
+            fn channel_id(&self) -> ComponentId {
                 self.id
             }
 

satrs/src/pus/verification.rs

@@ -1443,7 +1443,7 @@ pub mod tests {
         EcssChannel, PusTmWrapper, TmInSharedPoolSenderWithId, TmInSharedPoolSenderWithMpsc,
     };
     use crate::tmtc::tm_helper::SharedTmPool;
-    use crate::ChannelId;
+    use crate::ComponentId;
     use alloc::format;
     use alloc::sync::Arc;
     use hashbrown::HashMap;
@@ -1708,7 +1708,7 @@ pub mod tests {
     }
 
     impl EcssChannel for TestSender {
-        fn channel_id(&self) -> ChannelId {
+        fn channel_id(&self) -> ComponentId {
             0
         }
         fn name(&self) -> &'static str {

satrs/src/queue.rs

@@ -4,6 +4,8 @@ use std::error::Error;
 #[cfg(feature = "std")]
 use std::sync::mpsc;
 
+use crate::ComponentId;
+
 /// Generic channel ID type.
 pub type ChannelId = u32;
 
@@ -12,7 +14,7 @@ pub type ChannelId = u32;
 pub enum GenericSendError {
     RxDisconnected,
     QueueFull(Option<u32>),
-    TargetDoesNotExist(ChannelId),
+    TargetDoesNotExist(ComponentId),
 }
 
 impl Display for GenericSendError {
@@ -38,7 +40,7 @@ impl Error for GenericSendError {}
 #[derive(Debug, Copy, Clone)]
 pub enum GenericReceiveError {
     Empty,
-    TxDisconnected(Option<ChannelId>),
+    TxDisconnected(Option<ComponentId>),
 }
 
 impl Display for GenericReceiveError {

satrs/src/request.rs

@@ -15,7 +15,7 @@ use spacepackets::{
     ByteConversionError, CcsdsPacket,
 };
 
-use crate::{queue::GenericTargetedMessagingError, ChannelId, ComponentId};
+use crate::{queue::GenericTargetedMessagingError, ComponentId};
 
 /// Generic request ID type. Requests can be associated with an ID to have a unique identifier
 /// for them. This can be useful for tasks like tracking their progress.
@@ -91,13 +91,13 @@ impl fmt::Display for TargetAndApidId {
 #[derive(Debug, Clone, PartialEq, Eq)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 pub struct GenericMessage<MSG> {
-    pub sender_id: ChannelId,
     pub request_id: RequestId,
+    pub sender_id: ComponentId,
     pub message: MSG,
 }
 
 impl<MSG> GenericMessage<MSG> {
-    pub fn new(request_id: RequestId, sender_id: ChannelId, message: MSG) -> Self {
+    pub fn new(request_id: RequestId, sender_id: ComponentId, message: MSG) -> Self {
         Self {
             request_id,
             sender_id,
@@ -133,19 +133,19 @@ impl<MSG, R: MessageReceiver<MSG>> MessageWithSenderIdReceiver<MSG, R> {
 }
 
 pub struct MessageReceiverWithId<MSG, R: MessageReceiver<MSG>> {
-    local_channel_id: ChannelId,
+    local_channel_id: ComponentId,
     reply_receiver: MessageWithSenderIdReceiver<MSG, R>,
 }
 
 impl<MSG, R: MessageReceiver<MSG>> MessageReceiverWithId<MSG, R> {
-    pub fn new(local_channel_id: ChannelId, reply_receiver: R) -> Self {
+    pub fn new(local_channel_id: ComponentId, reply_receiver: R) -> Self {
         Self {
             local_channel_id,
             reply_receiver: MessageWithSenderIdReceiver::from(reply_receiver),
         }
     }
 
-    pub fn local_channel_id(&self) -> ChannelId {
+    pub fn local_channel_id(&self) -> ComponentId {
         self.local_channel_id
     }
 }
@@ -169,7 +169,7 @@ pub mod alloc_mod {
     use hashbrown::HashMap;
 
     pub struct MessageSenderMap<MSG, S: MessageSender<MSG>>(
-        pub HashMap<ChannelId, S>,
+        pub HashMap<ComponentId, S>,
         pub(crate) PhantomData<MSG>,
     );
 
@@ -180,15 +180,15 @@ pub mod alloc_mod {
     }
 
     impl<MSG, S: MessageSender<MSG>> MessageSenderMap<MSG, S> {
-        pub fn add_message_target(&mut self, target_id: ChannelId, message_sender: S) {
+        pub fn add_message_target(&mut self, target_id: ComponentId, message_sender: S) {
             self.0.insert(target_id, message_sender);
         }
 
         pub fn send_message(
             &self,
             request_id: RequestId,
-            local_channel_id: ChannelId,
+            local_channel_id: ComponentId,
-            target_channel_id: ChannelId,
+            target_channel_id: ComponentId,
             message: MSG,
         ) -> Result<(), GenericTargetedMessagingError> {
             if self.0.contains_key(&target_channel_id) {
@@ -203,12 +203,12 @@ pub mod alloc_mod {
     }
 
     pub struct MessageSenderMapWithId<MSG, S: MessageSender<MSG>> {
-        pub local_channel_id: ChannelId,
+        pub local_channel_id: ComponentId,
         pub message_sender_map: MessageSenderMap<MSG, S>,
     }
 
     impl<MSG, S: MessageSender<MSG>> MessageSenderMapWithId<MSG, S> {
-        pub fn new(local_channel_id: ChannelId) -> Self {
+        pub fn new(local_channel_id: ComponentId) -> Self {
             Self {
                 local_channel_id,
                 message_sender_map: Default::default(),
@@ -218,7 +218,7 @@ pub mod alloc_mod {
         pub fn send_message(
             &self,
             request_id: RequestId,
-            target_channel_id: ChannelId,
+            target_channel_id: ComponentId,
             message: MSG,
         ) -> Result<(), GenericTargetedMessagingError> {
             self.message_sender_map.send_message(
@@ -229,14 +229,14 @@ pub mod alloc_mod {
             )
         }
 
-        pub fn add_message_target(&mut self, target_id: ChannelId, message_sender: S) {
+        pub fn add_message_target(&mut self, target_id: ComponentId, message_sender: S) {
             self.message_sender_map
                 .add_message_target(target_id, message_sender)
         }
     }
 
     pub struct MessageSenderAndReceiver<TO, FROM, S: MessageSender<TO>, R: MessageReceiver<FROM>> {
-        pub local_channel_id: ChannelId,
+        pub local_channel_id: ComponentId,
         pub message_sender_map: MessageSenderMap<TO, S>,
         pub message_receiver: MessageWithSenderIdReceiver<FROM, R>,
     }
@@ -244,7 +244,7 @@ pub mod alloc_mod {
     impl<TO, FROM, S: MessageSender<TO>, R: MessageReceiver<FROM>>
         MessageSenderAndReceiver<TO, FROM, S, R>
     {
-        pub fn new(local_channel_id: ChannelId, message_receiver: R) -> Self {
+        pub fn new(local_channel_id: ComponentId, message_receiver: R) -> Self {
             Self {
                 local_channel_id,
                 message_sender_map: Default::default(),
@@ -252,12 +252,12 @@ pub mod alloc_mod {
             }
         }
 
-        pub fn add_message_target(&mut self, target_id: ChannelId, message_sender: S) {
+        pub fn add_message_target(&mut self, target_id: ComponentId, message_sender: S) {
             self.message_sender_map
                 .add_message_target(target_id, message_sender)
         }
 
-        pub fn local_channel_id_generic(&self) -> ChannelId {
+        pub fn local_channel_id_generic(&self) -> ComponentId {
             self.local_channel_id
         }
 
@@ -265,7 +265,7 @@ pub mod alloc_mod {
         pub fn send_message(
             &self,
             request_id: RequestId,
-            target_channel_id: ChannelId,
+            target_channel_id: ComponentId,
             message: TO,
         ) -> Result<(), GenericTargetedMessagingError> {
             self.message_sender_map.send_message(
@@ -292,7 +292,7 @@ pub mod alloc_mod {
         S1: MessageSender<REPLY>,
         R1: MessageReceiver<REQUEST>,
     > {
-        pub local_channel_id: ChannelId,
+        pub local_channel_id: ComponentId,
         // These 2 are a functional group.
         pub request_sender_map: MessageSenderMap<REQUEST, S0>,
         pub reply_receiver: MessageWithSenderIdReceiver<REPLY, R0>,
@@ -310,7 +310,11 @@ pub mod alloc_mod {
             R1: MessageReceiver<REQUEST>,
         > RequestAndReplySenderAndReceiver<REQUEST, REPLY, S0, R0, S1, R1>
     {
-        pub fn new(local_channel_id: ChannelId, request_receiver: R1, reply_receiver: R0) -> Self {
+        pub fn new(
+            local_channel_id: ComponentId,
+            request_receiver: R1,
+            reply_receiver: R0,
+        ) -> Self {
             Self {
                 local_channel_id,
                 request_receiver: request_receiver.into(),
@@ -320,7 +324,7 @@ pub mod alloc_mod {
             }
         }
 
-        pub fn local_channel_id_generic(&self) -> ChannelId {
+        pub fn local_channel_id_generic(&self) -> ComponentId {
             self.local_channel_id
         }
     }
@@ -390,9 +394,9 @@ mod tests {
 
     use super::{GenericMessage, MessageReceiverWithId, MessageSenderMapWithId, TargetAndApidId};
 
-    const TEST_CHANNEL_ID_0: u32 = 1;
+    const TEST_CHANNEL_ID_0: u64 = 1;
-    const TEST_CHANNEL_ID_1: u32 = 2;
+    const TEST_CHANNEL_ID_1: u64 = 2;
-    const TEST_CHANNEL_ID_2: u32 = 3;
+    const TEST_CHANNEL_ID_2: u64 = 3;
 
     #[test]
     fn test_basic_target_id_with_apid() {

satrs/tests/mode_tree.rs

@@ -13,7 +13,7 @@ use satrs::{
     mode::{ModeAndSubmode, ModeReply, ModeRequest},
     queue::GenericTargetedMessagingError,
     request::GenericMessage,
-    ChannelId,
+    ComponentId,
 };
 use std::string::{String, ToString};
 
@@ -47,7 +47,7 @@ struct TestDevice {
     pub name: String,
     pub mode_node: ModeRequestHandlerMpscBounded,
     pub mode_and_submode: ModeAndSubmode,
-    pub mode_requestor_info: Option<(RequestId, ChannelId)>,
+    pub mode_requestor_info: Option<(RequestId, ComponentId)>,
     pub action_queue: mpsc::Receiver<GenericMessage<ActionRequest>>,
 }
 
@@ -95,7 +95,7 @@ impl ModeRequestHandler for TestDevice {
     fn start_transition(
         &mut self,
         _request_id: RequestId,
-        _sender_id: ChannelId,
+        _sender_id: ComponentId,
         mode_and_submode: ModeAndSubmode,
     ) -> Result<(), ModeError> {
         self.mode_and_submode = mode_and_submode;
@@ -103,7 +103,7 @@ impl ModeRequestHandler for TestDevice {
         Ok(())
     }
 
-    fn announce_mode(&self, _request_id: RequestId, _sender_id: ChannelId, _recursive: bool) {
+    fn announce_mode(&self, _request_id: RequestId, _sender_id: ComponentId, _recursive: bool) {
         println!(
             "{}: announcing mode: {:?}",
             self.name, self.mode_and_submode
@@ -123,7 +123,7 @@ impl ModeRequestHandler for TestDevice {
 
 struct TestAssembly {
     pub mode_node: ModeRequestorAndHandlerMpscBounded,
-    pub mode_requestor_info: Option<(RequestId, ChannelId)>,
+    pub mode_requestor_info: Option<(RequestId, ComponentId)>,
     pub mode_and_submode: ModeAndSubmode,
     pub target_mode_and_submode: Option<ModeAndSubmode>,
 }
@@ -193,7 +193,7 @@ impl ModeRequestHandler for TestAssembly {
     fn start_transition(
         &mut self,
         request_id: RequestId,
-        sender_id: ChannelId,
+        sender_id: ComponentId,
         mode_and_submode: ModeAndSubmode,
     ) -> Result<(), ModeError> {
         self.mode_requestor_info = Some((request_id, sender_id));
@@ -201,7 +201,7 @@ impl ModeRequestHandler for TestAssembly {
         Ok(())
     }
 
-    fn announce_mode(&self, request_id: RequestId, _sender_id: ChannelId, recursive: bool) {
+    fn announce_mode(&self, request_id: RequestId, _sender_id: ComponentId, recursive: bool) {
         println!(
             "TestAssembly: Announcing mode (recursively: {}): {:?}",
             recursive, self.mode_and_submode