From cdf546b85dbe7169dd69613c08112f6d0652d123 Mon Sep 17 00:00:00 2001 From: Robin Mueller Date: Thu, 4 Apr 2024 13:14:21 +0200 Subject: [PATCH] all changes for updated spacepackets --- satrs-example/src/acs/mgm.rs | 9 +- satrs-example/src/bin/simpleclient.rs | 3 +- satrs-example/src/ccsds.rs | 4 +- satrs-example/src/config.rs | 2 +- satrs-example/src/pus/action.rs | 28 +++-- satrs-example/src/pus/hk.rs | 36 +++--- satrs-example/src/pus/mod.rs | 4 +- satrs-example/src/pus/mode.rs | 21 ++-- satrs-example/src/udp.rs | 4 +- satrs/CHANGELOG.md | 2 + satrs/release-checklist.md | 2 +- satrs/src/encoding/ccsds.rs | 110 +++-------------- satrs/src/hal/std/tcp_spacepackets_server.rs | 37 +++--- satrs/src/hal/std/udp_server.rs | 8 +- satrs/src/lib.rs | 65 ++++++++++ satrs/src/pus/event.rs | 3 +- satrs/src/pus/event_man.rs | 4 +- satrs/src/pus/event_srv.rs | 14 +-- satrs/src/pus/scheduler.rs | 119 +++++++++---------- satrs/src/pus/scheduler_srv.rs | 12 +- satrs/src/pus/test.rs | 22 ++-- satrs/src/pus/verification.rs | 21 ++-- satrs/src/request.rs | 8 +- satrs/src/tmtc/ccsds_distrib.rs | 58 ++++----- satrs/src/tmtc/pus_distrib.rs | 29 +++-- satrs/src/tmtc/tm_helper.rs | 4 +- satrs/tests/pus_events.rs | 2 +- satrs/tests/pus_verification.rs | 10 +- satrs/tests/tcp_servers.rs | 14 +-- 29 files changed, 336 insertions(+), 319 deletions(-) diff --git a/satrs-example/src/acs/mgm.rs b/satrs-example/src/acs/mgm.rs index ab03a76..1cb7eee 100644 --- a/satrs-example/src/acs/mgm.rs +++ b/satrs-example/src/acs/mgm.rs @@ -147,7 +147,6 @@ impl HkReply::new(hk_request.unique_id, HkReplyVariant::Ack), )) .expect("failed to send HK reply"); - let mut sp_header = SpHeader::tm_unseg(self.id.apid, 0, 0).unwrap(); let sec_header = PusTmSecondaryHeader::new( 3, hk::Subservice::TmHkPacket as u8, @@ -161,8 +160,12 @@ impl self.tm_buf[1..5].copy_from_slice(&mgm_snapshot.x.to_be_bytes()); self.tm_buf[5..9].copy_from_slice(&mgm_snapshot.y.to_be_bytes()); self.tm_buf[9..13].copy_from_slice(&mgm_snapshot.z.to_be_bytes()); - let hk_tm = - PusTmCreator::new(&mut sp_header, sec_header, &self.tm_buf[0..12], true); + let hk_tm = PusTmCreator::new( + SpHeader::new_from_apid(self.id.apid), + sec_header, + &self.tm_buf[0..12], + true, + ); self.tm_sender .send_tm(self.id.id(), PusTmVariant::Direct(hk_tm)) .expect("failed to send HK TM"); diff --git a/satrs-example/src/bin/simpleclient.rs b/satrs-example/src/bin/simpleclient.rs index 2d015d0..bbe7609 100644 --- a/satrs-example/src/bin/simpleclient.rs +++ b/satrs-example/src/bin/simpleclient.rs @@ -12,8 +12,7 @@ use std::time::Duration; fn main() { let mut buf = [0; 32]; let addr = SocketAddr::new(IpAddr::V4(OBSW_SERVER_ADDR), SERVER_PORT); - let mut sph = SpHeader::tc_unseg(0x02, 0, 0).unwrap(); - let pus_tc = PusTcCreator::new_simple(&mut sph, 17, 1, &[], true); + let pus_tc = PusTcCreator::new_simple(SpHeader::new_from_apid(0x02), 17, 1, &[], true); let client = UdpSocket::bind("127.0.0.1:7302").expect("Connecting to UDP server failed"); let tc_req_id = RequestId::new(&pus_tc); println!("Packing and sending PUS ping command TC[17,1] with request ID {tc_req_id}"); diff --git a/satrs-example/src/ccsds.rs b/satrs-example/src/ccsds.rs index 53d8a14..2373a4d 100644 --- a/satrs-example/src/ccsds.rs +++ b/satrs-example/src/ccsds.rs @@ -1,7 +1,7 @@ -use satrs::encoding::ccsds::PacketIdValidator; use satrs::pus::ReceivesEcssPusTc; use satrs::spacepackets::{CcsdsPacket, PacketId, SpHeader}; use satrs::tmtc::{CcsdsPacketHandler, ReceivesCcsdsTc}; +use satrs::ValidatorU16Id; use satrs_example::config::components::Apid; use satrs_example::config::PACKET_ID_VALIDATOR; @@ -16,7 +16,7 @@ pub struct CcsdsReceiver< impl< TcSource: ReceivesCcsdsTc + ReceivesEcssPusTc + Clone + 'static, E: 'static, - > PacketIdValidator for CcsdsReceiver + > ValidatorU16Id for CcsdsReceiver { fn validate(&self, packet_id: u16) -> bool { PACKET_ID_VALIDATOR.contains(&PacketId::from(packet_id)) diff --git a/satrs-example/src/config.rs b/satrs-example/src/config.rs index f016c88..8f8cd1b 100644 --- a/satrs-example/src/config.rs +++ b/satrs-example/src/config.rs @@ -45,7 +45,7 @@ lazy_static! { pub static ref PACKET_ID_VALIDATOR: HashSet = { let mut set = HashSet::new(); for id in components::Apid::iter() { - set.insert(PacketId::const_new(PacketType::Tc, true, id as u16)); + set.insert(PacketId::new(PacketType::Tc, true, id as u16)); } set }; diff --git a/satrs-example/src/pus/action.rs b/satrs-example/src/pus/action.rs index 9ce9891..22b6b93 100644 --- a/satrs-example/src/pus/action.rs +++ b/satrs-example/src/pus/action.rs @@ -477,13 +477,13 @@ mod tests { TEST_COMPONENT_ID_1.id(), ); // Create a basic action request and verify forwarding. - let mut sp_header = SpHeader::tc_unseg(TEST_APID, 0, 0).unwrap(); + let sp_header = SpHeader::new_from_apid(TEST_APID); let sec_header = PusTcSecondaryHeader::new_simple(8, 128); let action_id = 5_u32; let mut app_data: [u8; 8] = [0; 8]; app_data[0..4].copy_from_slice(&TEST_UNIQUE_ID_1.to_be_bytes()); app_data[4..8].copy_from_slice(&action_id.to_be_bytes()); - let pus8_packet = PusTcCreator::new(&mut sp_header, sec_header, &app_data, true); + let pus8_packet = PusTcCreator::new(sp_header, sec_header, &app_data, true); testbench.add_tc(&pus8_packet); let time_stamp: [u8; 7] = [0; 7]; testbench.verify_next_tc_is_handled_properly(&time_stamp); @@ -519,14 +519,18 @@ mod tests { TEST_COMPONENT_ID_1.id(), ); // Create a basic action request and verify forwarding. - let mut sp_header = SpHeader::tc_unseg(TEST_APID, 0, 0).unwrap(); let sec_header = PusTcSecondaryHeader::new_simple(8, 128); let action_id = 5_u32; let mut app_data: [u8; 8] = [0; 8]; // Invalid ID, routing should fail. app_data[0..4].copy_from_slice(&0_u32.to_be_bytes()); app_data[4..8].copy_from_slice(&action_id.to_be_bytes()); - let pus8_packet = PusTcCreator::new(&mut sp_header, sec_header, &app_data, true); + let pus8_packet = PusTcCreator::new( + SpHeader::new_from_apid(TEST_APID), + sec_header, + &app_data, + true, + ); testbench.add_tc(&pus8_packet); let time_stamp: [u8; 7] = [0; 7]; @@ -541,14 +545,18 @@ mod tests { TEST_COMPONENT_ID_0.raw(), ActionRequestConverter::default(), ); - let mut sp_header = SpHeader::tc_unseg(TEST_APID, 0, 0).unwrap(); let sec_header = PusTcSecondaryHeader::new_simple(8, 128); let action_id = 5_u32; let mut app_data: [u8; 8] = [0; 8]; // Invalid ID, routing should fail. app_data[0..4].copy_from_slice(&TEST_UNIQUE_ID_0.to_be_bytes()); app_data[4..8].copy_from_slice(&action_id.to_be_bytes()); - let pus8_packet = PusTcCreator::new(&mut sp_header, sec_header, &app_data, true); + let pus8_packet = PusTcCreator::new( + SpHeader::new_from_apid(TEST_APID), + sec_header, + &app_data, + true, + ); let token = testbench.add_tc(&pus8_packet); let result = testbench.convert(token, &[], TEST_APID, TEST_UNIQUE_ID_0); assert!(result.is_ok()); @@ -573,7 +581,6 @@ mod tests { fn converter_action_req_with_data() { let mut testbench = PusConverterTestbench::new(TEST_COMPONENT_ID_0.id(), ActionRequestConverter::default()); - let mut sp_header = SpHeader::tc_unseg(TEST_APID, 0, 0).unwrap(); let sec_header = PusTcSecondaryHeader::new_simple(8, 128); let action_id = 5_u32; let mut app_data: [u8; 16] = [0; 16]; @@ -583,7 +590,12 @@ mod tests { for i in 0..8 { app_data[i + 8] = i as u8; } - let pus8_packet = PusTcCreator::new(&mut sp_header, sec_header, &app_data, true); + let pus8_packet = PusTcCreator::new( + SpHeader::new_from_apid(TEST_APID), + sec_header, + &app_data, + true, + ); let token = testbench.add_tc(&pus8_packet); let result = testbench.convert(token, &[], TEST_APID, TEST_UNIQUE_ID_0); assert!(result.is_ok()); diff --git a/satrs-example/src/pus/hk.rs b/satrs-example/src/pus/hk.rs index ab88573..cb3ebb9 100644 --- a/satrs-example/src/pus/hk.rs +++ b/satrs-example/src/pus/hk.rs @@ -367,7 +367,7 @@ mod tests { fn hk_converter_one_shot_req() { let mut hk_bench = PusConverterTestbench::new(TEST_COMPONENT_ID_0.id(), HkRequestConverter::default()); - let mut sp_header = SpHeader::tc_unseg(TEST_APID, 0, 0).unwrap(); + let sp_header = SpHeader::new_for_unseg_tc(TEST_APID, 0, 0); let target_id = TEST_UNIQUE_ID_0; let unique_id = 5_u32; let mut app_data: [u8; 8] = [0; 8]; @@ -375,10 +375,10 @@ mod tests { app_data[4..8].copy_from_slice(&unique_id.to_be_bytes()); let hk_req = PusTcCreator::new_simple( - &mut sp_header, + sp_header, 3, Subservice::TcGenerateOneShotHk as u8, - Some(&app_data), + &app_data, true, ); let accepted_token = hk_bench.add_tc(&hk_req); @@ -397,7 +397,7 @@ mod tests { fn hk_converter_enable_periodic_generation() { let mut hk_bench = PusConverterTestbench::new(TEST_COMPONENT_ID_0.id(), HkRequestConverter::default()); - let mut sp_header = SpHeader::tc_unseg(TEST_APID, 0, 0).unwrap(); + let sp_header = SpHeader::new_for_unseg_tc(TEST_APID, 0, 0); let target_id = TEST_UNIQUE_ID_0; let unique_id = 5_u32; let mut app_data: [u8; 8] = [0; 8]; @@ -415,18 +415,18 @@ mod tests { } }; let tc0 = PusTcCreator::new_simple( - &mut sp_header, + sp_header, 3, Subservice::TcEnableHkGeneration as u8, - Some(&app_data), + &app_data, true, ); generic_check(&tc0); let tc1 = PusTcCreator::new_simple( - &mut sp_header, + sp_header, 3, Subservice::TcEnableDiagGeneration as u8, - Some(&app_data), + &app_data, true, ); generic_check(&tc1); @@ -436,7 +436,7 @@ mod tests { fn hk_conversion_disable_periodic_generation() { let mut hk_bench = PusConverterTestbench::new(TEST_COMPONENT_ID_0.id(), HkRequestConverter::default()); - let mut sp_header = SpHeader::tc_unseg(TEST_APID, 0, 0).unwrap(); + let sp_header = SpHeader::new_for_unseg_tc(TEST_APID, 0, 0); let target_id = TEST_UNIQUE_ID_0; let unique_id = 5_u32; let mut app_data: [u8; 8] = [0; 8]; @@ -454,18 +454,18 @@ mod tests { } }; let tc0 = PusTcCreator::new_simple( - &mut sp_header, + sp_header, 3, Subservice::TcDisableHkGeneration as u8, - Some(&app_data), + &app_data, true, ); generic_check(&tc0); let tc1 = PusTcCreator::new_simple( - &mut sp_header, + sp_header, 3, Subservice::TcDisableDiagGeneration as u8, - Some(&app_data), + &app_data, true, ); generic_check(&tc1); @@ -475,7 +475,7 @@ mod tests { fn hk_conversion_modify_interval() { let mut hk_bench = PusConverterTestbench::new(TEST_COMPONENT_ID_0.id(), HkRequestConverter::default()); - let mut sp_header = SpHeader::tc_unseg(TEST_APID, 0, 0).unwrap(); + let sp_header = SpHeader::new_for_unseg_tc(TEST_APID, 0, 0); let target_id = TEST_UNIQUE_ID_0; let unique_id = 5_u32; let mut app_data: [u8; 12] = [0; 12]; @@ -497,18 +497,18 @@ mod tests { } }; let tc0 = PusTcCreator::new_simple( - &mut sp_header, + sp_header, 3, Subservice::TcModifyHkCollectionInterval as u8, - Some(&app_data), + &app_data, true, ); generic_check(&tc0); let tc1 = PusTcCreator::new_simple( - &mut sp_header, + sp_header, 3, Subservice::TcModifyDiagCollectionInterval as u8, - Some(&app_data), + &app_data, true, ); generic_check(&tc1); diff --git a/satrs-example/src/pus/mod.rs b/satrs-example/src/pus/mod.rs index 4e67bd2..987f735 100644 --- a/satrs-example/src/pus/mod.rs +++ b/satrs-example/src/pus/mod.rs @@ -519,10 +519,10 @@ pub(crate) mod tests { apid_target: u32, time_stamp: &[u8], ) -> (verification::RequestId, ActivePusRequestStd) { - let mut sp_header = SpHeader::tc_unseg(apid, 0, 0).unwrap(); + let sp_header = SpHeader::new_from_apid(apid); let sec_header_dummy = PusTcSecondaryHeader::new_simple(0, 0); let init = self.verif_reporter.add_tc(&PusTcCreator::new( - &mut sp_header, + sp_header, sec_header_dummy, &[], true, diff --git a/satrs-example/src/pus/mode.rs b/satrs-example/src/pus/mode.rs index bb535b9..4f2ff13 100644 --- a/satrs-example/src/pus/mode.rs +++ b/satrs-example/src/pus/mode.rs @@ -78,11 +78,10 @@ impl PusReplyHandler for ModeReplyHandler { .write_to_be_bytes(&mut source_data) .expect("writing mode reply failed"); let req_id = verification::RequestId::from(reply.request_id()); - let mut sp_header = SpHeader::tm_unseg(req_id.packet_id().apid(), 0, 0) - .expect("generating SP header failed"); + let sp_header = SpHeader::new_for_unseg_tm(req_id.packet_id().apid(), 0, 0); let sec_header = PusTmSecondaryHeader::new(200, Subservice::TmModeReply as u8, 0, 0, time_stamp); - let pus_tm = PusTmCreator::new(&mut sp_header, sec_header, &source_data, true); + let pus_tm = PusTmCreator::new(sp_header, sec_header, &source_data, true); tm_sender.send_tm(self.owner_id, PusTmVariant::Direct(pus_tm))?; verification_handler.completion_success(tm_sender, started_token, time_stamp)?; } @@ -336,11 +335,11 @@ mod tests { fn mode_converter_read_mode_request() { let mut testbench = PusConverterTestbench::new(TEST_COMPONENT_ID_0.id(), ModeRequestConverter::default()); - let mut sp_header = SpHeader::tc_unseg(TEST_APID, 0, 0).unwrap(); + let sp_header = SpHeader::new_for_unseg_tc(TEST_APID, 0, 0); let sec_header = PusTcSecondaryHeader::new_simple(200, Subservice::TcReadMode as u8); let mut app_data: [u8; 4] = [0; 4]; app_data[0..4].copy_from_slice(&TEST_UNIQUE_ID_0.to_be_bytes()); - let tc = PusTcCreator::new(&mut sp_header, sec_header, &app_data, true); + let tc = PusTcCreator::new(sp_header, sec_header, &app_data, true); let token = testbench.add_tc(&tc); let (_active_req, req) = testbench .convert(token, &[], TEST_APID, TEST_UNIQUE_ID_0) @@ -352,7 +351,7 @@ mod tests { fn mode_converter_set_mode_request() { let mut testbench = PusConverterTestbench::new(TEST_COMPONENT_ID_0.id(), ModeRequestConverter::default()); - let mut sp_header = SpHeader::tc_unseg(TEST_APID, 0, 0).unwrap(); + let sp_header = SpHeader::new_for_unseg_tc(TEST_APID, 0, 0); let sec_header = PusTcSecondaryHeader::new_simple(200, Subservice::TcSetMode as u8); let mut app_data: [u8; 4 + ModeAndSubmode::RAW_LEN] = [0; 4 + ModeAndSubmode::RAW_LEN]; let mode_and_submode = ModeAndSubmode::new(2, 1); @@ -360,7 +359,7 @@ mod tests { mode_and_submode .write_to_be_bytes(&mut app_data[4..]) .unwrap(); - let tc = PusTcCreator::new(&mut sp_header, sec_header, &app_data, true); + let tc = PusTcCreator::new(sp_header, sec_header, &app_data, true); let token = testbench.add_tc(&tc); let (_active_req, req) = testbench .convert(token, &[], TEST_APID, TEST_UNIQUE_ID_0) @@ -372,11 +371,11 @@ mod tests { fn mode_converter_announce_mode() { let mut testbench = PusConverterTestbench::new(TEST_COMPONENT_ID_0.id(), ModeRequestConverter::default()); - let mut sp_header = SpHeader::tc_unseg(TEST_APID, 0, 0).unwrap(); + let sp_header = SpHeader::new_for_unseg_tc(TEST_APID, 0, 0); let sec_header = PusTcSecondaryHeader::new_simple(200, Subservice::TcAnnounceMode as u8); let mut app_data: [u8; 4] = [0; 4]; app_data[0..4].copy_from_slice(&TEST_UNIQUE_ID_0.to_be_bytes()); - let tc = PusTcCreator::new(&mut sp_header, sec_header, &app_data, true); + let tc = PusTcCreator::new(sp_header, sec_header, &app_data, true); let token = testbench.add_tc(&tc); let (_active_req, req) = testbench .convert(token, &[], TEST_APID, TEST_UNIQUE_ID_0) @@ -388,12 +387,12 @@ mod tests { fn mode_converter_announce_mode_recursively() { let mut testbench = PusConverterTestbench::new(TEST_COMPONENT_ID_0.id(), ModeRequestConverter::default()); - let mut sp_header = SpHeader::tc_unseg(TEST_APID, 0, 0).unwrap(); + let sp_header = SpHeader::new_for_unseg_tc(TEST_APID, 0, 0); let sec_header = PusTcSecondaryHeader::new_simple(200, Subservice::TcAnnounceModeRecursive as u8); let mut app_data: [u8; 4] = [0; 4]; app_data[0..4].copy_from_slice(&TEST_UNIQUE_ID_0.to_be_bytes()); - let tc = PusTcCreator::new(&mut sp_header, sec_header, &app_data, true); + let tc = PusTcCreator::new(sp_header, sec_header, &app_data, true); let token = testbench.add_tc(&tc); let (_active_req, req) = testbench .convert(token, &[], TEST_APID, TEST_UNIQUE_ID_0) diff --git a/satrs-example/src/udp.rs b/satrs-example/src/udp.rs index c2f26fa..2cb4823 100644 --- a/satrs-example/src/udp.rs +++ b/satrs-example/src/udp.rs @@ -177,8 +177,8 @@ mod tests { udp_tc_server, tm_handler, }; - let mut sph = SpHeader::tc_unseg(components::Apid::GenericPus as u16, 0, 0).unwrap(); - let ping_tc = PusTcCreator::new_simple(&mut sph, 17, 1, None, true) + let sph = SpHeader::new_for_unseg_tc(components::Apid::GenericPus as u16, 0, 0); + let ping_tc = PusTcCreator::new_simple(sph, 17, 1, &[], true) .to_vec() .unwrap(); let client = UdpSocket::bind("127.0.0.1:0").expect("Connecting to UDP server failed"); diff --git a/satrs/CHANGELOG.md b/satrs/CHANGELOG.md index bf133bc..7a2e027 100644 --- a/satrs/CHANGELOG.md +++ b/satrs/CHANGELOG.md @@ -22,6 +22,8 @@ and this project adheres to [Semantic Versioning](http://semver.org/). ## Changed +- `encoding::ccsds::PacketIdValidator` renamed to `ValidatorU16Id`, which lives in the crate root. + It can be used for both CCSDS packet ID and CCSDS APID validation. - `EventManager::try_event_handling` not expects a mutable error handling closure instead of returning the occured errors. - Renamed `EventManagerBase` to `EventReportCreator` diff --git a/satrs/release-checklist.md b/satrs/release-checklist.md index e742ac9..e76959e 100644 --- a/satrs/release-checklist.md +++ b/satrs/release-checklist.md @@ -8,7 +8,7 @@ Checklist for new releases 2. Bump version specifier in `Cargo.toml`. 3. Update `CHANGELOG.md`: Convert `unreleased` section into version section with date and add new `unreleased` section. -4. Run `cargo test --all-features`. +4. Run `cargo test --all-features` or `cargo nextest r --all-features` and `cargo test --doc`. 5. Run `cargo fmt` and `cargo clippy`. Check `cargo msrv` against MSRV in `Cargo.toml`. 6. Wait for CI/CD results for EGit and Github. These also check cross-compilation for bare-metal targets. diff --git a/satrs/src/encoding/ccsds.rs b/satrs/src/encoding/ccsds.rs index 2107787..30adccf 100644 --- a/satrs/src/encoding/ccsds.rs +++ b/satrs/src/encoding/ccsds.rs @@ -1,76 +1,4 @@ -#[cfg(feature = "alloc")] -use alloc::vec::Vec; -#[cfg(feature = "alloc")] -use hashbrown::HashSet; -#[cfg(feature = "std")] -use std::collections::HashSet as StdHashSet; - -use spacepackets::PacketId; - -use crate::tmtc::ReceivesTcCore; - -pub trait PacketIdValidator { - fn validate(&self, packet_id: u16) -> bool; -} - -#[cfg(feature = "alloc")] -impl PacketIdValidator for Vec { - fn validate(&self, packet_id: u16) -> bool { - self.contains(&packet_id) - } -} - -#[cfg(feature = "alloc")] -impl PacketIdValidator for HashSet { - fn validate(&self, packet_id: u16) -> bool { - self.contains(&packet_id) - } -} - -impl PacketIdValidator for [u16] { - fn validate(&self, packet_id: u16) -> bool { - self.binary_search(&packet_id).is_ok() - } -} - -impl PacketIdValidator for &[u16] { - fn validate(&self, packet_id: u16) -> bool { - self.binary_search(&packet_id).is_ok() - } -} - -#[cfg(feature = "alloc")] -impl PacketIdValidator for Vec { - fn validate(&self, packet_id: u16) -> bool { - self.contains(&PacketId::from(packet_id)) - } -} - -#[cfg(feature = "alloc")] -impl PacketIdValidator for HashSet { - fn validate(&self, packet_id: u16) -> bool { - self.contains(&PacketId::from(packet_id)) - } -} - -#[cfg(feature = "std")] -impl PacketIdValidator for StdHashSet { - fn validate(&self, packet_id: u16) -> bool { - self.contains(&PacketId::from(packet_id)) - } -} - -impl PacketIdValidator for [PacketId] { - fn validate(&self, packet_id: u16) -> bool { - self.binary_search(&PacketId::from(packet_id)).is_ok() - } -} - -impl PacketIdValidator for &[PacketId] { - fn validate(&self, packet_id: u16) -> bool { - self.binary_search(&PacketId::from(packet_id)).is_ok() - } -} +use crate::{tmtc::ReceivesTcCore, ValidatorU16Id}; /// This function parses a given buffer for tightly packed CCSDS space packets. It uses the /// [PacketId] field of the CCSDS packets to detect the start of a CCSDS space packet and then @@ -86,7 +14,7 @@ impl PacketIdValidator for &[PacketId] { /// error will be returned. pub fn parse_buffer_for_ccsds_space_packets( buf: &mut [u8], - packet_id_validator: &(impl PacketIdValidator + ?Sized), + packet_id_validator: &(impl ValidatorU16Id + ?Sized), tc_receiver: &mut (impl ReceivesTcCore + ?Sized), next_write_idx: &mut usize, ) -> Result { @@ -134,13 +62,13 @@ mod tests { const TEST_APID_0: u16 = 0x02; const TEST_APID_1: u16 = 0x10; - const TEST_PACKET_ID_0: PacketId = PacketId::const_tc(true, TEST_APID_0); - const TEST_PACKET_ID_1: PacketId = PacketId::const_tc(true, TEST_APID_1); + const TEST_PACKET_ID_0: PacketId = PacketId::new_for_tc(true, TEST_APID_0); + const TEST_PACKET_ID_1: PacketId = PacketId::new_for_tc(true, TEST_APID_1); #[test] fn test_basic() { - let mut sph = SpHeader::tc_unseg(TEST_APID_0, 0, 0).unwrap(); - let ping_tc = PusTcCreator::new_simple(&mut sph, 17, 1, None, true); + let sph = SpHeader::new_from_apid(TEST_APID_0); + let ping_tc = PusTcCreator::new_simple(sph, 17, 1, &[], true); let mut buffer: [u8; 32] = [0; 32]; let packet_len = ping_tc .write_to_bytes(&mut buffer) @@ -166,9 +94,9 @@ mod tests { #[test] fn test_multi_packet() { - let mut sph = SpHeader::tc_unseg(TEST_APID_0, 0, 0).unwrap(); - let ping_tc = PusTcCreator::new_simple(&mut sph, 17, 1, None, true); - let action_tc = PusTcCreator::new_simple(&mut sph, 8, 0, None, true); + let sph = SpHeader::new_from_apid(TEST_APID_0); + let ping_tc = PusTcCreator::new_simple(sph, 17, 1, &[], true); + let action_tc = PusTcCreator::new_simple(sph, 8, 0, &[], true); let mut buffer: [u8; 32] = [0; 32]; let packet_len_ping = ping_tc .write_to_bytes(&mut buffer) @@ -201,10 +129,10 @@ mod tests { #[test] fn test_multi_apid() { - let mut sph = SpHeader::tc_unseg(TEST_APID_0, 0, 0).unwrap(); - let ping_tc = PusTcCreator::new_simple(&mut sph, 17, 1, None, true); - sph = SpHeader::tc_unseg(TEST_APID_1, 0, 0).unwrap(); - let action_tc = PusTcCreator::new_simple(&mut sph, 8, 0, None, true); + let sph = SpHeader::new_from_apid(TEST_APID_0); + let ping_tc = PusTcCreator::new_simple(sph, 17, 1, &[], true); + let sph = SpHeader::new_from_apid(TEST_APID_1); + let action_tc = PusTcCreator::new_simple(sph, 8, 0, &[], true); let mut buffer: [u8; 32] = [0; 32]; let packet_len_ping = ping_tc .write_to_bytes(&mut buffer) @@ -237,10 +165,10 @@ mod tests { #[test] fn test_split_packet_multi() { - let mut sph = SpHeader::tc_unseg(TEST_APID_0, 0, 0).unwrap(); - let ping_tc = PusTcCreator::new_simple(&mut sph, 17, 1, None, true); - sph = SpHeader::tc_unseg(TEST_APID_1, 0, 0).unwrap(); - let action_tc = PusTcCreator::new_simple(&mut sph, 8, 0, None, true); + let ping_tc = + PusTcCreator::new_simple(SpHeader::new_from_apid(TEST_APID_0), 17, 1, &[], true); + let action_tc = + PusTcCreator::new_simple(SpHeader::new_from_apid(TEST_APID_1), 8, 0, &[], true); let mut buffer: [u8; 32] = [0; 32]; let packet_len_ping = ping_tc .write_to_bytes(&mut buffer) @@ -268,8 +196,8 @@ mod tests { #[test] fn test_one_split_packet() { - let mut sph = SpHeader::tc_unseg(TEST_APID_0, 0, 0).unwrap(); - let ping_tc = PusTcCreator::new_simple(&mut sph, 17, 1, None, true); + let ping_tc = + PusTcCreator::new_simple(SpHeader::new_from_apid(TEST_APID_0), 17, 1, &[], true); let mut buffer: [u8; 32] = [0; 32]; let packet_len_ping = ping_tc .write_to_bytes(&mut buffer) diff --git a/satrs/src/hal/std/tcp_spacepackets_server.rs b/satrs/src/hal/std/tcp_spacepackets_server.rs index 72b9e28..a33b137 100644 --- a/satrs/src/hal/std/tcp_spacepackets_server.rs +++ b/satrs/src/hal/std/tcp_spacepackets_server.rs @@ -5,8 +5,9 @@ use std::{ }; use crate::{ - encoding::{ccsds::PacketIdValidator, parse_buffer_for_ccsds_space_packets}, + encoding::parse_buffer_for_ccsds_space_packets, tmtc::{ReceivesTc, TmPacketSource}, + ValidatorU16Id, }; use super::tcp_server::{ @@ -14,17 +15,17 @@ use super::tcp_server::{ }; /// Concrete [TcpTcParser] implementation for the [TcpSpacepacketsServer]. -pub struct SpacepacketsTcParser { +pub struct SpacepacketsTcParser { packet_id_lookup: PacketIdChecker, } -impl SpacepacketsTcParser { +impl SpacepacketsTcParser { pub fn new(packet_id_lookup: PacketIdChecker) -> Self { Self { packet_id_lookup } } } -impl TcpTcParser +impl TcpTcParser for SpacepacketsTcParser { fn handle_tc_parsing( @@ -95,7 +96,7 @@ pub struct TcpSpacepacketsServer< TcError: 'static, TmSource: TmPacketSource, TcReceiver: ReceivesTc, - PacketIdChecker: PacketIdValidator, + PacketIdChecker: ValidatorU16Id, > { generic_server: TcpTmtcGenericServer< TmError, @@ -112,7 +113,7 @@ impl< TcError: 'static, TmSource: TmPacketSource, TcReceiver: ReceivesTc, - PacketIdChecker: PacketIdValidator, + PacketIdChecker: ValidatorU16Id, > TcpSpacepacketsServer { /// @@ -187,9 +188,9 @@ mod tests { use super::TcpSpacepacketsServer; const TEST_APID_0: u16 = 0x02; - const TEST_PACKET_ID_0: PacketId = PacketId::const_tc(true, TEST_APID_0); + const TEST_PACKET_ID_0: PacketId = PacketId::new_for_tc(true, TEST_APID_0); const TEST_APID_1: u16 = 0x10; - const TEST_PACKET_ID_1: PacketId = PacketId::const_tc(true, TEST_APID_1); + const TEST_PACKET_ID_1: PacketId = PacketId::new_for_tc(true, TEST_APID_1); fn generic_tmtc_server( addr: &SocketAddr, @@ -235,8 +236,8 @@ mod tests { assert_eq!(conn_result.num_sent_tms, 0); set_if_done.store(true, Ordering::Relaxed); }); - let mut sph = SpHeader::tc_unseg(TEST_APID_0, 0, 0).unwrap(); - let ping_tc = PusTcCreator::new_simple(&mut sph, 17, 1, None, true); + let ping_tc = + PusTcCreator::new_simple(SpHeader::new_from_apid(TEST_APID_0), 17, 1, &[], true); let tc_0 = ping_tc.to_vec().expect("packet generation failed"); let mut stream = TcpStream::connect(dest_addr).expect("connecting to TCP server failed"); stream @@ -267,13 +268,13 @@ mod tests { // Add telemetry let mut total_tm_len = 0; - let mut sph = SpHeader::tc_unseg(TEST_APID_0, 0, 0).unwrap(); - let verif_tm = PusTcCreator::new_simple(&mut sph, 1, 1, None, true); + let verif_tm = + PusTcCreator::new_simple(SpHeader::new_from_apid(TEST_APID_0), 1, 1, &[], true); let tm_0 = verif_tm.to_vec().expect("writing packet failed"); total_tm_len += tm_0.len(); tm_source.add_tm(&tm_0); - let mut sph = SpHeader::tc_unseg(TEST_APID_1, 0, 0).unwrap(); - let verif_tm = PusTcCreator::new_simple(&mut sph, 1, 3, None, true); + let verif_tm = + PusTcCreator::new_simple(SpHeader::new_from_apid(TEST_APID_1), 1, 3, &[], true); let tm_1 = verif_tm.to_vec().expect("writing packet failed"); total_tm_len += tm_1.len(); tm_source.add_tm(&tm_1); @@ -314,14 +315,14 @@ mod tests { .expect("setting reas timeout failed"); // Send telecommands - let mut sph = SpHeader::tc_unseg(TEST_APID_0, 0, 0).unwrap(); - let ping_tc = PusTcCreator::new_simple(&mut sph, 17, 1, None, true); + let ping_tc = + PusTcCreator::new_simple(SpHeader::new_from_apid(TEST_APID_0), 17, 1, &[], true); let tc_0 = ping_tc.to_vec().expect("ping tc creation failed"); stream .write_all(&tc_0) .expect("writing to TCP server failed"); - let mut sph = SpHeader::tc_unseg(TEST_APID_1, 0, 0).unwrap(); - let action_tc = PusTcCreator::new_simple(&mut sph, 8, 0, None, true); + let action_tc = + PusTcCreator::new_simple(SpHeader::new_from_apid(TEST_APID_1), 8, 0, &[], true); let tc_1 = action_tc.to_vec().expect("action tc creation failed"); stream .write_all(&tc_1) diff --git a/satrs/src/hal/std/udp_server.rs b/satrs/src/hal/std/udp_server.rs index fa117f0..8f77c2b 100644 --- a/satrs/src/hal/std/udp_server.rs +++ b/satrs/src/hal/std/udp_server.rs @@ -40,8 +40,8 @@ use std::vec::Vec; /// let ping_receiver = PingReceiver::default(); /// let mut udp_tc_server = UdpTcServer::new(dest_addr, 2048, Box::new(ping_receiver)) /// .expect("Creating UDP TMTC server failed"); -/// let mut sph = SpHeader::tc_unseg(0x02, 0, 0).unwrap(); -/// let pus_tc = PusTcCreator::new_simple(&mut sph, 17, 1, None, true); +/// let sph = SpHeader::new_from_apid(0x02); +/// let pus_tc = PusTcCreator::new_simple(sph, 17, 1, &[], true); /// let len = pus_tc /// .write_to_bytes(&mut buf) /// .expect("Error writing PUS TC packet"); @@ -178,8 +178,8 @@ mod tests { let mut udp_tc_server = UdpTcServer::new(dest_addr, 2048, Box::new(ping_receiver)) .expect("Creating UDP TMTC server failed"); is_send(&udp_tc_server); - let mut sph = SpHeader::tc_unseg(0x02, 0, 0).unwrap(); - let pus_tc = PusTcCreator::new_simple(&mut sph, 17, 1, None, true); + let sph = SpHeader::new_from_apid(0x02); + let pus_tc = PusTcCreator::new_simple(sph, 17, 1, &[], true); let len = pus_tc .write_to_bytes(&mut buf) .expect("Error writing PUS TC packet"); diff --git a/satrs/src/lib.rs b/satrs/src/lib.rs index 3c5d29c..f6b43e6 100644 --- a/satrs/src/lib.rs +++ b/satrs/src/lib.rs @@ -49,5 +49,70 @@ pub mod params; pub use spacepackets; +use spacepackets::PacketId; + /// Generic component ID type. pub type ComponentId = u64; + +pub trait ValidatorU16Id { + fn validate(&self, id: u16) -> bool; +} + +#[cfg(feature = "alloc")] +impl ValidatorU16Id for alloc::vec::Vec { + fn validate(&self, id: u16) -> bool { + self.contains(&id) + } +} + +#[cfg(feature = "alloc")] +impl ValidatorU16Id for hashbrown::HashSet { + fn validate(&self, id: u16) -> bool { + self.contains(&id) + } +} + +impl ValidatorU16Id for [u16] { + fn validate(&self, id: u16) -> bool { + self.binary_search(&id).is_ok() + } +} + +impl ValidatorU16Id for &[u16] { + fn validate(&self, id: u16) -> bool { + self.binary_search(&id).is_ok() + } +} + +#[cfg(feature = "alloc")] +impl ValidatorU16Id for alloc::vec::Vec { + fn validate(&self, packet_id: u16) -> bool { + self.contains(&PacketId::from(packet_id)) + } +} + +#[cfg(feature = "alloc")] +impl ValidatorU16Id for hashbrown::HashSet { + fn validate(&self, packet_id: u16) -> bool { + self.contains(&PacketId::from(packet_id)) + } +} + +#[cfg(feature = "std")] +impl ValidatorU16Id for std::collections::HashSet { + fn validate(&self, packet_id: u16) -> bool { + self.contains(&PacketId::from(packet_id)) + } +} + +impl ValidatorU16Id for [PacketId] { + fn validate(&self, packet_id: u16) -> bool { + self.binary_search(&PacketId::from(packet_id)).is_ok() + } +} + +impl ValidatorU16Id for &[PacketId] { + fn validate(&self, packet_id: u16) -> bool { + self.binary_search(&PacketId::from(packet_id)).is_ok() + } +} diff --git a/satrs/src/pus/event.rs b/satrs/src/pus/event.rs index c360f5c..233b609 100644 --- a/satrs/src/pus/event.rs +++ b/satrs/src/pus/event.rs @@ -113,7 +113,6 @@ impl EventReportCreator { src_data_len += aux_data.len(); } source_buffer_large_enough(src_data_buf.len(), src_data_len)?; - let mut sp_header = SpHeader::tm_unseg(self.apid, 0, 0).unwrap(); let sec_header = PusTmSecondaryHeader::new(5, subservice.into(), 0, self.dest_id, time_stamp); let mut current_idx = 0; @@ -124,7 +123,7 @@ impl EventReportCreator { current_idx += aux_data.len(); } Ok(PusTmCreator::new( - &mut sp_header, + SpHeader::new_from_apid(self.apid), sec_header, &src_data_buf[0..current_idx], true, diff --git a/satrs/src/pus/event_man.rs b/satrs/src/pus/event_man.rs index 43c1c31..eecb375 100644 --- a/satrs/src/pus/event_man.rs +++ b/satrs/src/pus/event_man.rs @@ -270,12 +270,12 @@ mod tests { const TEST_ID: UniqueApidTargetId = UniqueApidTargetId::new(TEST_APID, 0x05); fn create_basic_man_1() -> DefaultPusEventU32Dispatcher<()> { - let reporter = EventReporter::new(TEST_ID.raw(), TEST_APID, 128) + let reporter = EventReporter::new(TEST_ID.raw(), TEST_APID, 0, 128) .expect("Creating event repoter failed"); PusEventDispatcher::new_with_default_backend(reporter) } fn create_basic_man_2() -> DefaultPusEventU32Dispatcher<()> { - let reporter = EventReporter::new(TEST_ID.raw(), TEST_APID, 128) + let reporter = EventReporter::new(TEST_ID.raw(), TEST_APID, 0, 128) .expect("Creating event repoter failed"); let backend = DefaultPusEventMgmtBackend::default(); PusEventDispatcher::new(reporter, backend) diff --git a/satrs/src/pus/event_srv.rs b/satrs/src/pus/event_srv.rs index e68b04c..bb08f58 100644 --- a/satrs/src/pus/event_srv.rs +++ b/satrs/src/pus/event_srv.rs @@ -158,7 +158,7 @@ mod tests { tc::{PusTcCreator, PusTcSecondaryHeader}, tm::PusTmReader, }, - SequenceFlags, SpHeader, + SpHeader, }; use std::sync::mpsc::{self, Sender}; @@ -236,13 +236,13 @@ mod tests { expected_event_req: EventRequest, event_req_receiver: mpsc::Receiver, ) { - let mut sp_header = SpHeader::tc(TEST_APID, SequenceFlags::Unsegmented, 0, 0).unwrap(); + let sp_header = SpHeader::new_for_unseg_tc(TEST_APID, 0, 0); let sec_header = PusTcSecondaryHeader::new_simple(5, subservice as u8); let mut app_data = [0; 4]; TEST_EVENT_0 .write_to_be_bytes(&mut app_data) .expect("writing test event failed"); - let ping_tc = PusTcCreator::new(&mut sp_header, sec_header, &app_data, true); + let ping_tc = PusTcCreator::new(sp_header, sec_header, &app_data, true); let token = test_harness.init_verification(&ping_tc); test_harness.send_tc(&token, &ping_tc); let request_id = token.request_id(); @@ -298,9 +298,9 @@ mod tests { fn test_sending_custom_subservice() { let (event_request_tx, _) = mpsc::channel(); let mut test_harness = Pus5HandlerWithStoreTester::new(event_request_tx); - let mut sp_header = SpHeader::tc(TEST_APID, SequenceFlags::Unsegmented, 0, 0).unwrap(); + let sp_header = SpHeader::new_for_unseg_tc(TEST_APID, 0, 0); let sec_header = PusTcSecondaryHeader::new_simple(5, 200); - let ping_tc = PusTcCreator::new_no_app_data(&mut sp_header, sec_header, true); + let ping_tc = PusTcCreator::new_no_app_data(sp_header, sec_header, true); let token = test_harness.init_verification(&ping_tc); test_harness.send_tc(&token, &ping_tc); let result = test_harness.handle_one_tc(); @@ -317,10 +317,10 @@ mod tests { fn test_sending_invalid_app_data() { let (event_request_tx, _) = mpsc::channel(); let mut test_harness = Pus5HandlerWithStoreTester::new(event_request_tx); - let mut sp_header = SpHeader::tc(TEST_APID, SequenceFlags::Unsegmented, 0, 0).unwrap(); + let sp_header = SpHeader::new_for_unseg_tc(TEST_APID, 0, 0); let sec_header = PusTcSecondaryHeader::new_simple(5, Subservice::TcEnableEventGeneration as u8); - let ping_tc = PusTcCreator::new(&mut sp_header, sec_header, &[0, 1, 2], true); + let ping_tc = PusTcCreator::new(sp_header, sec_header, &[0, 1, 2], true); let token = test_harness.init_verification(&ping_tc); test_harness.send_tc(&token, &ping_tc); let result = test_harness.handle_one_tc(); diff --git a/satrs/src/pus/scheduler.rs b/satrs/src/pus/scheduler.rs index e223990..b3b9ef2 100644 --- a/satrs/src/pus/scheduler.rs +++ b/satrs/src/pus/scheduler.rs @@ -871,28 +871,28 @@ mod tests { cds::CdsTime::from_unix_time_with_u16_days(×tamp, cds::SubmillisPrecision::Absent) .unwrap(); let len_time_stamp = cds_time.write_to_bytes(buf).unwrap(); - let len_packet = base_ping_tc_simple_ctor(0, None) + let len_packet = base_ping_tc_simple_ctor(0, &[]) .write_to_bytes(&mut buf[len_time_stamp..]) .unwrap(); ( - SpHeader::tc_unseg(0x02, 0x34, len_packet as u16).unwrap(), + SpHeader::new_for_unseg_tc(0x02, 0x34, len_packet as u16), len_packet + len_time_stamp, ) } fn scheduled_tc(timestamp: UnixTime, buf: &mut [u8]) -> PusTcCreator { - let (mut sph, len_app_data) = pus_tc_base(timestamp, buf); - PusTcCreator::new_simple(&mut sph, 11, 4, Some(&buf[..len_app_data]), true) + let (sph, len_app_data) = pus_tc_base(timestamp, buf); + PusTcCreator::new_simple(sph, 11, 4, &buf[..len_app_data], true) } fn wrong_tc_service(timestamp: UnixTime, buf: &mut [u8]) -> PusTcCreator { - let (mut sph, len_app_data) = pus_tc_base(timestamp, buf); - PusTcCreator::new_simple(&mut sph, 12, 4, Some(&buf[..len_app_data]), true) + let (sph, len_app_data) = pus_tc_base(timestamp, buf); + PusTcCreator::new_simple(sph, 12, 4, &buf[..len_app_data], true) } fn wrong_tc_subservice(timestamp: UnixTime, buf: &mut [u8]) -> PusTcCreator { - let (mut sph, len_app_data) = pus_tc_base(timestamp, buf); - PusTcCreator::new_simple(&mut sph, 11, 5, Some(&buf[..len_app_data]), true) + let (sph, len_app_data) = pus_tc_base(timestamp, buf); + PusTcCreator::new_simple(sph, 11, 5, &buf[..len_app_data], true) } fn double_wrapped_time_tagged_tc(timestamp: UnixTime, buf: &mut [u8]) -> PusTcCreator { @@ -900,40 +900,31 @@ mod tests { cds::CdsTime::from_unix_time_with_u16_days(×tamp, cds::SubmillisPrecision::Absent) .unwrap(); let len_time_stamp = cds_time.write_to_bytes(buf).unwrap(); - let mut sph = SpHeader::tc_unseg(0x02, 0x34, 0).unwrap(); + let sph = SpHeader::new_for_unseg_tc(0x02, 0x34, 0); // app data should not matter, double wrapped time-tagged commands should be rejected right // away - let inner_time_tagged_tc = PusTcCreator::new_simple(&mut sph, 11, 4, None, true); + let inner_time_tagged_tc = PusTcCreator::new_simple(sph, 11, 4, &[], true); let packet_len = inner_time_tagged_tc .write_to_bytes(&mut buf[len_time_stamp..]) .expect("writing inner time tagged tc failed"); - PusTcCreator::new_simple( - &mut sph, - 11, - 4, - Some(&buf[..len_time_stamp + packet_len]), - true, - ) + PusTcCreator::new_simple(sph, 11, 4, &buf[..len_time_stamp + packet_len], true) } fn invalid_time_tagged_cmd() -> PusTcCreator<'static> { - let mut sph = SpHeader::tc_unseg(0x02, 0x34, 1).unwrap(); - PusTcCreator::new_simple(&mut sph, 11, 4, None, true) + let sph = SpHeader::new_for_unseg_tc(0x02, 0x34, 1); + PusTcCreator::new_simple(sph, 11, 4, &[], true) } - fn base_ping_tc_simple_ctor( - seq_count: u16, - app_data: Option<&'static [u8]>, - ) -> PusTcCreator<'static> { - let mut sph = SpHeader::tc_unseg(0x02, seq_count, 0).unwrap(); - PusTcCreator::new_simple(&mut sph, 17, 1, app_data, true) + fn base_ping_tc_simple_ctor(seq_count: u16, app_data: &'static [u8]) -> PusTcCreator<'static> { + let sph = SpHeader::new_for_unseg_tc(0x02, seq_count, 0); + PusTcCreator::new_simple(sph, 17, 1, app_data, true) } fn ping_tc_to_store( pool: &mut StaticMemoryPool, buf: &mut [u8], seq_count: u16, - app_data: Option<&'static [u8]>, + app_data: &'static [u8], ) -> TcInfo { let ping_tc = base_ping_tc_simple_ctor(seq_count, app_data); let ping_size = ping_tc.write_to_bytes(buf).expect("writing ping TC failed"); @@ -957,7 +948,7 @@ mod tests { let mut scheduler = PusScheduler::new(UnixTime::new_only_secs(0), Duration::from_secs(5)); let mut buf: [u8; 32] = [0; 32]; - let tc_info_0 = ping_tc_to_store(&mut pool, &mut buf, 0, None); + let tc_info_0 = ping_tc_to_store(&mut pool, &mut buf, 0, &[]); scheduler .insert_unwrapped_and_stored_tc( @@ -967,7 +958,7 @@ mod tests { .unwrap(); let app_data = &[0, 1, 2]; - let tc_info_1 = ping_tc_to_store(&mut pool, &mut buf, 1, Some(app_data)); + let tc_info_1 = ping_tc_to_store(&mut pool, &mut buf, 1, app_data); scheduler .insert_unwrapped_and_stored_tc( UnixTime::new_only_secs(200), @@ -976,7 +967,7 @@ mod tests { .unwrap(); let app_data = &[0, 1, 2]; - let tc_info_2 = ping_tc_to_store(&mut pool, &mut buf, 2, Some(app_data)); + let tc_info_2 = ping_tc_to_store(&mut pool, &mut buf, 2, app_data); scheduler .insert_unwrapped_and_stored_tc( UnixTime::new_only_secs(300), @@ -1087,10 +1078,10 @@ mod tests { let src_id_to_set = 12; let apid_to_set = 0x22; let seq_count = 105; - let mut sp_header = SpHeader::tc_unseg(apid_to_set, 105, 0).unwrap(); + let sp_header = SpHeader::new_for_unseg_tc(apid_to_set, 105, 0); let mut sec_header = PusTcSecondaryHeader::new_simple(17, 1); sec_header.source_id = src_id_to_set; - let ping_tc = PusTcCreator::new_no_app_data(&mut sp_header, sec_header, true); + let ping_tc = PusTcCreator::new_no_app_data(sp_header, sec_header, true); let req_id = RequestId::from_tc(&ping_tc); assert_eq!(req_id.source_id(), src_id_to_set); assert_eq!(req_id.apid(), apid_to_set); @@ -1106,13 +1097,13 @@ mod tests { let mut scheduler = PusScheduler::new(UnixTime::new_only_secs(0), Duration::from_secs(5)); let mut buf: [u8; 32] = [0; 32]; - let tc_info_0 = ping_tc_to_store(&mut pool, &mut buf, 0, None); + let tc_info_0 = ping_tc_to_store(&mut pool, &mut buf, 0, &[]); scheduler .insert_unwrapped_and_stored_tc(UnixTime::new_only_secs(100), tc_info_0) .expect("insertion failed"); - let tc_info_1 = ping_tc_to_store(&mut pool, &mut buf, 1, None); + let tc_info_1 = ping_tc_to_store(&mut pool, &mut buf, 1, &[]); scheduler .insert_unwrapped_and_stored_tc(UnixTime::new_only_secs(200), tc_info_1) .expect("insertion failed"); @@ -1171,13 +1162,13 @@ mod tests { let mut scheduler = PusScheduler::new(UnixTime::new_only_secs(0), Duration::from_secs(5)); let mut buf: [u8; 32] = [0; 32]; - let tc_info_0 = ping_tc_to_store(&mut pool, &mut buf, 0, None); + let tc_info_0 = ping_tc_to_store(&mut pool, &mut buf, 0, &[]); scheduler .insert_unwrapped_and_stored_tc(UnixTime::new_only_secs(100), tc_info_0) .expect("insertion failed"); - let tc_info_1 = ping_tc_to_store(&mut pool, &mut buf, 1, None); + let tc_info_1 = ping_tc_to_store(&mut pool, &mut buf, 1, &[]); scheduler .insert_unwrapped_and_stored_tc(UnixTime::new_only_secs(100), tc_info_1) .expect("insertion failed"); @@ -1230,13 +1221,13 @@ mod tests { scheduler.disable(); let mut buf: [u8; 32] = [0; 32]; - let tc_info_0 = ping_tc_to_store(&mut pool, &mut buf, 0, None); + let tc_info_0 = ping_tc_to_store(&mut pool, &mut buf, 0, &[]); scheduler .insert_unwrapped_and_stored_tc(UnixTime::new_only_secs(100), tc_info_0) .expect("insertion failed"); - let tc_info_1 = ping_tc_to_store(&mut pool, &mut buf, 1, None); + let tc_info_1 = ping_tc_to_store(&mut pool, &mut buf, 1, &[]); scheduler .insert_unwrapped_and_stored_tc(UnixTime::new_only_secs(200), tc_info_1) .expect("insertion failed"); @@ -1294,7 +1285,7 @@ mod tests { let mut pool = StaticMemoryPool::new(StaticPoolConfig::new(vec![(10, 32), (5, 64)], false)); let mut buf: [u8; 32] = [0; 32]; - let tc_info_0 = ping_tc_to_store(&mut pool, &mut buf, 0, None); + let tc_info_0 = ping_tc_to_store(&mut pool, &mut buf, 0, &[]); let info = scheduler .insert_unwrapped_tc( @@ -1309,7 +1300,7 @@ mod tests { let mut read_buf: [u8; 64] = [0; 64]; pool.read(&tc_info_0.addr(), &mut read_buf).unwrap(); let check_tc = PusTcReader::new(&read_buf).expect("incorrect Pus tc raw data"); - assert_eq!(check_tc.0, base_ping_tc_simple_ctor(0, None)); + assert_eq!(check_tc.0, base_ping_tc_simple_ctor(0, &[])); assert_eq!(scheduler.num_scheduled_telecommands(), 1); @@ -1332,7 +1323,7 @@ mod tests { let read_len = pool.read(&addr_vec[0], &mut read_buf).unwrap(); let check_tc = PusTcReader::new(&read_buf).expect("incorrect Pus tc raw data"); assert_eq!(read_len, check_tc.1); - assert_eq!(check_tc.0, base_ping_tc_simple_ctor(0, None)); + assert_eq!(check_tc.0, base_ping_tc_simple_ctor(0, &[])); } #[test] @@ -1356,7 +1347,7 @@ mod tests { let read_len = pool.read(&info.addr, &mut buf).unwrap(); let check_tc = PusTcReader::new(&buf).expect("incorrect Pus tc raw data"); assert_eq!(read_len, check_tc.1); - assert_eq!(check_tc.0, base_ping_tc_simple_ctor(0, None)); + assert_eq!(check_tc.0, base_ping_tc_simple_ctor(0, &[])); assert_eq!(scheduler.num_scheduled_telecommands(), 1); @@ -1381,7 +1372,7 @@ mod tests { let read_len = pool.read(&addr_vec[0], &mut buf).unwrap(); let check_tc = PusTcReader::new(&buf).expect("incorrect PUS tc raw data"); assert_eq!(read_len, check_tc.1); - assert_eq!(check_tc.0, base_ping_tc_simple_ctor(0, None)); + assert_eq!(check_tc.0, base_ping_tc_simple_ctor(0, &[])); } #[test] @@ -1506,7 +1497,7 @@ mod tests { let mut pool = StaticMemoryPool::new(StaticPoolConfig::new(vec![(10, 32), (5, 64)], false)); let mut scheduler = PusScheduler::new(UnixTime::new_only_secs(0), Duration::from_secs(5)); let mut buf: [u8; 32] = [0; 32]; - let tc_info_0 = ping_tc_to_store(&mut pool, &mut buf, 0, None); + let tc_info_0 = ping_tc_to_store(&mut pool, &mut buf, 0, &[]); scheduler .insert_unwrapped_and_stored_tc(UnixTime::new_only_secs(100), tc_info_0) .expect("insertion failed"); @@ -1540,7 +1531,7 @@ mod tests { let mut pool = StaticMemoryPool::new(StaticPoolConfig::new(vec![(10, 32), (5, 64)], false)); let mut scheduler = PusScheduler::new(UnixTime::new_only_secs(0), Duration::from_secs(5)); let mut buf: [u8; 32] = [0; 32]; - let tc_info_0 = ping_tc_to_store(&mut pool, &mut buf, 0, None); + let tc_info_0 = ping_tc_to_store(&mut pool, &mut buf, 0, &[]); scheduler .insert_unwrapped_and_stored_tc(UnixTime::new_only_secs(100), tc_info_0) .expect("insertion failed"); @@ -1563,7 +1554,7 @@ mod tests { let mut pool = StaticMemoryPool::new(StaticPoolConfig::new(vec![(10, 32), (5, 64)], false)); let mut scheduler = PusScheduler::new(UnixTime::new_only_secs(0), Duration::from_secs(5)); let mut buf: [u8; 32] = [0; 32]; - let tc_info_0 = ping_tc_to_store(&mut pool, &mut buf, 0, None); + let tc_info_0 = ping_tc_to_store(&mut pool, &mut buf, 0, &[]); scheduler .insert_unwrapped_and_stored_tc(UnixTime::new_only_secs(100), tc_info_0) .expect("inserting tc failed"); @@ -1581,7 +1572,7 @@ mod tests { let mut pool = StaticMemoryPool::new(StaticPoolConfig::new(vec![(10, 32), (5, 64)], false)); let mut scheduler = PusScheduler::new(UnixTime::new_only_secs(0), Duration::from_secs(5)); let mut buf: [u8; 32] = [0; 32]; - let tc_info_0 = ping_tc_to_store(&mut pool, &mut buf, 0, None); + let tc_info_0 = ping_tc_to_store(&mut pool, &mut buf, 0, &[]); scheduler .insert_unwrapped_and_stored_tc(UnixTime::new_only_secs(100), tc_info_0) .expect("inserting tc failed"); @@ -1599,15 +1590,15 @@ mod tests { let mut pool = StaticMemoryPool::new(StaticPoolConfig::new(vec![(10, 32), (5, 64)], false)); let mut scheduler = PusScheduler::new(UnixTime::new_only_secs(0), Duration::from_secs(5)); let mut buf: [u8; 32] = [0; 32]; - let tc_info_0 = ping_tc_to_store(&mut pool, &mut buf, 0, None); + let tc_info_0 = ping_tc_to_store(&mut pool, &mut buf, 0, &[]); scheduler .insert_unwrapped_and_stored_tc(UnixTime::new_only_secs(100), tc_info_0) .expect("inserting tc failed"); - let tc_info_1 = ping_tc_to_store(&mut pool, &mut buf, 1, None); + let tc_info_1 = ping_tc_to_store(&mut pool, &mut buf, 1, &[]); scheduler .insert_unwrapped_and_stored_tc(UnixTime::new_only_secs(100), tc_info_1) .expect("inserting tc failed"); - let tc_info_2 = ping_tc_to_store(&mut pool, &mut buf, 2, None); + let tc_info_2 = ping_tc_to_store(&mut pool, &mut buf, 2, &[]); scheduler .insert_unwrapped_and_stored_tc(UnixTime::new_only_secs(100), tc_info_2) .expect("inserting tc failed"); @@ -1667,7 +1658,7 @@ mod tests { release_secs: u64, ) -> TcInfo { let mut buf: [u8; 32] = [0; 32]; - let tc_info = ping_tc_to_store(pool, &mut buf, seq_count, None); + let tc_info = ping_tc_to_store(pool, &mut buf, seq_count, &[]); scheduler .insert_unwrapped_and_stored_tc(UnixTime::new_only_secs(release_secs as i64), tc_info) @@ -1915,13 +1906,13 @@ mod tests { let mut scheduler = PusScheduler::new(UnixTime::new_only_secs(0), Duration::from_secs(5)); let mut buf: [u8; 32] = [0; 32]; - let tc_info_0 = ping_tc_to_store(&mut pool, &mut buf, 0, None); + let tc_info_0 = ping_tc_to_store(&mut pool, &mut buf, 0, &[]); scheduler .insert_unwrapped_and_stored_tc(UnixTime::new_only_secs(100), tc_info_0) .expect("insertion failed"); - let tc_info_1 = ping_tc_to_store(&mut pool, &mut buf, 1, None); + let tc_info_1 = ping_tc_to_store(&mut pool, &mut buf, 1, &[]); scheduler .insert_unwrapped_and_stored_tc(UnixTime::new_only_secs(200), tc_info_1) .expect("insertion failed"); @@ -1949,13 +1940,13 @@ mod tests { #[test] fn test_generic_insert_app_data_test() { let time_writer = cds::CdsTime::new_with_u16_days(1, 1); - let mut sph = SpHeader::new( - PacketId::const_new(PacketType::Tc, true, 0x002), - PacketSequenceCtrl::const_new(SequenceFlags::Unsegmented, 5), + let sph = SpHeader::new( + PacketId::new(PacketType::Tc, true, 0x002), + PacketSequenceCtrl::new(SequenceFlags::Unsegmented, 5), 0, ); let sec_header = PusTcSecondaryHeader::new_simple(17, 1); - let ping_tc = PusTcCreator::new_no_app_data(&mut sph, sec_header, true); + let ping_tc = PusTcCreator::new_no_app_data(sph, sec_header, true); let mut buf: [u8; 64] = [0; 64]; let result = generate_insert_telecommand_app_data(&mut buf, &time_writer, &ping_tc); assert!(result.is_ok()); @@ -1971,13 +1962,13 @@ mod tests { #[test] fn test_generic_insert_app_data_test_byte_conv_error() { let time_writer = cds::CdsTime::new_with_u16_days(1, 1); - let mut sph = SpHeader::new( - PacketId::const_new(PacketType::Tc, true, 0x002), - PacketSequenceCtrl::const_new(SequenceFlags::Unsegmented, 5), + let sph = SpHeader::new( + PacketId::new(PacketType::Tc, true, 0x002), + PacketSequenceCtrl::new(SequenceFlags::Unsegmented, 5), 0, ); let sec_header = PusTcSecondaryHeader::new_simple(17, 1); - let ping_tc = PusTcCreator::new_no_app_data(&mut sph, sec_header, true); + let ping_tc = PusTcCreator::new_no_app_data(sph, sec_header, true); let mut buf: [u8; 16] = [0; 16]; let result = generate_insert_telecommand_app_data(&mut buf, &time_writer, &ping_tc); assert!(result.is_err()); @@ -2000,13 +1991,13 @@ mod tests { #[test] fn test_generic_insert_app_data_test_as_vec() { let time_writer = cds::CdsTime::new_with_u16_days(1, 1); - let mut sph = SpHeader::new( - PacketId::const_new(PacketType::Tc, true, 0x002), - PacketSequenceCtrl::const_new(SequenceFlags::Unsegmented, 5), + let sph = SpHeader::new( + PacketId::new(PacketType::Tc, true, 0x002), + PacketSequenceCtrl::new(SequenceFlags::Unsegmented, 5), 0, ); let sec_header = PusTcSecondaryHeader::new_simple(17, 1); - let ping_tc = PusTcCreator::new_no_app_data(&mut sph, sec_header, true); + let ping_tc = PusTcCreator::new_no_app_data(sph, sec_header, true); let mut buf: [u8; 64] = [0; 64]; generate_insert_telecommand_app_data(&mut buf, &time_writer, &ping_tc).unwrap(); let vec = generate_insert_telecommand_app_data_as_vec(&time_writer, &ping_tc) diff --git a/satrs/src/pus/scheduler_srv.rs b/satrs/src/pus/scheduler_srv.rs index 05de81e..6812770 100644 --- a/satrs/src/pus/scheduler_srv.rs +++ b/satrs/src/pus/scheduler_srv.rs @@ -375,9 +375,9 @@ mod tests { test_harness: &mut Pus11HandlerWithStoreTester, subservice: Subservice, ) { - let mut reply_header = SpHeader::tm_unseg(TEST_APID, 0, 0).unwrap(); + let reply_header = SpHeader::new_for_unseg_tm(TEST_APID, 0, 0); let tc_header = PusTcSecondaryHeader::new_simple(11, subservice as u8); - let enable_scheduling = PusTcCreator::new(&mut reply_header, tc_header, &[0; 7], true); + let enable_scheduling = PusTcCreator::new(reply_header, tc_header, &[0; 7], true); let token = test_harness.init_verification(&enable_scheduling); test_harness.send_tc(&token, &enable_scheduling); @@ -422,9 +422,9 @@ mod tests { #[test] fn test_insert_activity_tc() { let mut test_harness = Pus11HandlerWithStoreTester::new(); - let mut reply_header = SpHeader::tm_unseg(TEST_APID, 0, 0).unwrap(); + let mut reply_header = SpHeader::new_for_unseg_tc(TEST_APID, 0, 0); let mut sec_header = PusTcSecondaryHeader::new_simple(17, 1); - let ping_tc = PusTcCreator::new(&mut reply_header, sec_header, &[], true); + let ping_tc = PusTcCreator::new(reply_header, sec_header, &[], true); let req_id_ping_tc = scheduler::RequestId::from_tc(&ping_tc); let stamper = cds::CdsTime::now_with_u16_days().expect("time provider failed"); let mut sched_app_data: [u8; 64] = [0; 64]; @@ -432,10 +432,10 @@ mod tests { let ping_raw = ping_tc.to_vec().expect("generating raw tc failed"); sched_app_data[written_len..written_len + ping_raw.len()].copy_from_slice(&ping_raw); written_len += ping_raw.len(); - reply_header = SpHeader::tm_unseg(TEST_APID, 1, 0).unwrap(); + reply_header = SpHeader::new_for_unseg_tc(TEST_APID, 1, 0); sec_header = PusTcSecondaryHeader::new_simple(11, Subservice::TcInsertActivity as u8); let enable_scheduling = PusTcCreator::new( - &mut reply_header, + reply_header, sec_header, &sched_app_data[..written_len], true, diff --git a/satrs/src/pus/test.rs b/satrs/src/pus/test.rs index c859e7b..58abb0f 100644 --- a/satrs/src/pus/test.rs +++ b/satrs/src/pus/test.rs @@ -78,10 +78,12 @@ impl< None }; // Sequence count will be handled centrally in TM funnel. - let mut reply_header = - SpHeader::tm_unseg(self.service_helper.verif_reporter().apid(), 0, 0).unwrap(); + // It is assumed that the verification reporter was built with a valid APID, so we use + // the unchecked API here. + let reply_header = + SpHeader::new_for_unseg_tm(self.service_helper.verif_reporter().apid(), 0, 0); let tc_header = PusTmSecondaryHeader::new_simple(17, 2, time_stamp); - let ping_reply = PusTmCreator::new(&mut reply_header, tc_header, &[], true); + let ping_reply = PusTmCreator::new(reply_header, tc_header, &[], true); let result = self .service_helper .common @@ -175,7 +177,7 @@ mod tests { use spacepackets::ecss::tm::PusTmReader; use spacepackets::ecss::PusPacket; use spacepackets::time::{cds, TimeWriter}; - use spacepackets::{SequenceFlags, SpHeader}; + use spacepackets::SpHeader; use super::PusService17TestHandler; @@ -283,9 +285,9 @@ mod tests { fn ping_test(test_harness: &mut (impl PusTestHarness + SimplePusPacketHandler)) { // Create a ping TC, verify acceptance. - let mut sp_header = SpHeader::tc(TEST_APID, SequenceFlags::Unsegmented, 0, 0).unwrap(); + let sp_header = SpHeader::new_for_unseg_tc(TEST_APID, 0, 0); let sec_header = PusTcSecondaryHeader::new_simple(17, 1); - let ping_tc = PusTcCreator::new_no_app_data(&mut sp_header, sec_header, true); + let ping_tc = PusTcCreator::new_no_app_data(sp_header, sec_header, true); let token = test_harness.init_verification(&ping_tc); test_harness.send_tc(&token, &ping_tc); let request_id = token.request_id(); @@ -337,9 +339,9 @@ mod tests { #[test] fn test_sending_unsupported_service() { let mut test_harness = Pus17HandlerWithStoreTester::new(0); - let mut sp_header = SpHeader::tc(TEST_APID, SequenceFlags::Unsegmented, 0, 0).unwrap(); + let sp_header = SpHeader::new_for_unseg_tc(TEST_APID, 0, 0); let sec_header = PusTcSecondaryHeader::new_simple(3, 1); - let ping_tc = PusTcCreator::new_no_app_data(&mut sp_header, sec_header, true); + let ping_tc = PusTcCreator::new_no_app_data(sp_header, sec_header, true); let token = test_harness.init_verification(&ping_tc); test_harness.send_tc(&token, &ping_tc); let result = test_harness.handle_one_tc(); @@ -358,9 +360,9 @@ mod tests { #[test] fn test_sending_custom_subservice() { let mut test_harness = Pus17HandlerWithStoreTester::new(0); - let mut sp_header = SpHeader::tc(TEST_APID, SequenceFlags::Unsegmented, 0, 0).unwrap(); + let sp_header = SpHeader::new_for_unseg_tc(TEST_APID, 0, 0); let sec_header = PusTcSecondaryHeader::new_simple(17, 200); - let ping_tc = PusTcCreator::new_no_app_data(&mut sp_header, sec_header, true); + let ping_tc = PusTcCreator::new_no_app_data(sp_header, sec_header, true); let token = test_harness.init_verification(&ping_tc); test_harness.send_tc(&token, &ping_tc); let result = test_harness.handle_one_tc(); diff --git a/satrs/src/pus/verification.rs b/satrs/src/pus/verification.rs index 27194ea..35dc972 100644 --- a/satrs/src/pus/verification.rs +++ b/satrs/src/pus/verification.rs @@ -41,9 +41,12 @@ //! let cfg = VerificationReporterCfg::new(TEST_APID, 1, 2, 8).unwrap(); //! let mut reporter = VerificationReporter::new(TEST_COMPONENT_ID.id(), &cfg); //! -//! let mut sph = SpHeader::tc_unseg(TEST_APID, 0, 0).unwrap(); //! let tc_header = PusTcSecondaryHeader::new_simple(17, 1); -//! let pus_tc_0 = PusTcCreator::new_no_app_data(&mut sph, tc_header, true); +//! let pus_tc_0 = PusTcCreator::new_no_app_data( +//! SpHeader::new_from_apid(TEST_APID), +//! tc_header, +//! true +//! ); //! let init_token = reporter.add_tc(&pus_tc_0); //! //! // Complete success sequence for a telecommand @@ -804,12 +807,12 @@ impl VerificationReportCreator { step.write_to_be_bytes(&mut src_data_buf[idx..idx + step.size()]) .unwrap(); } - let mut sp_header = SpHeader::tm_unseg(self.apid(), seq_count, 0).unwrap(); + let sp_header = SpHeader::new_for_unseg_tm(self.apid(), seq_count, 0); Ok(self.create_pus_verif_tm_base( src_data_buf, subservice, msg_counter, - &mut sp_header, + sp_header, time_stamp, source_data_len, )) @@ -847,12 +850,12 @@ impl VerificationReportCreator { .write_to_be_bytes(&mut src_data_buf[idx..idx + params.failure_code.size()])?; idx += params.failure_code.size(); src_data_buf[idx..idx + params.failure_data.len()].copy_from_slice(params.failure_data); - let mut sp_header = SpHeader::tm_unseg(self.apid(), seq_count, 0).unwrap(); + let sp_header = SpHeader::new_for_unseg_tm(self.apid(), seq_count, 0); Ok(self.create_pus_verif_tm_base( src_data_buf, subservice, msg_counter, - &mut sp_header, + sp_header, params.time_stamp, source_data_len, )) @@ -863,7 +866,7 @@ impl VerificationReportCreator { src_data_buf: &'src_data mut [u8], subservice: u8, msg_counter: u16, - sp_header: &mut SpHeader, + sp_header: SpHeader, time_stamp: &'time [u8], source_data_len: usize, ) -> PusTmCreator<'time, 'src_data> { @@ -2115,9 +2118,9 @@ pub mod tests { } fn create_generic_ping() -> PusTcCreator<'static> { - let mut sph = SpHeader::tc_unseg(TEST_APID, 0x34, 0).unwrap(); + let sph = SpHeader::new_for_unseg_tc(TEST_APID, 0x34, 0); let tc_header = PusTcSecondaryHeader::new_simple(17, 1); - PusTcCreator::new(&mut sph, tc_header, &[], true) + PusTcCreator::new(sph, tc_header, &[], true) } #[test] diff --git a/satrs/src/request.rs b/satrs/src/request.rs index bc43fd7..f2104ed 100644 --- a/satrs/src/request.rs +++ b/satrs/src/request.rs @@ -417,9 +417,9 @@ mod tests { #[test] fn test_basic_target_id_with_apid_from_pus_tc() { - let mut sp_header = SpHeader::tc_unseg(0x111, 5, 0).unwrap(); + let sp_header = SpHeader::new_for_unseg_tc(0x111, 5, 0); let app_data = 1_u32.to_be_bytes(); - let pus_tc = PusTcCreator::new_simple(&mut sp_header, 17, 1, Some(&app_data), true); + let pus_tc = PusTcCreator::new_simple(sp_header, 17, 1, &app_data, true); let id = UniqueApidTargetId::from_pus_tc(&pus_tc).unwrap(); assert_eq!(id.apid, 0x111); assert_eq!(id.unique_id, 1); @@ -427,9 +427,9 @@ mod tests { #[test] fn test_basic_target_id_with_apid_from_pus_tc_invalid_app_data() { - let mut sp_header = SpHeader::tc_unseg(0x111, 5, 0).unwrap(); + let sp_header = SpHeader::new_for_unseg_tc(0x111, 5, 0); let sec_header = PusTcSecondaryHeader::new_simple(17, 1); - let pus_tc = PusTcCreator::new_no_app_data(&mut sp_header, sec_header, true); + let pus_tc = PusTcCreator::new_no_app_data(sp_header, sec_header, true); let error = UniqueApidTargetId::from_pus_tc(&pus_tc); assert!(error.is_err()); let error = error.unwrap_err(); diff --git a/satrs/src/tmtc/ccsds_distrib.rs b/satrs/src/tmtc/ccsds_distrib.rs index 813ffdd..607b461 100644 --- a/satrs/src/tmtc/ccsds_distrib.rs +++ b/satrs/src/tmtc/ccsds_distrib.rs @@ -18,6 +18,7 @@ //! # Example //! //! ```rust +//! use satrs::ValidatorU16Id; //! use satrs::tmtc::ccsds_distrib::{CcsdsPacketHandler, CcsdsDistributor}; //! use satrs::tmtc::{ReceivesTc, ReceivesTcCore}; //! use spacepackets::{CcsdsPacket, SpHeader}; @@ -34,16 +35,19 @@ //! fn mutable_foo(&mut self) {} //! } //! +//! impl ValidatorU16Id for ConcreteApidHandler { +//! fn validate(&self, apid: u16) -> bool { apid == 0x0002 } +//! } +//! //! impl CcsdsPacketHandler for ConcreteApidHandler { //! type Error = (); -//! fn valid_apids(&self) -> &'static [u16] { &[0x002] } -//! fn handle_known_apid(&mut self, sp_header: &SpHeader, tc_raw: &[u8]) -> Result<(), Self::Error> { +//! fn handle_packet_with_valid_apid(&mut self, sp_header: &SpHeader, tc_raw: &[u8]) -> Result<(), Self::Error> { //! assert_eq!(sp_header.apid(), 0x002); //! assert_eq!(tc_raw.len(), 13); //! self.known_call_count += 1; //! Ok(()) //! } -//! fn handle_unknown_apid(&mut self, sp_header: &SpHeader, tc_raw: &[u8]) -> Result<(), Self::Error> { +//! fn handle_packet_with_unknown_apid(&mut self, sp_header: &SpHeader, tc_raw: &[u8]) -> Result<(), Self::Error> { //! assert_eq!(sp_header.apid(), 0x003); //! assert_eq!(tc_raw.len(), 13); //! self.unknown_call_count += 1; @@ -55,8 +59,8 @@ //! let mut ccsds_distributor = CcsdsDistributor::new(apid_handler); //! //! // Create and pass PUS telecommand with a valid APID -//! let mut space_packet_header = SpHeader::tc_unseg(0x002, 0x34, 0).unwrap(); -//! let mut pus_tc = PusTcCreator::new_simple(&mut space_packet_header, 17, 1, None, true); +//! let sp_header = SpHeader::new_for_unseg_tc(0x002, 0x34, 0); +//! let mut pus_tc = PusTcCreator::new_simple(sp_header, 17, 1, &[], true); //! let mut test_buf: [u8; 32] = [0; 32]; //! let mut size = pus_tc //! .write_to_bytes(test_buf.as_mut_slice()) @@ -82,8 +86,8 @@ //! mutable_handler_ref.mutable_foo(); //! ``` use crate::{ - encoding::ccsds::PacketIdValidator, tmtc::{ReceivesCcsdsTc, ReceivesTcCore}, + ValidatorU16Id, }; use core::fmt::{Display, Formatter}; use spacepackets::{ByteConversionError, CcsdsPacket, SpHeader}; @@ -95,8 +99,9 @@ use std::error::Error; /// Users should implement this trait on their custom CCSDS packet handler and then pass a boxed /// instance of this handler to the [CcsdsDistributor]. The distributor will use the trait /// interface to dispatch received packets to the user based on the Application Process Identifier -/// (APID) field of the CCSDS packet. -pub trait CcsdsPacketHandler: PacketIdValidator { +/// (APID) field of the CCSDS packet. The APID will be checked using the generic [ValidatorU16Id] +/// trait. +pub trait CcsdsPacketHandler: ValidatorU16Id { type Error; fn handle_packet_with_valid_apid( @@ -189,13 +194,12 @@ impl, E: 'static> CcsdsDistributor< } fn dispatch_ccsds(&mut self, sp_header: &SpHeader, tc_raw: &[u8]) -> Result<(), CcsdsError> { - //let valid_apids = self.packet_handler.valid_apids(); - let valid_apid = self.packet_handler().validate(sp_header.packet_id().raw()); + let valid_apid = self.packet_handler().validate(sp_header.apid()); if valid_apid { - return self - .packet_handler + self.packet_handler .handle_packet_with_valid_apid(sp_header, tc_raw) - .map_err(|e| CcsdsError::CustomError(e)); + .map_err(|e| CcsdsError::CustomError(e))?; + return Ok(()); } self.packet_handler .handle_packet_with_unknown_apid(sp_header, tc_raw) @@ -217,8 +221,8 @@ pub(crate) mod tests { fn is_send(_: &T) {} pub fn generate_ping_tc(buf: &mut [u8]) -> &[u8] { - let mut sph = SpHeader::tc_unseg(0x002, 0x34, 0).unwrap(); - let pus_tc = PusTcCreator::new_simple(&mut sph, 17, 1, None, true); + let sph = SpHeader::new_for_unseg_tc(0x002, 0x34, 0); + let pus_tc = PusTcCreator::new_simple(sph, 17, 1, &[], true); let size = pus_tc .write_to_bytes(buf) .expect("Error writing TC to buffer"); @@ -227,8 +231,8 @@ pub(crate) mod tests { } pub fn generate_ping_tc_as_vec() -> Vec { - let mut sph = SpHeader::tc_unseg(0x002, 0x34, 0).unwrap(); - PusTcCreator::new_simple(&mut sph, 17, 1, None, true) + let sph = SpHeader::new_for_unseg_tc(0x002, 0x34, 0); + PusTcCreator::new_simple(sph, 17, 1, &[], true) .to_vec() .unwrap() } @@ -245,9 +249,9 @@ pub(crate) mod tests { pub unknown_packet_queue: VecDeque<(u16, Vec)>, } - impl PacketIdValidator for BasicApidHandlerSharedQueue { + impl ValidatorU16Id for BasicApidHandlerSharedQueue { fn validate(&self, packet_id: u16) -> bool { - &[0x000, 0x002].contains(&packet_id) + [0x000, 0x002].contains(&packet_id) } } @@ -283,9 +287,9 @@ pub(crate) mod tests { } } - impl PacketIdValidator for BasicApidHandlerOwnedQueue { + impl ValidatorU16Id for BasicApidHandlerOwnedQueue { fn validate(&self, packet_id: u16) -> bool { - &[0x000, 0x002].contains(&packet_id) + [0x000, 0x002].contains(&packet_id) } } @@ -341,8 +345,8 @@ pub(crate) mod tests { fn test_unknown_apid_handling() { let apid_handler = BasicApidHandlerOwnedQueue::default(); let mut ccsds_distrib = CcsdsDistributor::new(apid_handler); - let mut sph = SpHeader::tc_unseg(0x004, 0x34, 0).unwrap(); - let pus_tc = PusTcCreator::new_simple(&mut sph, 17, 1, None, true); + let sph = SpHeader::new_for_unseg_tc(0x004, 0x34, 0); + let pus_tc = PusTcCreator::new_simple(sph, 17, 1, &[], true); let mut test_buf: [u8; 32] = [0; 32]; pus_tc .write_to_bytes(test_buf.as_mut_slice()) @@ -360,8 +364,8 @@ pub(crate) mod tests { #[test] fn test_ccsds_distribution() { let mut ccsds_distrib = CcsdsDistributor::new(BasicApidHandlerOwnedQueue::default()); - let mut sph = SpHeader::tc_unseg(0x002, 0x34, 0).unwrap(); - let pus_tc = PusTcCreator::new_simple(&mut sph, 17, 1, None, true); + let sph = SpHeader::new_for_unseg_tc(0x002, 0x34, 0); + let pus_tc = PusTcCreator::new_simple(sph, 17, 1, &[], true); let tc_vec = pus_tc.to_vec().unwrap(); ccsds_distrib .pass_ccsds(&sph, &tc_vec) @@ -379,8 +383,8 @@ pub(crate) mod tests { #[test] fn test_distribution_short_packet_fails() { let mut ccsds_distrib = CcsdsDistributor::new(BasicApidHandlerOwnedQueue::default()); - let mut sph = SpHeader::tc_unseg(0x002, 0x34, 0).unwrap(); - let pus_tc = PusTcCreator::new_simple(&mut sph, 17, 1, None, true); + let sph = SpHeader::new_for_unseg_tc(0x002, 0x34, 0); + let pus_tc = PusTcCreator::new_simple(sph, 17, 1, &[], true); let tc_vec = pus_tc.to_vec().unwrap(); let result = ccsds_distrib.pass_tc(&tc_vec[0..6]); assert!(result.is_err()); diff --git a/satrs/src/tmtc/pus_distrib.rs b/satrs/src/tmtc/pus_distrib.rs index f5d6c8d..53056bc 100644 --- a/satrs/src/tmtc/pus_distrib.rs +++ b/satrs/src/tmtc/pus_distrib.rs @@ -46,8 +46,8 @@ //! let mut pus_distributor = PusDistributor::new(service_handler); //! //! // Create and pass PUS ping telecommand with a valid APID -//! let mut space_packet_header = SpHeader::tc_unseg(0x002, 0x34, 0).unwrap(); -//! let mut pus_tc = PusTcCreator::new_simple(&mut space_packet_header, 17, 1, None, true); +//! let sp_header = SpHeader::new_for_unseg_tc(0x002, 0x34, 0); +//! let mut pus_tc = PusTcCreator::new_simple(sp_header, 17, 1, &[], true); //! let mut test_buf: [u8; 32] = [0; 32]; //! let mut size = pus_tc //! .write_to_bytes(test_buf.as_mut_slice()) @@ -176,6 +176,7 @@ mod tests { BasicApidHandlerSharedQueue, }; use crate::tmtc::ccsds_distrib::{CcsdsDistributor, CcsdsPacketHandler}; + use crate::ValidatorU16Id; use alloc::format; use alloc::vec::Vec; use spacepackets::ecss::PusError; @@ -253,17 +254,13 @@ mod tests { () => { type Error = PusError; - fn valid_apids(&self) -> &'static [u16] { - &[0x000, 0x002] - } - - fn handle_known_apid( + fn handle_packet_with_valid_apid( &mut self, sp_header: &SpHeader, tc_raw: &[u8], ) -> Result<(), Self::Error> { self.handler_base - .handle_known_apid(&sp_header, tc_raw) + .handle_packet_with_valid_apid(&sp_header, tc_raw) .ok() .expect("Unexpected error"); match self.pus_distrib.pass_ccsds(&sp_header, tc_raw) { @@ -275,13 +272,13 @@ mod tests { } } - fn handle_unknown_apid( + fn handle_packet_with_unknown_apid( &mut self, sp_header: &SpHeader, tc_raw: &[u8], ) -> Result<(), Self::Error> { self.handler_base - .handle_unknown_apid(&sp_header, tc_raw) + .handle_packet_with_unknown_apid(&sp_header, tc_raw) .ok() .expect("Unexpected error"); Ok(()) @@ -289,6 +286,18 @@ mod tests { }; } + impl ValidatorU16Id for ApidHandlerOwned { + fn validate(&self, packet_id: u16) -> bool { + [0x000, 0x002].contains(&packet_id) + } + } + + impl ValidatorU16Id for ApidHandlerShared { + fn validate(&self, packet_id: u16) -> bool { + [0x000, 0x002].contains(&packet_id) + } + } + impl CcsdsPacketHandler for ApidHandlerOwned { apid_handler_impl!(); } diff --git a/satrs/src/tmtc/tm_helper.rs b/satrs/src/tmtc/tm_helper.rs index 630a338..a305472 100644 --- a/satrs/src/tmtc/tm_helper.rs +++ b/satrs/src/tmtc/tm_helper.rs @@ -92,9 +92,9 @@ impl PusTmWithCdsShortHelper { source_data: &'a [u8], seq_count: u16, ) -> PusTmCreator { - let mut reply_header = SpHeader::tm_unseg(self.apid, seq_count, 0).unwrap(); + let reply_header = SpHeader::new_for_unseg_tm(self.apid, seq_count, 0); let tc_header = PusTmSecondaryHeader::new_simple(service, subservice, &self.cds_short_buf); - PusTmCreator::new(&mut reply_header, tc_header, source_data, true) + PusTmCreator::new(reply_header, tc_header, source_data, true) } } diff --git a/satrs/tests/pus_events.rs b/satrs/tests/pus_events.rs index e47cb55..6fc518f 100644 --- a/satrs/tests/pus_events.rs +++ b/satrs/tests/pus_events.rs @@ -39,7 +39,7 @@ fn test_threaded_usage() { event_man.add_sender(pus_event_man_send_provider); let (event_tx, event_rx) = mpsc::channel::(); let reporter = - EventReporter::new(TEST_ID.raw(), 0x02, 128).expect("Creating event reporter failed"); + EventReporter::new(TEST_ID.raw(), 0x02, 0, 128).expect("Creating event reporter failed"); let pus_event_man = PusEventDispatcher::new(reporter, DefaultPusEventMgmtBackend::default()); let error_handler = |event_msg: &EventMessageU32, error: EventRoutingError| { panic!("received routing error for event {event_msg:?}: {error:?}"); diff --git a/satrs/tests/pus_verification.rs b/satrs/tests/pus_verification.rs index c75f848..743535f 100644 --- a/satrs/tests/pus_verification.rs +++ b/satrs/tests/pus_verification.rs @@ -1,4 +1,4 @@ -#[cfg(feature = "crossbeam")] +// #[cfg(feature = "crossbeam")] pub mod crossbeam_test { use hashbrown::HashMap; use satrs::pool::{PoolProvider, PoolProviderWithGuards, StaticMemoryPool, StaticPoolConfig}; @@ -53,9 +53,9 @@ pub mod crossbeam_test { let (tx_tc_1, rx_tc_1) = crossbeam_channel::bounded(3); { let mut tc_guard = shared_tc_pool_0.write().unwrap(); - let mut sph = SpHeader::tc_unseg(TEST_APID, 0, 0).unwrap(); + let sph = SpHeader::new_for_unseg_tc(TEST_APID, 0, 0); let tc_header = PusTcSecondaryHeader::new_simple(17, 1); - let pus_tc_0 = PusTcCreator::new_no_app_data(&mut sph, tc_header, true); + let pus_tc_0 = PusTcCreator::new_no_app_data(sph, tc_header, true); req_id_0 = RequestId::new(&pus_tc_0); let addr = tc_guard .free_element(pus_tc_0.len_written(), |buf| { @@ -63,9 +63,9 @@ pub mod crossbeam_test { }) .unwrap(); tx_tc_0.send(addr).unwrap(); - let mut sph = SpHeader::tc_unseg(TEST_APID, 1, 0).unwrap(); + let sph = SpHeader::new_for_unseg_tc(TEST_APID, 1, 0); let tc_header = PusTcSecondaryHeader::new_simple(5, 1); - let pus_tc_1 = PusTcCreator::new_no_app_data(&mut sph, tc_header, true); + let pus_tc_1 = PusTcCreator::new_no_app_data(sph, tc_header, true); req_id_1 = RequestId::new(&pus_tc_1); let addr = tc_guard .free_element(pus_tc_0.len_written(), |buf| { diff --git a/satrs/tests/tcp_servers.rs b/satrs/tests/tcp_servers.rs index b960df7..ff3fe78 100644 --- a/satrs/tests/tcp_servers.rs +++ b/satrs/tests/tcp_servers.rs @@ -31,7 +31,7 @@ use spacepackets::{ ecss::{tc::PusTcCreator, WritablePusPacket}, PacketId, SpHeader, }; -use std::{boxed::Box, collections::VecDeque, sync::Arc, vec::Vec}; +use std::{collections::VecDeque, sync::Arc, vec::Vec}; #[derive(Default, Clone)] struct SyncTcCacher { @@ -162,14 +162,14 @@ fn test_cobs_server() { } const TEST_APID_0: u16 = 0x02; -const TEST_PACKET_ID_0: PacketId = PacketId::const_tc(true, TEST_APID_0); +const TEST_PACKET_ID_0: PacketId = PacketId::new_for_tc(true, TEST_APID_0); #[test] fn test_ccsds_server() { let tc_receiver = SyncTcCacher::default(); let mut tm_source = SyncTmSource::default(); - let mut sph = SpHeader::tc_unseg(TEST_APID_0, 0, 0).unwrap(); - let verif_tm = PusTcCreator::new_simple(&mut sph, 1, 1, None, true); + let sph = SpHeader::new_for_unseg_tc(TEST_APID_0, 0, 0); + let verif_tm = PusTcCreator::new_simple(sph, 1, 1, &[], true); let tm_0 = verif_tm.to_vec().expect("tm generation failed"); tm_source.add_tm(&tm_0); let mut packet_id_lookup = HashSet::new(); @@ -178,7 +178,7 @@ fn test_ccsds_server() { ServerConfig::new(AUTO_PORT_ADDR, Duration::from_millis(2), 1024, 1024), tm_source, tc_receiver.clone(), - Box::new(packet_id_lookup), + packet_id_lookup, ) .expect("TCP server generation failed"); let dest_addr = tcp_server @@ -203,8 +203,8 @@ fn test_ccsds_server() { .expect("setting reas timeout failed"); // Send ping telecommand. - let mut sph = SpHeader::tc_unseg(TEST_APID_0, 0, 0).unwrap(); - let ping_tc = PusTcCreator::new_simple(&mut sph, 17, 1, None, true); + let sph = SpHeader::new_for_unseg_tc(TEST_APID_0, 0, 0); + let ping_tc = PusTcCreator::new_simple(sph, 17, 1, &[], true); let tc_0 = ping_tc.to_vec().expect("packet creation failed"); stream .write_all(&tc_0)