clean up a bit

satrs-example/src/eps/pcdu.rs

@@ -536,7 +536,6 @@ mod tests {
         pcdu::{SwitchMapBinary, SwitchStateBinary},
     };
     use satrs::{
-        mode::{ModeReply, ModeRequest},
         request::{GenericMessage, MessageMetadata},
         spacepackets::SpacePacketHeader,
     };
@@ -590,8 +589,8 @@ mod tests {
 
     #[allow(dead_code)]
     pub struct PcduTestbench {
-        pub mode_request_tx: mpsc::SyncSender<GenericMessage<ModeRequest>>,
-        pub mode_reply_rx_to_parent: mpsc::Receiver<GenericMessage<ModeReply>>,
+        pub mode_request_tx: mpsc::SyncSender<models::pcdu::request::Request>,
+        pub mode_reply_rx_to_parent: mpsc::Receiver<models::pcdu::response::Response>,
         pub tc_tx: mpsc::SyncSender<CcsdsTcPacketOwned>,
         pub tm_rx: mpsc::Receiver<CcsdsTmPacketOwned>,
         pub switch_request_tx: mpsc::Sender<GenericMessage<SwitchRequest>>,

satrs-example/src/main.rs

@@ -23,16 +23,13 @@ use logger::setup_logger;
 use models::{ComponentId, DeviceMode};
 use satrs::{
     hal::std::{tcp_server::ServerConfig, udp_server::UdpTcServer},
-    mode::{Mode, ModeAndSubmode, ModeRequest},
     pus::HandlingStatus,
-    request::{GenericMessage, MessageMetadata},
     spacepackets::time::cds::CdsTime,
 };
 use satrs_example::{
     TmtcQueues,
     config::{
         OBSW_SERVER_ADDR, PACKET_ID_VALIDATOR, SERVER_PORT,
-        components::NO_SENDER,
         tasks::{FREQ_MS_AOCS, FREQ_MS_CONTROLLER, FREQ_MS_UDP_TMTC, SIM_CLIENT_IDLE_DELAY_MS},
     },
 };
@@ -266,13 +263,7 @@ fn main() {
 
     // The PCDU is a critical component which should be in normal mode immediately.
     pcdu_handler_mode_tx
-        .send(GenericMessage::new(
-            MessageMetadata::new(0, NO_SENDER),
-            ModeRequest::SetMode {
-                mode_and_submode: ModeAndSubmode::new(DeviceMode::Normal as Mode, 0),
-                forced: false,
-            },
-        ))
+        .send(models::pcdu::request::Request::Mode(DeviceMode::Normal))
         .expect("sending initial mode request failed");
 
     info!("Starting TMTC and UDP task");

satrs/src/pus/mode.rs

@@ -32,126 +32,4 @@ pub mod alloc_mod {}
 pub mod std_mod {}
 
 #[cfg(test)]
-mod tests {
-
-    use std::sync::mpsc;
-
-    use crate::{
-        ComponentId,
-        mode::{
-            ModeAndSubmode, ModeReply, ModeReplySender, ModeRequest, ModeRequestSender,
-            ModeRequestorAndHandlerMpsc, ModeRequestorOneChildMpsc,
-        },
-        request::{GenericMessage, MessageMetadata},
-    };
-
-    const TEST_COMPONENT_ID_0: ComponentId = 5;
-    const TEST_COMPONENT_ID_1: ComponentId = 6;
-    const TEST_COMPONENT_ID_2: ComponentId = 7;
-
-    #[test]
-    fn test_simple_mode_requestor() {
-        let (reply_sender, reply_receiver) = mpsc::channel();
-        let (request_sender, request_receiver) = mpsc::channel();
-        let mut mode_requestor =
-            ModeRequestorOneChildMpsc::new(TEST_COMPONENT_ID_0, reply_receiver);
-        mode_requestor.add_message_target(TEST_COMPONENT_ID_1, request_sender);
-
-        // Send a request and verify it arrives at the receiver.
-        let request_id = 2;
-        let sent_request = ModeRequest::ReadMode;
-        mode_requestor
-            .send_mode_request(request_id, TEST_COMPONENT_ID_1, sent_request)
-            .expect("send failed");
-        let request = request_receiver.recv().expect("recv failed");
-        assert_eq!(request.request_id(), 2);
-        assert_eq!(request.sender_id(), TEST_COMPONENT_ID_0);
-        assert_eq!(request.message, sent_request);
-
-        // Send a reply and verify it arrives at the requestor.
-        let mode_reply = ModeReply::ModeReply(ModeAndSubmode::new(1, 5));
-        reply_sender
-            .send(GenericMessage::new(
-                MessageMetadata::new(request_id, TEST_COMPONENT_ID_1),
-                mode_reply,
-            ))
-            .expect("send failed");
-        let reply = mode_requestor.try_recv_mode_reply().expect("recv failed");
-        assert!(reply.is_some());
-        let reply = reply.unwrap();
-        assert_eq!(reply.sender_id(), TEST_COMPONENT_ID_1);
-        assert_eq!(reply.request_id(), 2);
-        assert_eq!(reply.message, mode_reply);
-    }
-
-    #[test]
-    fn test_mode_requestor_and_request_handler_request_sending() {
-        let (_reply_sender_to_connector, reply_receiver_of_connector) = mpsc::channel();
-        let (_request_sender_to_connector, request_receiver_of_connector) = mpsc::channel();
-
-        let (request_sender_to_channel_1, request_receiver_channel_1) = mpsc::channel();
-        //let (reply_sender_to_channel_2, reply_receiver_channel_2) = mpsc::channel();
-        let mut mode_connector = ModeRequestorAndHandlerMpsc::new(
-            TEST_COMPONENT_ID_0,
-            request_receiver_of_connector,
-            reply_receiver_of_connector,
-        );
-        assert_eq!(
-            ModeRequestSender::local_channel_id(&mode_connector),
-            TEST_COMPONENT_ID_0
-        );
-        assert_eq!(
-            ModeReplySender::local_channel_id(&mode_connector),
-            TEST_COMPONENT_ID_0
-        );
-        assert_eq!(
-            mode_connector.local_channel_id_generic(),
-            TEST_COMPONENT_ID_0
-        );
-
-        mode_connector.add_request_target(TEST_COMPONENT_ID_1, request_sender_to_channel_1);
-
-        // Send a request and verify it arrives at the receiver.
-        let request_id = 2;
-        let sent_request = ModeRequest::ReadMode;
-        mode_connector
-            .send_mode_request(request_id, TEST_COMPONENT_ID_1, sent_request)
-            .expect("send failed");
-
-        let request = request_receiver_channel_1.recv().expect("recv failed");
-        assert_eq!(request.request_id(), 2);
-        assert_eq!(request.sender_id(), TEST_COMPONENT_ID_0);
-        assert_eq!(request.message, ModeRequest::ReadMode);
-    }
-
-    #[test]
-    fn test_mode_requestor_and_request_handler_reply_sending() {
-        let (_reply_sender_to_connector, reply_receiver_of_connector) = mpsc::channel();
-        let (_request_sender_to_connector, request_receiver_of_connector) = mpsc::channel();
-
-        let (reply_sender_to_channel_2, reply_receiver_channel_2) = mpsc::channel();
-        let mut mode_connector = ModeRequestorAndHandlerMpsc::new(
-            TEST_COMPONENT_ID_0,
-            request_receiver_of_connector,
-            reply_receiver_of_connector,
-        );
-        mode_connector.add_reply_target(TEST_COMPONENT_ID_2, reply_sender_to_channel_2);
-
-        // Send a reply and verify it arrives at the receiver.
-        let request_id = 2;
-        let sent_reply = ModeReply::ModeReply(ModeAndSubmode::new(3, 5));
-        mode_connector
-            .send_mode_reply(
-                MessageMetadata::new(request_id, TEST_COMPONENT_ID_2),
-                sent_reply,
-            )
-            .expect("send failed");
-        let reply = reply_receiver_channel_2.recv().expect("recv failed");
-        assert_eq!(reply.request_id(), 2);
-        assert_eq!(reply.sender_id(), TEST_COMPONENT_ID_0);
-        assert_eq!(reply.message, sent_reply);
-    }
-
-    #[test]
-    fn test_mode_reply_handler() {}
-}
+mod tests {}

satrs/src/subsystem.rs

@@ -350,7 +350,7 @@ pub struct SubsystemCommandingHelper {
 impl Default for SubsystemCommandingHelper {
     fn default() -> Self {
         Self {
-            current_mode: 0,
+            current_mode: u32::MAX,
             state: Default::default(),
             children_mode_store: Default::default(),
             active_internal_request_id: None,