all changes for updated spacepackets

satrs-example/src/acs/mgm.rs

@@ -147,7 +147,6 @@ impl<ComInterface: SpiInterface, TmSender: EcssTmSenderCore>
                         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<ComInterface: SpiInterface, TmSender: EcssTmSenderCore>
                 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 =
+                let hk_tm = PusTmCreator::new(
-                    PusTmCreator::new(&mut sp_header, sec_header, &self.tm_buf[0..12], true);
+                    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");

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(SpHeader::new_from_apid(0x02), 17, 1, &[], true);
-    let pus_tc = PusTcCreator::new_simple(&mut sph, 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}");

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<Error = E> + ReceivesEcssPusTc<Error = E> + Clone + 'static,
         E: 'static,
-    > PacketIdValidator for CcsdsReceiver<TcSource, E>
+    > ValidatorU16Id for CcsdsReceiver<TcSource, E>
 {
     fn validate(&self, packet_id: u16) -> bool {
         PACKET_ID_VALIDATOR.contains(&PacketId::from(packet_id))

satrs-example/src/config.rs

@@ -45,7 +45,7 @@ lazy_static! {
     pub static ref PACKET_ID_VALIDATOR: HashSet<PacketId> = {
         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
     };

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());

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);

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,

satrs-example/src/pus/mode.rs

@@ -78,11 +78,10 @@ impl PusReplyHandler<ActivePusRequestStd, ModeReply> 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)
+                let sp_header = SpHeader::new_for_unseg_tm(req_id.packet_id().apid(), 0, 0);
-                    .expect("generating SP header failed");
                 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)

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 sph = SpHeader::new_for_unseg_tc(components::Apid::GenericPus as u16, 0, 0);
-        let ping_tc = PusTcCreator::new_simple(&mut sph, 17, 1, None, true)
+        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");

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`

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.

satrs/src/encoding/ccsds.rs

@@ -1,76 +1,4 @@
-#[cfg(feature = "alloc")]
+use crate::{tmtc::ReceivesTcCore, ValidatorU16Id};
-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<u16> {
-    fn validate(&self, packet_id: u16) -> bool {
-        self.contains(&packet_id)
-    }
-}
-
-#[cfg(feature = "alloc")]
-impl PacketIdValidator for HashSet<u16> {
-    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<PacketId> {
-    fn validate(&self, packet_id: u16) -> bool {
-        self.contains(&PacketId::from(packet_id))
-    }
-}
-
-#[cfg(feature = "alloc")]
-impl PacketIdValidator for HashSet<PacketId> {
-    fn validate(&self, packet_id: u16) -> bool {
-        self.contains(&PacketId::from(packet_id))
-    }
-}
-
-#[cfg(feature = "std")]
-impl PacketIdValidator for StdHashSet<PacketId> {
-    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()
-    }
-}
 
 /// 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<E>(
     buf: &mut [u8],
-    packet_id_validator: &(impl PacketIdValidator + ?Sized),
+    packet_id_validator: &(impl ValidatorU16Id + ?Sized),
     tc_receiver: &mut (impl ReceivesTcCore<Error = E> + ?Sized),
     next_write_idx: &mut usize,
 ) -> Result<u32, E> {
@@ -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_0: PacketId = PacketId::new_for_tc(true, TEST_APID_0);
-    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);
 
     #[test]
     fn test_basic() {
-        let mut sph = SpHeader::tc_unseg(TEST_APID_0, 0, 0).unwrap();
+        let sph = SpHeader::new_from_apid(TEST_APID_0);
-        let ping_tc = PusTcCreator::new_simple(&mut sph, 17, 1, None, true);
+        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 sph = SpHeader::new_from_apid(TEST_APID_0);
-        let ping_tc = PusTcCreator::new_simple(&mut sph, 17, 1, None, true);
+        let ping_tc = PusTcCreator::new_simple(sph, 17, 1, &[], true);
-        let action_tc = PusTcCreator::new_simple(&mut sph, 8, 0, None, 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 sph = SpHeader::new_from_apid(TEST_APID_0);
-        let ping_tc = PusTcCreator::new_simple(&mut sph, 17, 1, None, true);
+        let ping_tc = PusTcCreator::new_simple(sph, 17, 1, &[], true);
-        sph = SpHeader::tc_unseg(TEST_APID_1, 0, 0).unwrap();
+        let sph = SpHeader::new_from_apid(TEST_APID_1);
-        let action_tc = PusTcCreator::new_simple(&mut sph, 8, 0, None, 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)
@@ -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 =
-        let ping_tc = PusTcCreator::new_simple(&mut sph, 17, 1, None, true);
+            PusTcCreator::new_simple(SpHeader::new_from_apid(TEST_APID_0), 17, 1, &[], true);
-        sph = SpHeader::tc_unseg(TEST_APID_1, 0, 0).unwrap();
+        let action_tc =
-        let action_tc = PusTcCreator::new_simple(&mut sph, 8, 0, None, true);
+            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 =
-        let ping_tc = PusTcCreator::new_simple(&mut sph, 17, 1, None, true);
+            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)

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<PacketIdChecker: PacketIdValidator> {
+pub struct SpacepacketsTcParser<PacketIdChecker: ValidatorU16Id> {
     packet_id_lookup: PacketIdChecker,
 }
 
-impl<PacketIdChecker: PacketIdValidator> SpacepacketsTcParser<PacketIdChecker> {
+impl<PacketIdChecker: ValidatorU16Id> SpacepacketsTcParser<PacketIdChecker> {
     pub fn new(packet_id_lookup: PacketIdChecker) -> Self {
         Self { packet_id_lookup }
     }
 }
 
-impl<TmError, TcError: 'static, PacketIdChecker: PacketIdValidator> TcpTcParser<TmError, TcError>
+impl<TmError, TcError: 'static, PacketIdChecker: ValidatorU16Id> TcpTcParser<TmError, TcError>
     for SpacepacketsTcParser<PacketIdChecker>
 {
     fn handle_tc_parsing(
@@ -95,7 +96,7 @@ pub struct TcpSpacepacketsServer<
     TcError: 'static,
     TmSource: TmPacketSource<Error = TmError>,
     TcReceiver: ReceivesTc<Error = TcError>,
-    PacketIdChecker: PacketIdValidator,
+    PacketIdChecker: ValidatorU16Id,
 > {
     generic_server: TcpTmtcGenericServer<
         TmError,
@@ -112,7 +113,7 @@ impl<
         TcError: 'static,
         TmSource: TmPacketSource<Error = TmError>,
         TcReceiver: ReceivesTc<Error = TcError>,
-        PacketIdChecker: PacketIdValidator,
+        PacketIdChecker: ValidatorU16Id,
     > TcpSpacepacketsServer<TmError, TcError, TmSource, TcReceiver, PacketIdChecker>
 {
     ///
@@ -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 =
-        let ping_tc = PusTcCreator::new_simple(&mut sph, 17, 1, None, true);
+            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 =
-        let verif_tm = PusTcCreator::new_simple(&mut sph, 1, 1, None, true);
+            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 =
-        let verif_tm = PusTcCreator::new_simple(&mut sph, 1, 3, None, true);
+            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 =
-        let ping_tc = PusTcCreator::new_simple(&mut sph, 17, 1, None, true);
+            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 =
-        let action_tc = PusTcCreator::new_simple(&mut sph, 8, 0, None, true);
+            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)

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 sph = SpHeader::new_from_apid(0x02);
-/// let pus_tc = PusTcCreator::new_simple(&mut sph, 17, 1, None, true);
+/// 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 sph = SpHeader::new_from_apid(0x02);
-        let pus_tc = PusTcCreator::new_simple(&mut sph, 17, 1, None, true);
+        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");

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<u16> {
+    fn validate(&self, id: u16) -> bool {
+        self.contains(&id)
+    }
+}
+
+#[cfg(feature = "alloc")]
+impl ValidatorU16Id for hashbrown::HashSet<u16> {
+    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<spacepackets::PacketId> {
+    fn validate(&self, packet_id: u16) -> bool {
+        self.contains(&PacketId::from(packet_id))
+    }
+}
+
+#[cfg(feature = "alloc")]
+impl ValidatorU16Id for hashbrown::HashSet<spacepackets::PacketId> {
+    fn validate(&self, packet_id: u16) -> bool {
+        self.contains(&PacketId::from(packet_id))
+    }
+}
+
+#[cfg(feature = "std")]
+impl ValidatorU16Id for std::collections::HashSet<PacketId> {
+    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()
+    }
+}

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,

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)

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<EventRequestWithToken>,
     ) {
-        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();

satrs/src/pus/scheduler.rs

@@ -871,28 +871,28 @@ mod tests {
             cds::CdsTime::from_unix_time_with_u16_days(&timestamp, 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);
+        let (sph, len_app_data) = pus_tc_base(timestamp, buf);
-        PusTcCreator::new_simple(&mut sph, 11, 4, Some(&buf[..len_app_data]), true)
+        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);
+        let (sph, len_app_data) = pus_tc_base(timestamp, buf);
-        PusTcCreator::new_simple(&mut sph, 12, 4, Some(&buf[..len_app_data]), true)
+        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);
+        let (sph, len_app_data) = pus_tc_base(timestamp, buf);
-        PusTcCreator::new_simple(&mut sph, 11, 5, Some(&buf[..len_app_data]), true)
+        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(&timestamp, 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(
+        PusTcCreator::new_simple(sph, 11, 4, &buf[..len_time_stamp + packet_len], true)
-            &mut sph,
-            11,
-            4,
-            Some(&buf[..len_time_stamp + packet_len]),
-            true,
-        )
     }
 
     fn invalid_time_tagged_cmd() -> PusTcCreator<'static> {
-        let mut sph = SpHeader::tc_unseg(0x02, 0x34, 1).unwrap();
+        let sph = SpHeader::new_for_unseg_tc(0x02, 0x34, 1);
-        PusTcCreator::new_simple(&mut sph, 11, 4, None, true)
+        PusTcCreator::new_simple(sph, 11, 4, &[], true)
     }
 
-    fn base_ping_tc_simple_ctor(
+    fn base_ping_tc_simple_ctor(seq_count: u16, app_data: &'static [u8]) -> PusTcCreator<'static> {
-        seq_count: u16,
+        let sph = SpHeader::new_for_unseg_tc(0x02, seq_count, 0);
-        app_data: Option<&'static [u8]>,
+        PusTcCreator::new_simple(sph, 17, 1, app_data, true)
-    ) -> PusTcCreator<'static> {
-        let mut sph = SpHeader::tc_unseg(0x02, seq_count, 0).unwrap();
-        PusTcCreator::new_simple(&mut 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(
+        let sph = SpHeader::new(
-            PacketId::const_new(PacketType::Tc, true, 0x002),
+            PacketId::new(PacketType::Tc, true, 0x002),
-            PacketSequenceCtrl::const_new(SequenceFlags::Unsegmented, 5),
+            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(
+        let sph = SpHeader::new(
-            PacketId::const_new(PacketType::Tc, true, 0x002),
+            PacketId::new(PacketType::Tc, true, 0x002),
-            PacketSequenceCtrl::const_new(SequenceFlags::Unsegmented, 5),
+            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(
+        let sph = SpHeader::new(
-            PacketId::const_new(PacketType::Tc, true, 0x002),
+            PacketId::new(PacketType::Tc, true, 0x002),
-            PacketSequenceCtrl::const_new(SequenceFlags::Unsegmented, 5),
+            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)

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,

satrs/src/pus/test.rs

@@ -78,10 +78,12 @@ impl<
                 None
             };
             // Sequence count will be handled centrally in TM funnel.
-            let mut reply_header =
+            // It is assumed that the verification reporter was built with a valid APID, so we use
-                SpHeader::tm_unseg(self.service_helper.verif_reporter().apid(), 0, 0).unwrap();
+            // 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();

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]

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();

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_packet_with_valid_apid(&mut self, sp_header: &SpHeader, tc_raw: &[u8]) -> Result<(), Self::Error> {
-//!     fn handle_known_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 sp_header = SpHeader::new_for_unseg_tc(0x002, 0x34, 0);
-//! let mut pus_tc = PusTcCreator::new_simple(&mut space_packet_header, 17, 1, None, true);
+//! 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.
+/// (APID) field of the CCSDS packet. The APID will be checked using the generic [ValidatorU16Id]
-pub trait CcsdsPacketHandler: PacketIdValidator {
+/// trait.
+pub trait CcsdsPacketHandler: ValidatorU16Id {
     type Error;
 
     fn handle_packet_with_valid_apid(
@@ -189,13 +194,12 @@ impl<PacketHandler: CcsdsPacketHandler<Error = E>, E: 'static> CcsdsDistributor<
     }
 
     fn dispatch_ccsds(&mut self, sp_header: &SpHeader, tc_raw: &[u8]) -> Result<(), CcsdsError<E>> {
-        //let valid_apids = self.packet_handler.valid_apids();
+        let valid_apid = self.packet_handler().validate(sp_header.apid());
-        let valid_apid = self.packet_handler().validate(sp_header.packet_id().raw());
         if valid_apid {
-            return self
+            self.packet_handler
-                .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: Send>(_: &T) {}
 
     pub fn generate_ping_tc(buf: &mut [u8]) -> &[u8] {
-        let mut sph = SpHeader::tc_unseg(0x002, 0x34, 0).unwrap();
+        let sph = SpHeader::new_for_unseg_tc(0x002, 0x34, 0);
-        let pus_tc = PusTcCreator::new_simple(&mut sph, 17, 1, None, true);
+        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<u8> {
-        let mut sph = SpHeader::tc_unseg(0x002, 0x34, 0).unwrap();
+        let sph = SpHeader::new_for_unseg_tc(0x002, 0x34, 0);
-        PusTcCreator::new_simple(&mut sph, 17, 1, None, true)
+        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<u8>)>,
     }
 
-    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 sph = SpHeader::new_for_unseg_tc(0x004, 0x34, 0);
-        let pus_tc = PusTcCreator::new_simple(&mut sph, 17, 1, None, true);
+        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 sph = SpHeader::new_for_unseg_tc(0x002, 0x34, 0);
-        let pus_tc = PusTcCreator::new_simple(&mut sph, 17, 1, None, true);
+        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 sph = SpHeader::new_for_unseg_tc(0x002, 0x34, 0);
-        let pus_tc = PusTcCreator::new_simple(&mut sph, 17, 1, None, true);
+        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());

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 sp_header = SpHeader::new_for_unseg_tc(0x002, 0x34, 0);
-//! let mut pus_tc = PusTcCreator::new_simple(&mut space_packet_header, 17, 1, None, true);
+//! 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] {
+            fn handle_packet_with_valid_apid(
-                &[0x000, 0x002]
-            }
-
-            fn handle_known_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!();
     }

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)
     }
 }
 

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::<PusTmAsVec>();
     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:?}");

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| {

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 sph = SpHeader::new_for_unseg_tc(TEST_APID_0, 0, 0);
-    let verif_tm = PusTcCreator::new_simple(&mut sph, 1, 1, None, true);
+    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 sph = SpHeader::new_for_unseg_tc(TEST_APID_0, 0, 0);
-    let ping_tc = PusTcCreator::new_simple(&mut sph, 17, 1, None, true);
+    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)