diff --git a/satrs-example/src/eps/pcdu.rs b/satrs-example/src/eps/pcdu.rs index 875b398..0d30e3d 100644 --- a/satrs-example/src/eps/pcdu.rs +++ b/satrs-example/src/eps/pcdu.rs @@ -101,9 +101,7 @@ impl SerialInterface for SerialInterfaceDummy { type Error = (); fn send(&self, data: &[u8]) -> Result<(), Self::Error> { - let sim_req: SimRequest = serde_json::from_slice(data).unwrap(); - let pcdu_req = - PcduRequest::from_sim_message(&sim_req).expect("PCDU request creation failed"); + let pcdu_req: PcduRequest = serde_json::from_slice(data).unwrap(); let switch_map_mut = &mut self.switch_map.borrow_mut().0; match pcdu_req { PcduRequest::SwitchDevice { switch, state } => { @@ -119,7 +117,7 @@ impl SerialInterface for SerialInterfaceDummy { PcduRequest::RequestSwitchInfo => { let mut reply_deque_mut = self.reply_deque.borrow_mut(); reply_deque_mut.push_back(SimReply::new(&PcduReply::SwitchInfo( - self.switch_map.borrow().0.clone(), + switch_map_mut.clone(), ))); } }; @@ -381,10 +379,12 @@ impl PcduHandler { let switch_map_wrapper = SwitchMapWrapper::from_binary_switch_map_ref(&switch_info); - self.shared_switch_map + let mut shared_switch_map = self + .shared_switch_map .lock() - .expect("failed to lock switch map") - .switch_map = switch_map_wrapper.0; + .expect("failed to lock switch map"); + shared_switch_map.switch_map = switch_map_wrapper.0; + shared_switch_map.valid = true; } } }) { @@ -480,8 +480,11 @@ impl ModeRequestHandler mod tests { use std::sync::mpsc; - use satrs::{mode::ModeRequest, request::GenericMessage, tmtc::PacketAsVec}; - use satrs_example::config::components::Apid; + use satrs::{ + mode::ModeRequest, power::SwitchStateBinary, request::GenericMessage, tmtc::PacketAsVec, + }; + use satrs_example::config::components::{Apid, MGM_HANDLER_0}; + use satrs_minisim::eps::SwitchMapBinary; use super::*; @@ -567,6 +570,51 @@ mod tests { ), } } + + pub fn verify_switch_info_req_was_sent(&self, expected_queue_len: usize) { + // Check that there is now communication happening. + let mut send_queue_mut = self.handler.com_interface.send_queue.borrow_mut(); + assert_eq!(send_queue_mut.len(), expected_queue_len); + let packet_sent = send_queue_mut.pop_front().unwrap(); + drop(send_queue_mut); + let pcdu_req: PcduRequest = serde_json::from_slice(&packet_sent).unwrap(); + assert_eq!(pcdu_req, PcduRequest::RequestSwitchInfo); + } + + pub fn verify_switch_req_was_sent( + &self, + expected_queue_len: usize, + switch_id: PcduSwitch, + target_state: SwitchStateBinary, + ) { + // Check that there is now communication happening. + let mut send_queue_mut = self.handler.com_interface.send_queue.borrow_mut(); + assert_eq!(send_queue_mut.len(), expected_queue_len); + let packet_sent = send_queue_mut.pop_front().unwrap(); + drop(send_queue_mut); + let pcdu_req: PcduRequest = serde_json::from_slice(&packet_sent).unwrap(); + assert_eq!( + pcdu_req, + PcduRequest::SwitchDevice { + switch: switch_id, + state: target_state + } + ) + } + + pub fn verify_switch_reply_received( + &self, + expected_queue_len: usize, + expected_map: SwitchMapBinary, + ) { + // Check that a switch reply was read back. + let mut reply_received_mut = self.handler.com_interface.reply_queue.borrow_mut(); + assert_eq!(reply_received_mut.len(), expected_queue_len); + let reply_received = reply_received_mut.pop_front().unwrap(); + let sim_reply: SimReply = serde_json::from_str(&reply_received).unwrap(); + let pcdu_reply = PcduReply::from_sim_message(&sim_reply).unwrap(); + assert_eq!(pcdu_reply, PcduReply::SwitchInfo(expected_map)); + } } #[test] @@ -598,4 +646,71 @@ mod tests { ); assert_eq!(testbench.handler.mode_and_submode().submode(), 0_u16); } + + #[test] + fn test_normal_mode() { + let mut testbench = PcduTestbench::new(); + testbench + .mode_request_tx + .send(GenericMessage::new( + MessageMetadata::new(0, PUS_MODE_SERVICE.id()), + ModeRequest::SetMode(ModeAndSubmode::new(DeviceMode::Normal as u32, 0)), + )) + .expect("failed to send mode request"); + let switch_map_shared = testbench.handler.shared_switch_map.lock().unwrap(); + assert!(!switch_map_shared.valid); + drop(switch_map_shared); + testbench.handler.periodic_operation(OpCode::RegularOp); + testbench + .handler + .periodic_operation(OpCode::PollAndRecvReplies); + // Check correctness of mode. + assert_eq!( + testbench.handler.mode_and_submode().mode(), + DeviceMode::Normal as u32 + ); + assert_eq!(testbench.handler.mode_and_submode().submode(), 0); + + testbench.verify_switch_info_req_was_sent(1); + testbench.verify_switch_reply_received(1, SwitchMapBinaryWrapper::default().0); + + let switch_map_shared = testbench.handler.shared_switch_map.lock().unwrap(); + assert!(switch_map_shared.valid); + drop(switch_map_shared); + } + + #[test] + fn test_switch_request_handling() { + let mut testbench = PcduTestbench::new(); + testbench + .mode_request_tx + .send(GenericMessage::new( + MessageMetadata::new(0, PUS_MODE_SERVICE.id()), + ModeRequest::SetMode(ModeAndSubmode::new(DeviceMode::Normal as u32, 0)), + )) + .expect("failed to send mode request"); + testbench + .switch_request_tx + .send(GenericMessage::new( + MessageMetadata::new(0, MGM_HANDLER_0.id()), + SwitchRequest::new(0, SwitchStateBinary::On), + )) + .expect("failed to send switch request"); + testbench.handler.periodic_operation(OpCode::RegularOp); + testbench + .handler + .periodic_operation(OpCode::PollAndRecvReplies); + + testbench.verify_switch_req_was_sent(2, PcduSwitch::Mgm, SwitchStateBinary::On); + testbench.verify_switch_info_req_was_sent(1); + let mut switch_map = SwitchMapBinaryWrapper::default().0; + *switch_map + .get_mut(&PcduSwitch::Mgm) + .expect("switch state setting failed") = SwitchStateBinary::On; + testbench.verify_switch_reply_received(1, switch_map); + + let switch_map_shared = testbench.handler.shared_switch_map.lock().unwrap(); + assert!(switch_map_shared.valid); + drop(switch_map_shared); + } } diff --git a/satrs-minisim/src/lib.rs b/satrs-minisim/src/lib.rs index eb1b420..b3b7d44 100644 --- a/satrs-minisim/src/lib.rs +++ b/satrs-minisim/src/lib.rs @@ -236,7 +236,7 @@ pub mod eps { RequestSwitchInfo = 1, } - #[derive(Debug, Copy, Clone, Serialize, Deserialize)] + #[derive(Debug, Copy, Clone, PartialEq, Eq, Serialize, Deserialize)] pub enum PcduRequest { SwitchDevice { switch: PcduSwitch,