rust/sat-rs
rust/sat-rs
5
1
Fork 0
Code Issues 9 Pull Requests Projects Releases 22 Wiki Activity

command propagation works

Browse Source
This commit is contained in:
Robin Müller 2025-01-20 10:53:51 +01:00
parent a6aa20d09b
commit 7f674dd5bf
1 changed files with 52 additions and 49 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

101
satrs/tests/mode_tree.rs
View File

@ -453,7 +453,6 @@ struct AcsSubsystem {
pub target_mode_and_submode: Option<ModeAndSubmode>, pub target_mode_and_submode: Option<ModeAndSubmode>,
pub subsystem_helper: SubsystemCommandingHelper, pub subsystem_helper: SubsystemCommandingHelper,
pub mode_req_handler_mock: ModeRequestHandlerMock, pub mode_req_handler_mock: ModeRequestHandlerMock,
pub mode_req_recvd: u32,
} }
impl AcsSubsystem { impl AcsSubsystem {
@ -464,58 +463,52 @@ impl AcsSubsystem {
target_mode_and_submode: None, target_mode_and_submode: None,
subsystem_helper: SubsystemCommandingHelper::default(), subsystem_helper: SubsystemCommandingHelper::default(),
mode_req_handler_mock: Default::default(), mode_req_handler_mock: Default::default(),
mode_req_recvd: 0,
} }
} }
pub fn get_and_clear_num_mode_requests(&mut self) -> u32 { pub fn get_num_mode_requests(&mut self) -> usize {
let tmp = self.mode_req_recvd; self.mode_req_handler_mock.mode_messages_received()
self.mode_req_recvd = 0;
tmp
} }
pub fn run(&mut self) { pub fn run(&mut self) {
if let Some(request) = self.mode_node.try_recv_mode_request().unwrap() { while let Some(request) = self.mode_node.try_recv_mode_request().unwrap() {
self.mode_req_recvd += 1;
self.handle_mode_request(request) self.handle_mode_request(request)
.expect("mode messaging error"); .expect("mode messaging error");
} }
let mut mode_reply = None;
if let Some(reply) = self.mode_node.try_recv_mode_reply().unwrap() { let mut received_reply = false;
mode_reply = Some(reply); while let Some(mode_reply) = self.mode_node.try_recv_mode_reply().unwrap() {
} received_reply = true;
match self match self
.subsystem_helper .subsystem_helper
.state_machine(mode_reply, &self.mode_node) .state_machine(Some(mode_reply), &self.mode_node)
{ {
Ok(result) => match result { Ok(result) => {
SubsystemHelperResult::Idle => (), if let SubsystemHelperResult::TargetKeeping(target_keeping_result) = result {
SubsystemHelperResult::TargetKeeping(target_keeping_result) => { match target_keeping_result {
match target_keeping_result { TargetKeepingResult::Ok => (),
TargetKeepingResult::Ok => todo!(), TargetKeepingResult::Violated { fallback_mode } => {
TargetKeepingResult::Violated { fallback_mode } => { if let Some(fallback_mode) = fallback_mode {
if let Some(fallback_mode) = fallback_mode { self.subsystem_helper
self.subsystem_helper .start_command_sequence(fallback_mode, 0)
.start_command_sequence(fallback_mode, 0) .unwrap();
.unwrap(); }
} }
} }
} }
} }
SubsystemHelperResult::ModeCommanding(sequence_handler_result) => { Err(error) => match error {
match sequence_handler_result { ModeTreeHelperError::Message(_generic_targeted_messaging_error) => {
ModeCommandingResult::CommandingDone => (), panic!("messaging error")
ModeCommandingResult::CommandingStepDone => (),
ModeCommandingResult::AwaitingSuccessCheck => (),
} }
} ModeTreeHelperError::CurrentModeNotInTargetTable(_) => panic!("mode not found"),
}, },
Err(error) => match error { }
ModeTreeHelperError::Message(_generic_targeted_messaging_error) => { }
panic!("messaging error") if !received_reply {
} self.subsystem_helper
ModeTreeHelperError::CurrentModeNotInTargetTable(_) => panic!("mode not found"), .state_machine(None, &self.mode_node)
}, .expect("subsystem helper error");
} }
} }
pub fn add_target_and_sequence_table( pub fn add_target_and_sequence_table(
@ -697,6 +690,7 @@ impl AssemblyCommandingHelper {
child.awaiting_reply = true; child.awaiting_reply = true;
} }
self.active_request_id = Some(request_id); self.active_request_id = Some(request_id);
self.state = ModeTreeHelperState::ModeCommanding;
Ok(()) Ok(())
} }
@ -801,14 +795,14 @@ impl MgmAssembly {
} }
pub fn check_mode_requests(&mut self) -> Result<(), GenericTargetedMessagingError> { pub fn check_mode_requests(&mut self) -> Result<(), GenericTargetedMessagingError> {
if let Some(request) = self.mode_node.try_recv_mode_request()? { while let Some(request) = self.mode_node.try_recv_mode_request()? {
self.handle_mode_request(request).unwrap(); self.handle_mode_request(request).unwrap();
} }
Ok(()) Ok(())
} }
pub fn check_mode_replies(&mut self) -> Result<(), ModeError> { pub fn check_mode_replies(&mut self) -> Result<(), ModeError> {
if let Some(reply_and_id) = self.mode_node.try_recv_mode_reply()? { while let Some(reply_and_id) = self.mode_node.try_recv_mode_reply()? {
self.mode_reply_mock.handle_mode_reply(&reply_and_id); self.mode_reply_mock.handle_mode_reply(&reply_and_id);
match self.assembly_helper.handle_mode_reply(&reply_and_id) { match self.assembly_helper.handle_mode_reply(&reply_and_id) {
AssemblyHelperResult::Idle => (), AssemblyHelperResult::Idle => (),
@ -839,6 +833,9 @@ impl ModeParent for MgmAssembly {
fn add_mode_child(&mut self, id: ComponentId, request_sender: RequestSenderType) { fn add_mode_child(&mut self, id: ComponentId, request_sender: RequestSenderType) {
self.mode_node.add_request_target(id, request_sender); self.mode_node.add_request_target(id, request_sender);
self.assembly_helper
.children_mode_store
.add_component(id, UNKNOWN_MODE);
} }
} }
@ -1108,7 +1105,6 @@ struct CommonDevice {
pub mode_node: ModeRequestHandlerMpscBounded, pub mode_node: ModeRequestHandlerMpscBounded,
pub mode_and_submode: ModeAndSubmode, pub mode_and_submode: ModeAndSubmode,
pub mode_req_mock: ModeRequestHandlerMock, pub mode_req_mock: ModeRequestHandlerMock,
pub num_mode_msgs_recvd: u32,
} }
impl CommonDevice { impl CommonDevice {
@ -1123,7 +1119,6 @@ impl CommonDevice {
mode_node, mode_node,
mode_and_submode: UNKNOWN_MODE, mode_and_submode: UNKNOWN_MODE,
mode_req_mock: Default::default(), mode_req_mock: Default::default(),
num_mode_msgs_recvd: 0,
} }
} }
@ -1133,16 +1128,13 @@ impl CommonDevice {
pub fn check_mode_requests(&mut self) -> Result<(), ModeError> { pub fn check_mode_requests(&mut self) -> Result<(), ModeError> {
if let Some(request) = self.mode_node.try_recv_mode_request()? { if let Some(request) = self.mode_node.try_recv_mode_request()? {
self.num_mode_msgs_recvd += 1;
self.handle_mode_request(request)? self.handle_mode_request(request)?
} }
Ok(()) Ok(())
} }
pub fn get_and_clear_num_mode_msgs(&mut self) -> u32 { pub fn get_and_clear_num_mode_msgs(&mut self) -> usize {
let tmp = self.num_mode_msgs_recvd; self.mode_req_mock.mode_messages_received()
self.num_mode_msgs_recvd = 0;
tmp
} }
} }
@ -1617,7 +1609,7 @@ fn announce_recursively() {
// Run everything twice so the order does not matter. // Run everything twice so the order does not matter.
tb.run(); tb.run();
tb.run(); tb.run();
assert_eq!(tb.subsystem.get_and_clear_num_mode_requests(), 1); assert_eq!(tb.subsystem.get_num_mode_requests(), 1);
let mut announces = tb let mut announces = tb
.subsystem .subsystem
.mode_req_handler_mock .mode_req_handler_mock
@ -1660,6 +1652,9 @@ fn announce_recursively() {
#[test] #[test]
fn command_safe_mode() { fn command_safe_mode() {
let mut tb = TreeTestbench::new(); let mut tb = TreeTestbench::new();
assert_eq!(tb.ctrl.mode_and_submode(), UNKNOWN_MODE);
assert_eq!(tb.mgm_devs[0].mode_and_submode(), UNKNOWN_MODE);
assert_eq!(tb.mgm_devs[1].mode_and_submode(), UNKNOWN_MODE);
tb.run(); tb.run();
tb.pus tb.pus
.send_mode_cmd(ModeAndSubmode::new(AcsMode::SAFE as u32, 0)); .send_mode_cmd(ModeAndSubmode::new(AcsMode::SAFE as u32, 0));
@ -1669,6 +1664,14 @@ fn command_safe_mode() {
tb.ctrl.mode_and_submode(), tb.ctrl.mode_and_submode(),
ModeAndSubmode::new(AcsMode::SAFE as u32, 0) ModeAndSubmode::new(AcsMode::SAFE as u32, 0)
); );
assert_eq!(
tb.mgm_devs[0].mode_and_submode(),
ModeAndSubmode::new(DefaultMode::NORMAL as u32, 0)
);
assert_eq!(
tb.mgm_devs[1].mode_and_submode(),
ModeAndSubmode::new(DefaultMode::NORMAL as u32, 0)
);
assert_eq!( assert_eq!(
tb.mgm_assy.mode_and_submode(), tb.mgm_assy.mode_and_submode(),
ModeAndSubmode::new(DefaultMode::NORMAL as u32, 0) ModeAndSubmode::new(DefaultMode::NORMAL as u32, 0)