From c477739f6d62c68968e61760d9e9d59a6c0a6b78 Mon Sep 17 00:00:00 2001 From: Robin Mueller Date: Wed, 24 Apr 2024 18:50:08 +0200 Subject: [PATCH] more improvements for API, tests for example event module --- satrs-example/src/events.rs | 75 ++++++++++++++++++++++++++---------- satrs-shared/Cargo.toml | 5 +++ satrs-shared/src/res_code.rs | 23 +++++++++++ satrs/src/events.rs | 4 ++ 4 files changed, 87 insertions(+), 20 deletions(-) diff --git a/satrs-example/src/events.rs b/satrs-example/src/events.rs index abfcb6b..cb0caf8 100644 --- a/satrs-example/src/events.rs +++ b/satrs-example/src/events.rs @@ -214,43 +214,78 @@ mod tests { use satrs::{ events::EventU32, pus::verification::VerificationReporterCfg, - spacepackets::{ecss::tm::PusTmReader, CcsdsPacket}, + spacepackets::{ + ecss::{tm::PusTmReader, PusPacket}, + CcsdsPacket, + }, tmtc::PacketAsVec, }; use super::*; const TEST_CREATOR_ID: UniqueApidTargetId = UniqueApidTargetId::new(1, 2); + const TEST_EVENT: EventU32 = EventU32::new(satrs::events::Severity::Info, 1, 1); + + pub struct EventManagementTestbench { + pub event_tx: mpsc::SyncSender, + pub event_manager: EventManagerWithBoundedMpsc, + pub tm_receiver: mpsc::Receiver, + pub pus_event_handler: PusEventHandler>, + } + + impl EventManagementTestbench { + pub fn new() -> Self { + let (event_tx, event_rx) = mpsc::sync_channel(10); + let (_event_req_tx, event_req_rx) = mpsc::sync_channel(10); + let (tm_sender, tm_receiver) = mpsc::channel(); + let verif_reporter_cfg = VerificationReporterCfg::new(0x05, 2, 2, 128).unwrap(); + let verif_reporter = + VerificationReporter::new(PUS_EVENT_MANAGEMENT.id(), &verif_reporter_cfg); + let mut event_manager = EventManagerWithBoundedMpsc::new(event_rx); + let pus_event_handler = PusEventHandler::>::new( + tm_sender, + verif_reporter, + &mut event_manager, + event_req_rx, + ); + Self { + event_tx, + tm_receiver, + event_manager, + pus_event_handler, + } + } + } #[test] - fn test_basic() { - let (event_tx, event_rx) = mpsc::sync_channel(10); - let (_event_req_tx, event_req_rx) = mpsc::sync_channel(10); - let (tm_sender, tm_receiver) = mpsc::channel(); - let verif_reporter_cfg = VerificationReporterCfg::new(0x05, 2, 2, 128).unwrap(); - let verif_reporter = - VerificationReporter::new(PUS_EVENT_MANAGEMENT.id(), &verif_reporter_cfg); - let mut event_manager = EventManagerWithBoundedMpsc::new(event_rx); - let mut pus_event_handler = PusEventHandler::>::new( - tm_sender, - verif_reporter, - &mut event_manager, - event_req_rx, - ); - event_tx + fn test_basic_event_generation() { + let mut testbench = EventManagementTestbench::new(); + testbench + .event_tx .send(EventMessageU32::new( TEST_CREATOR_ID.id(), EventU32::new(satrs::events::Severity::Info, 1, 1), )) .expect("failed to send event"); - pus_event_handler.handle_event_requests(); - event_manager.try_event_handling(|_, _| {}); - pus_event_handler.generate_pus_event_tm(); - let tm_packet = tm_receiver.try_recv().expect("failed to receive TM packet"); + testbench.pus_event_handler.handle_event_requests(); + testbench.event_manager.try_event_handling(|_, _| {}); + testbench.pus_event_handler.generate_pus_event_tm(); + let tm_packet = testbench + .tm_receiver + .try_recv() + .expect("failed to receive TM packet"); assert_eq!(tm_packet.sender_id, PUS_EVENT_MANAGEMENT.id()); let tm_reader = PusTmReader::new(&tm_packet.packet, 7) .expect("failed to create TM reader") .0; assert_eq!(tm_reader.apid(), TEST_CREATOR_ID.apid); + assert_eq!(tm_reader.user_data().len(), 4); + let event_read_back = EventU32::from_be_bytes(tm_reader.user_data().try_into().unwrap()); + assert_eq!(event_read_back, TEST_EVENT); + } + + #[test] + fn test_basic_event_disabled() { + // TODO: Add test. } } diff --git a/satrs-shared/Cargo.toml b/satrs-shared/Cargo.toml index 2ed8f26..cfac25d 100644 --- a/satrs-shared/Cargo.toml +++ b/satrs-shared/Cargo.toml @@ -17,12 +17,17 @@ version = "1" default-features = false optional = true +[dependencies.defmt] +version = "0.3" +optional = true + [dependencies.spacepackets] version = ">0.9, <=0.11" default-features = false [features] serde = ["dep:serde", "spacepackets/serde"] +spacepackets = ["dep:defmt", "spacepackets/defmt"] [package.metadata.docs.rs] rustdoc-args = ["--cfg", "doc_cfg", "--generate-link-to-definition"] diff --git a/satrs-shared/src/res_code.rs b/satrs-shared/src/res_code.rs index e7816f3..099e84d 100644 --- a/satrs-shared/src/res_code.rs +++ b/satrs-shared/src/res_code.rs @@ -7,6 +7,7 @@ use spacepackets::ByteConversionError; /// Simple [u16] based result code type which also allows to group related resultcodes. #[derive(Debug, Copy, Clone, PartialEq, Eq)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] +#[cfg_attr(feature = "defmt", derive(defmt::Format))] pub struct ResultU16 { group_id: u8, unique_id: u8, @@ -19,15 +20,28 @@ impl ResultU16 { unique_id, } } + pub fn raw(&self) -> u16 { ((self.group_id as u16) << 8) | self.unique_id as u16 } + pub fn group_id(&self) -> u8 { self.group_id } + pub fn unique_id(&self) -> u8 { self.unique_id } + + pub fn from_be_bytes(bytes: [u8; 2]) -> Self { + Self::from(u16::from_be_bytes(bytes)) + } +} + +impl From for ResultU16 { + fn from(value: u16) -> Self { + Self::new(((value >> 8) & 0xff) as u8, (value & 0xff) as u8) + } } impl From for EcssEnumU16 { @@ -84,5 +98,14 @@ mod tests { assert_eq!(written, 2); assert_eq!(buf[0], 1); assert_eq!(buf[1], 1); + let read_back = ResultU16::from_be_bytes(buf); + assert_eq!(read_back, result_code); + } + + #[test] + fn test_from_u16() { + let result_code = ResultU16::new(1, 1); + let result_code_2 = ResultU16::from(result_code.raw()); + assert_eq!(result_code, result_code_2); } } diff --git a/satrs/src/events.rs b/satrs/src/events.rs index cb87a05..5544eb2 100644 --- a/satrs/src/events.rs +++ b/satrs/src/events.rs @@ -794,6 +794,8 @@ mod tests { assert!(HIGH_SEV_EVENT.write_to_be_bytes(&mut buf).is_ok()); let val_from_raw = u32::from_be_bytes(buf); assert_eq!(val_from_raw, 0xFFFFFFFF); + let event_read_back = EventU32::from_be_bytes(buf); + assert_eq!(event_read_back, HIGH_SEV_EVENT); } #[test] @@ -802,6 +804,8 @@ mod tests { assert!(HIGH_SEV_EVENT_SMALL.write_to_be_bytes(&mut buf).is_ok()); let val_from_raw = u16::from_be_bytes(buf); assert_eq!(val_from_raw, 0xFFFF); + let event_read_back = EventU16::from_be_bytes(buf); + assert_eq!(event_read_back, HIGH_SEV_EVENT_SMALL); } #[test]