satrs/src/mode_tree.rs

@@ -75,12 +75,12 @@ pub trait ModeReplySendProvider {
     ) -> Result<(), ModeMessagingError>;
 }
 
-pub struct StandardModeReplySender {
+pub struct MpscModeReplyRouter {
     pub local_id: ChannelId,
-    pub reply_sender_map: HashMap<ChannelId, mpsc::Sender<ModeReply>>,
+    pub reply_sender_map: HashMap<ChannelId, mpsc::Sender<ModeReplyWithSenderId>>,
 }
 
-impl ModeReplySendProvider for StandardModeReplySender {
+impl ModeReplySendProvider for MpscModeReplyRouter {
     fn send_mode_reply(
         &mut self,
         target_channel_id: ChannelId,
@@ -90,7 +90,10 @@ impl ModeReplySendProvider for StandardModeReplySender {
             self.reply_sender_map
                 .get(&target_channel_id)
                 .unwrap()
-                .send(reply)
+                .send(ModeReplyWithSenderId {
+                    sender_id: self.local_channel_id(),
+                    reply,
+                })
                 .map_err(|_| GenericSendError::RxDisconnected)?;
             return Ok(());
         }
@@ -102,7 +105,7 @@ impl ModeReplySendProvider for StandardModeReplySender {
     }
 }
 
-impl StandardModeReplySender {
+impl MpscModeReplyRouter {
     pub fn new(local_id: ChannelId) -> Self {
         Self {
             local_id,
@@ -113,61 +116,99 @@ impl StandardModeReplySender {
     pub fn add_reply_target(
         &mut self,
         target_id: ChannelId,
-        reply_sender: mpsc::Sender<ModeReply>,
+        reply_sender: mpsc::Sender<ModeReplyWithSenderId>,
     ) {
         self.reply_sender_map.insert(target_id, reply_sender);
     }
 }
 
-pub struct ModeReplyTuple {
+pub struct ModeReplyWithSenderId {
     pub sender_id: ChannelId,
     pub reply: ModeReply,
 }
 
 pub trait ModeReplyReceiver {
-    fn try_recv_mode_reply(&self) -> Result<Option<ModeReplyTuple>, ModeMessagingError>;
+    fn try_recv_mode_reply(&self) -> Result<Option<ModeReplyWithSenderId>, ModeMessagingError>;
 }
 
-pub struct StandardModeReplyReceiver {
+pub struct MpscModeReplyReceiver {
-    pub sender_id: ChannelId,
+    local_channel_id: ChannelId,
-    pub receiver: mpsc::Receiver<ModeReply>,
+    reply_receiver: mpsc::Receiver<ModeReplyWithSenderId>,
 }
 
-#[derive(Default)]
+impl MpscModeReplyReceiver {
-pub struct StandardModeReplyReceiverList {
+    pub fn new(
-    pub reply_receiver_vec: Vec<StandardModeReplyReceiver>,
+        local_channel_id: ChannelId,
-}
+        reply_receiver: mpsc::Receiver<ModeReplyWithSenderId>,
+    ) -> Self {
+        Self {
+            local_channel_id,
+            reply_receiver,
+        }
+    }
 
-impl StandardModeReplyReceiverList {
+    pub fn local_channel_id(&self) -> ChannelId {
-    pub fn add_reply_receiver(
+        self.local_channel_id
-        &mut self,
-        sender_id: ChannelId,
-        receiver: mpsc::Receiver<ModeReply>,
-    ) {
-        self.reply_receiver_vec.push(StandardModeReplyReceiver {
-            sender_id,
-            receiver,
-        });
     }
 }
 
-impl ModeReplyReceiver for StandardModeReplyReceiverList {
+impl ModeReplyReceiver for MpscModeReplyReceiver {
-    fn try_recv_mode_reply(&self) -> Result<Option<ModeReplyTuple>, ModeMessagingError> {
+    fn try_recv_mode_reply(&self) -> Result<Option<ModeReplyWithSenderId>, ModeMessagingError> {
-        for reply_receiver in &self.reply_receiver_vec {
+        match self.reply_receiver.try_recv() {
-            match reply_receiver.receiver.try_recv() {
+            Ok(reply) => {
-                Ok(reply) => {
+                return Ok(Some(reply));
-                    return Ok(Some(ModeReplyTuple {
+            }
-                        sender_id: reply_receiver.sender_id,
+            Err(e) => {
-                        reply,
+                if e == mpsc::TryRecvError::Disconnected {
-                    }))
+                    return Err(
+                        GenericReceiveError::TxDisconnected(Some(self.local_channel_id())).into(),
+                    );
                 }
-                Err(e) => {
+            }
-                    if e == mpsc::TryRecvError::Disconnected {
+        }
-                        return Err(GenericReceiveError::TxDisconnected(Some(
+        Ok(None)
-                            reply_receiver.sender_id,
+    }
-                        ))
+}
-                        .into());
+
-                    }
+pub trait ModeRequestReceiver {
+    fn try_recv_mode_reply(&self) -> Result<Option<ModeRequestWithSenderId>, ModeMessagingError>;
+}
+
+pub struct MpscModeRequestReceiver {
+    local_channel_id: ChannelId,
+    receiver: mpsc::Receiver<ModeRequestWithSenderId>,
+}
+
+impl MpscModeRequestReceiver {
+    pub fn new(
+        local_channel_id: ChannelId,
+        receiver: mpsc::Receiver<ModeRequestWithSenderId>,
+    ) -> Self {
+        Self {
+            local_channel_id,
+            receiver,
+        }
+    }
+
+    pub fn local_channel_id(&self) -> ChannelId {
+        self.local_channel_id
+    }
+}
+
+impl ModeRequestReceiver for MpscModeRequestReceiver {
+    fn try_recv_mode_reply(&self) -> Result<Option<ModeRequestWithSenderId>, ModeMessagingError> {
+        match self.receiver.try_recv() {
+            Ok(request_and_sender) => {
+                return Ok(Some(ModeRequestWithSenderId {
+                    sender_id: request_and_sender.sender_id,
+                    request: request_and_sender.request,
+                }))
+            }
+            Err(e) => {
+                if e == mpsc::TryRecvError::Disconnected {
+                    return Err(
+                        GenericReceiveError::TxDisconnected(Some(self.local_channel_id)).into(),
+                    );
                 }
             }
         }
@@ -178,20 +219,20 @@ impl ModeReplyReceiver for StandardModeReplyReceiverList {
 pub trait ModeRequestSendProvider {
     fn local_channel_id(&self) -> Option<ChannelId>;
     fn send_mode_request(
-        &mut self,
+        &self,
         target_id: ChannelId,
         request: ModeRequest,
     ) -> Result<(), ModeMessagingError>;
 }
 
-pub struct StandardModeRequestSender {
+pub struct MpscModeRequestRouter {
     pub local_channel_id: ChannelId,
     pub request_sender_map: HashMap<ChannelId, mpsc::Sender<ModeRequestWithSenderId>>,
 }
 
-impl ModeRequestSendProvider for StandardModeRequestSender {
+impl ModeRequestSendProvider for MpscModeRequestRouter {
     fn send_mode_request(
-        &mut self,
+        &self,
         target_id: ChannelId,
         request: ModeRequest,
     ) -> Result<(), ModeMessagingError> {
@@ -199,10 +240,10 @@ impl ModeRequestSendProvider for StandardModeRequestSender {
             self.request_sender_map
                 .get(&target_id)
                 .unwrap()
-                .send(ModeRequestWithSenderId {
+                .send(ModeRequestWithSenderId::new(
-                    sender_id: target_id,
+                    self.local_channel_id().unwrap(),
                     request,
-                })
+                ))
                 .map_err(|_| GenericSendError::RxDisconnected)?;
             return Ok(());
         }
@@ -214,7 +255,7 @@ impl ModeRequestSendProvider for StandardModeRequestSender {
     }
 }
 
-impl StandardModeRequestSender {
+impl MpscModeRequestRouter {
     pub fn new(local_channel_id: ChannelId) -> Self {
         Self {
             local_channel_id,
@@ -251,38 +292,59 @@ pub trait ModeRequestHandler: ModeProvider {
 mod tests {
     use std::{println, sync::mpsc};
 
-    use hashbrown::HashMap;
+    use super::*;
-
     use crate::{
         mode::{ModeAndSubmode, ModeReply, ModeRequest},
         mode_tree::ModeRequestSendProvider,
         ChannelId,
     };
 
-    use super::{
+    pub enum TestChannelId {
-        ModeMessagingError, ModeProvider, ModeReplySendProvider, ModeRequestHandler,
+        Device1 = 1,
-        ModeRequestWithSenderId, StandardModeReplyReceiverList, StandardModeReplySender,
+        Device2 = 2,
-        StandardModeRequestSender,
+        Assembly = 3,
-    };
+        PusModeService = 4,
+    }
+
+    struct PusModeService {
+        // This contains ALL objects which are able to process mode requests.
+        pub mode_request_recipients: MpscModeRequestRouter,
+        // This contains all reply receivers for request recipients.
+        pub mode_reply_receiver_list: MpscModeReplyReceiver,
+    }
+
+    impl PusModeService {
+        pub fn send_announce_mode_cmd_to_assy(&self) {
+            self.mode_request_recipients
+                .send_mode_request(
+                    TestChannelId::Assembly as u32,
+                    ModeRequest::AnnounceModeRecursive,
+                )
+                .unwrap();
+        }
+    }
 
     struct TestDevice {
-        /// One receiver handle for all mode requests.
+        // This object is used to receive all mode requests, for example by the PUS Mode service
-        pub mode_req_receiver: mpsc::Receiver<ModeRequestWithSenderId>,
+        // or by the parent assembly.
-        /// This structure contains all handles to send mode replies.
+        pub mode_request_receiver: MpscModeRequestReceiver,
-        pub mode_reply_sender: StandardModeReplySender,
+        // This structure contains all handles to send mode replies back to the senders.
-        pub last_mode_sender: Option<ChannelId>,
+        pub mode_reply_router: MpscModeReplyRouter,
+        // Used to cache the receiver for mode replies.
+        pub mode_reply_receiver: Option<ChannelId>,
         pub mode_and_submode: ModeAndSubmode,
         pub target_mode_and_submode: Option<ModeAndSubmode>,
     }
 
     struct TestAssembly {
-        /// One receiver handle for all mode requests.
+        // This object is used to receive all mode requests, for example by the PUS Mode service
-        pub mode_req_receiver: mpsc::Receiver<ModeRequestWithSenderId>,
+        // or by the parent subsystem.
-        /// This structure contains all handles to send mode replies.
+        pub mode_request_receiver: MpscModeRequestReceiver,
-        pub mode_reply_sender: StandardModeReplySender,
+        pub mode_reply_receiver: MpscModeReplyReceiver,
-        /// This structure contains all handles to send mode requests to its children.
+        // This structure contains all handles to send mode replies.
-        pub mode_children_map: StandardModeRequestSender,
+        pub mode_reply_senders: MpscModeReplyRouter,
-        pub mode_reply_receiver_list: StandardModeReplyReceiverList,
+        // This structure contains all handles to send mode requests to its children.
+        pub mode_request_senders: MpscModeRequestRouter,
         pub last_mode_sender: Option<ChannelId>,
         pub mode_and_submode: ModeAndSubmode,
         pub target_mode_and_submode: Option<ModeAndSubmode>,
@@ -296,11 +358,18 @@ mod tests {
 
     impl TestAssembly {
         pub fn run(&mut self) {
-            self.check_mode_requests()
+            // self.check_mode_requests()
         }
 
-        pub fn check_mode_requests(&mut self) {
+        /*
-            match self.mode_req_receiver.try_recv() {
+        pub fn check_mode_requests(&mut self) -> Result<(), ModeMessagingError> {
+            match self.mode_request_receiver_list.try_recv_mode_reply()? {
+                Some(request_and_id) => {
+                    match request_and_id {
+
+                    }
+
+                }
                 Ok(ModeRequestWithSenderId { sender_id, request }) => {
                     match request {
                         ModeRequest::SetMode(mode_and_submode) => {
@@ -322,7 +391,7 @@ mod tests {
                 }
                 Err(_) => todo!(),
             };
-        }
+        } */
     }
 
     impl ModeRequestHandler for TestAssembly {
@@ -343,13 +412,13 @@ mod tests {
             if recursive {
                 mode_request = ModeRequest::AnnounceModeRecursive;
             }
-            self.mode_children_map
+            self.mode_request_senders
                 .request_sender_map
                 .iter()
                 .for_each(|(_, sender)| {
                     sender
                         .send(ModeRequestWithSenderId::new(
-                            self.mode_children_map.local_channel_id().unwrap(),
+                            self.mode_request_senders.local_channel_id().unwrap(),
                             mode_request,
                         ))
                         .expect("sending mode request failed");
@@ -357,7 +426,7 @@ mod tests {
         }
 
         fn handle_mode_reached(&mut self) -> Result<(), ModeMessagingError> {
-            self.mode_reply_sender.send_mode_reply(
+            self.mode_reply_senders.send_mode_reply(
                 self.last_mode_sender.unwrap(),
                 ModeReply::ModeReply(self.mode_and_submode),
             )?;
@@ -365,42 +434,105 @@ mod tests {
         }
     }
 
-    pub enum TestChannelId {
-        Device1 = 1,
-        Device2 = 2,
-        Assembly = 3,
-    }
     #[test]
     fn basic_test() {
-        let (dev1_sender, dev1_receiver) = mpsc::channel();
+        // All request channel handles.
-        let (dev2_sender, dev2_receiver) = mpsc::channel();
+        let (request_sender_to_dev1, request_receiver_dev1) = mpsc::channel();
-        let mut mode_reply_sender_dev1 =
+        let (request_sender_to_dev2, request_receiver_dev2) = mpsc::channel();
-            StandardModeReplySender::new(TestChannelId::Device1 as u32);
+        let (request_sender_to_assy, request_receiver_assy) = mpsc::channel();
-        let mut mode_reply_sender_dev2 =
-            StandardModeReplySender::new(TestChannelId::Device2 as u32);
-        let mut mode_request_map_assy =
-            StandardModeRequestSender::new(TestChannelId::Assembly as u32);
-        let mut mode_reply_map_assy = StandardModeReplySender::new(TestChannelId::Assembly as u32);
 
-        let (dev1_reply_sender, assy_reply_receiver_dev1) = mpsc::channel();
+        // All reply channel handles.
-        let (dev2_reply_sender, assy_reply_receiver_dev2) = mpsc::channel();
+        let (reply_sender_to_assy, reply_receiver_assy) = mpsc::channel();
-        mode_reply_sender_dev1.add_reply_target(TestChannelId::Assembly as u32, dev1_reply_sender);
+        let (reply_sender_to_pus, reply_receiver_pus) = mpsc::channel();
-        mode_reply_sender_dev2.add_reply_target(TestChannelId::Assembly as u32, dev2_reply_sender);
+
-        //mode_reply_map_assy.add_reply_target(target_id, reply_sender)
+        // All request routers.
+        let mut mode_request_router_assy =
+            MpscModeRequestRouter::new(TestChannelId::Assembly as u32);
+        let mut mode_request_router_pus_mode =
+            MpscModeRequestRouter::new(TestChannelId::PusModeService as u32);
+
+        // All request receivers.
+        let mode_request_receiver_dev1 =
+            MpscModeRequestReceiver::new(TestChannelId::Device1 as u32, request_receiver_dev1);
+        let mode_request_receiver_dev2 =
+            MpscModeRequestReceiver::new(TestChannelId::Device2 as u32, request_receiver_dev2);
+        let mode_request_receiver_assy =
+            MpscModeRequestReceiver::new(TestChannelId::Assembly as u32, request_receiver_assy);
+
+        // All reply senders.
+        let mut mode_reply_senders_dev1 = MpscModeReplyRouter::new(TestChannelId::Device1 as u32);
+        let mut mode_reply_senders_dev2 = MpscModeReplyRouter::new(TestChannelId::Device2 as u32);
+        let mut mode_reply_senders_assy = MpscModeReplyRouter::new(TestChannelId::Assembly as u32);
+
+        // All reply receivers.
+        let mode_reply_receiver_list_assy =
+            MpscModeReplyReceiver::new(TestChannelId::Assembly as u32, reply_receiver_assy);
+        let mode_reply_receiver_pus_service =
+            MpscModeReplyReceiver::new(TestChannelId::PusModeService as u32, reply_receiver_pus);
+
+        // Set up mode request senders first.
+        mode_request_router_pus_mode
+            .add_request_target(TestChannelId::Assembly as u32, request_sender_to_assy);
+        mode_request_router_pus_mode.add_request_target(
+            TestChannelId::Device1 as u32,
+            request_sender_to_dev1.clone(),
+        );
+        mode_request_router_pus_mode.add_request_target(
+            TestChannelId::Device2 as u32,
+            request_sender_to_dev2.clone(),
+        );
+        mode_request_router_assy
+            .add_request_target(TestChannelId::Device1 as u32, request_sender_to_dev1);
+        mode_request_router_assy
+            .add_request_target(TestChannelId::Device2 as u32, request_sender_to_dev2);
+
+        // Set up mode reply senders.
+        mode_reply_senders_dev1
+            .add_reply_target(TestChannelId::Assembly as u32, reply_sender_to_assy.clone());
+        mode_reply_senders_dev1.add_reply_target(
+            TestChannelId::PusModeService as u32,
+            reply_sender_to_pus.clone(),
+        );
+        mode_reply_senders_dev2
+            .add_reply_target(TestChannelId::Assembly as u32, reply_sender_to_assy);
+        mode_reply_senders_dev2.add_reply_target(
+            TestChannelId::PusModeService as u32,
+            reply_sender_to_pus.clone(),
+        );
+        mode_reply_senders_assy
+            .add_reply_target(TestChannelId::PusModeService as u32, reply_sender_to_pus);
 
         let device1 = TestDevice {
-            mode_req_receiver: dev1_receiver,
+            mode_request_receiver: mode_request_receiver_dev1,
-            mode_reply_sender: mode_reply_sender_dev1,
+            mode_reply_router: mode_reply_senders_dev1,
-            last_mode_sender: None,
+            mode_reply_receiver: None,
             mode_and_submode: ModeAndSubmode::new(0, 0),
             target_mode_and_submode: None,
         };
         let device2 = TestDevice {
-            mode_req_receiver: dev2_receiver,
+            mode_request_receiver: mode_request_receiver_dev2,
-            mode_reply_sender: mode_reply_sender_dev2,
+            mode_reply_router: mode_reply_senders_dev2,
+            mode_reply_receiver: None,
+            mode_and_submode: ModeAndSubmode::new(0, 0),
+            target_mode_and_submode: None,
+        };
+        let assy = TestAssembly {
+            mode_request_receiver: mode_request_receiver_assy,
+            mode_reply_senders: mode_reply_senders_assy,
+            mode_request_senders: mode_request_router_assy,
+            mode_reply_receiver: mode_reply_receiver_list_assy,
             last_mode_sender: None,
             mode_and_submode: ModeAndSubmode::new(0, 0),
             target_mode_and_submode: None,
         };
+        let pus_service = PusModeService {
+            mode_request_recipients: mode_request_router_pus_mode,
+            mode_reply_receiver_list: mode_reply_receiver_pus_service,
+        };
+
+        pus_service.send_announce_mode_cmd_to_assy();
+        // assy.run();
+        // device1.run();
+        // device2.run();
     }
 }

satrs/src/pus/mod.rs

@@ -485,9 +485,9 @@ pub mod std_mod {
         fn recv_tc(&self) -> Result<EcssTcAndToken, TryRecvTmtcError> {
             self.receiver.try_recv().map_err(|e| match e {
                 TryRecvError::Empty => TryRecvTmtcError::Empty,
-                TryRecvError::Disconnected => {
+                TryRecvError::Disconnected => TryRecvTmtcError::Error(EcssTmtcError::from(
-                    TryRecvTmtcError::Error(EcssTmtcError::from(GenericReceiveError::TxDisconnected(Some(self.id()))))
+                    GenericReceiveError::TxDisconnected(Some(self.id())),
-                }
+                )),
             })
         }
     }
@@ -625,9 +625,9 @@ pub mod std_mod {
         fn recv_tc(&self) -> Result<EcssTcAndToken, TryRecvTmtcError> {
             self.receiver.try_recv().map_err(|e| match e {
                 cb::TryRecvError::Empty => TryRecvTmtcError::Empty,
-                cb::TryRecvError::Disconnected => {
+                cb::TryRecvError::Disconnected => TryRecvTmtcError::Error(EcssTmtcError::from(
-                    TryRecvTmtcError::Error(EcssTmtcError::from(GenericReceiveError::TxDisconnected(Some(self.id()))))
+                    GenericReceiveError::TxDisconnected(Some(self.id())),
-                }
+                )),
             })
         }
     }

satrs/src/queue.rs

@@ -32,7 +32,7 @@ impl Error for GenericSendError {}
 #[derive(Debug, Copy, Clone)]
 pub enum GenericReceiveError {
     Empty,
-    TxDisconnected(Option<ChannelId>)
+    TxDisconnected(Option<ChannelId>),
 }
 
 impl Display for GenericReceiveError {