bump spacepackets

update all the code
2025-09-11 09:29:34 +02:00 · 2025-09-10 19:01:44 +02:00
35 changed files with 560 additions and 373 deletions
--- a/satrs-example/Cargo.toml
+++ b/satrs-example/Cargo.toml
@@ -11,6 +11,8 @@ repository = "https://egit.irs.uni-stuttgart.de/rust/sat-rs"
 fern = "0.7"
 chrono = "0.4"
 log = "0.4"
+arbitrary-int = "2"
+bitbybit = "1.4"
 crossbeam-channel = "0.5"
 delegate = "0.13"
 zerocopy = "0.8"
--- a/satrs-example/src/acs/mgm.rs
+++ b/satrs-example/src/acs/mgm.rs
@@ -574,7 +574,7 @@ mod tests {
            let (request_tx, request_rx) = mpsc::sync_channel(5);
            let (reply_tx_to_pus, reply_rx_to_pus) = mpsc::sync_channel(5);
            let (reply_tx_to_parent, reply_rx_to_parent) = mpsc::sync_channel(5);
-            let id = UniqueApidTargetId::new(Apid::Acs as u16, 1);
+            let id = UniqueApidTargetId::new(Apid::Acs.raw_value(), 1);
            let mode_node = ModeRequestHandlerMpscBounded::new(id.into(), request_rx);
            let (composite_request_tx, composite_request_rx) = mpsc::channel();
            let (hk_reply_tx, hk_reply_rx) = mpsc::sync_channel(10);
--- a/satrs-example/src/bin/simpleclient.rs
+++ b/satrs-example/src/bin/simpleclient.rs
@@ -1,7 +1,9 @@
+use arbitrary_int::u11;
 use satrs::pus::verification::RequestId;
 use satrs::spacepackets::ecss::tc::PusTcCreator;
 use satrs::spacepackets::ecss::tm::PusTmReader;
-use satrs::{spacepackets::ecss::PusPacket, spacepackets::SpHeader};
+use satrs::spacepackets::ecss::CreatorConfig;
+use satrs::spacepackets::SpHeader;
 use satrs_example::config::{OBSW_SERVER_ADDR, SERVER_PORT};
 use std::net::{IpAddr, SocketAddr, UdpSocket};
 use std::time::Duration;
@@ -9,7 +11,13 @@ use std::time::Duration;
 fn main() {
    let mut buf = [0; 32];
    let addr = SocketAddr::new(IpAddr::V4(OBSW_SERVER_ADDR), SERVER_PORT);
-    let pus_tc = PusTcCreator::new_simple(SpHeader::new_from_apid(0x02), 17, 1, &[], true);
+    let pus_tc = PusTcCreator::new_simple(
+        SpHeader::new_from_apid(u11::new(0x02)),
+        17,
+        1,
+        &[],
+        CreatorConfig::default(),
+    );
    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}");
--- a/satrs-example/src/config.rs
+++ b/satrs-example/src/config.rs
@@ -44,7 +44,7 @@ lazy_static! {
    pub static ref PACKET_ID_VALIDATOR: HashSet<PacketId> = {
        let mut set = HashSet::new();
        for id in crate::ids::Apid::iter() {
-            set.insert(PacketId::new(PacketType::Tc, true, id as u16));
+            set.insert(PacketId::new(PacketType::Tc, true, id.raw_value()));
        }
        set
    };
--- a/satrs-example/src/eps/pcdu.rs
+++ b/satrs-example/src/eps/pcdu.rs
@@ -572,7 +572,7 @@ mod tests {
            let (switch_request_tx, switch_reqest_rx) = mpsc::channel();
            let shared_switch_map = Arc::new(Mutex::new(SwitchSet::default()));
            let mut handler = PcduHandler::new(
-                UniqueApidTargetId::new(Apid::Eps as u16, 0),
+                UniqueApidTargetId::new(Apid::Eps.raw_value(), 0),
                "TEST_PCDU",
                mode_node,
                composite_request_rx,
--- a/satrs-example/src/events.rs
+++ b/satrs-example/src/events.rs
@@ -1,6 +1,7 @@
 use std::sync::mpsc::{self};

 use crate::pus::create_verification_reporter;
+use arbitrary_int::u11;
 use satrs::event_man::{EventMessageU32, EventRoutingError};
 use satrs::pus::event::EventTmHook;
 use satrs::pus::verification::VerificationReporter;
@@ -23,7 +24,7 @@ use crate::update_time;
 // This helper sets the APID of the event sender for the PUS telemetry.
 #[derive(Default)]
 pub struct EventApidSetter {
-    pub next_apid: u16,
+    pub next_apid: u11,
 }

 impl EventTmHook for EventApidSetter {
@@ -59,7 +60,7 @@ impl<TmSender: EcssTmSender> PusEventHandler<TmSender> {
        // telemetry for each event.
        let event_reporter = EventReporter::new_with_hook(
            PUS_EVENT_MANAGEMENT.raw(),
-            0,
+            u11::new(0),
            0,
            128,
            EventApidSetter::default(),
@@ -220,16 +221,13 @@ mod tests {
    use satrs::{
        events::EventU32,
        pus::verification::VerificationReporterConfig,
-        spacepackets::{
-            ecss::{tm::PusTmReader, PusPacket},
-            CcsdsPacket,
-        },
+        spacepackets::ecss::{tm::PusTmReader, PusPacket},
        tmtc::PacketAsVec,
    };

    use super::*;

-    const TEST_CREATOR_ID: UniqueApidTargetId = UniqueApidTargetId::new(1, 2);
+    const TEST_CREATOR_ID: UniqueApidTargetId = UniqueApidTargetId::new(u11::new(1), 2);
    const TEST_EVENT: EventU32 = EventU32::new(satrs::events::Severity::Info, 1, 1);

    pub struct EventManagementTestbench {
@@ -244,7 +242,8 @@ mod tests {
            let (event_tx, event_rx) = mpsc::sync_channel(10);
            let (_event_req_tx, event_req_rx) = mpsc::sync_channel(10);
            let (tm_sender, tm_receiver) = mpsc::channel();
-            let verif_reporter_cfg = VerificationReporterConfig::new(0x05, 2, 2, 128).unwrap();
+            let verif_reporter_cfg =
+                VerificationReporterConfig::new(u11::new(0x05), 2, 2, 128).unwrap();
            let verif_reporter =
                VerificationReporter::new(PUS_EVENT_MANAGEMENT.id(), &verif_reporter_cfg);
            let mut event_manager = EventManagerWithBoundedMpsc::new(event_rx);
--- a/satrs-example/src/hk.rs
+++ b/satrs-example/src/hk.rs
@@ -1,8 +1,8 @@
 use derive_new::new;
 use satrs::hk::UniqueId;
 use satrs::request::UniqueApidTargetId;
-use satrs::spacepackets::ecss::hk;
 use satrs::spacepackets::ecss::tm::{PusTmCreator, PusTmSecondaryHeader};
+use satrs::spacepackets::ecss::{hk, CreatorConfig};
 use satrs::spacepackets::{ByteConversionError, SpHeader};

 #[derive(Debug, new, Copy, Clone)]
@@ -63,7 +63,7 @@ impl PusHkHelper {
            SpHeader::new_from_apid(self.component_id.apid),
            sec_header,
            &buf[0..8 + hk_data_len],
-            true,
+            CreatorConfig::default(),
        ))
    }
 }
--- a/satrs-example/src/ids.rs
+++ b/satrs-example/src/ids.rs
@@ -1,7 +1,8 @@
 //! This is an auto-generated configuration module.
 use satrs::request::UniqueApidTargetId;

-#[derive(Debug, Copy, Clone, PartialEq, Eq, strum::EnumIter)]
+#[derive(Debug, PartialEq, Eq, strum::EnumIter)]
+#[bitbybit::bitenum(u11, exhaustive = false)]
 pub enum Apid {
    Sched = 1,
    GenericPus = 2,
@@ -21,13 +22,13 @@ pub mod acs {
    }

    pub const SUBSYSTEM: super::UniqueApidTargetId =
-        super::UniqueApidTargetId::new(super::Apid::Acs as u16, Id::Subsystem as u32);
+        super::UniqueApidTargetId::new(super::Apid::Acs.raw_value(), Id::Subsystem as u32);
    pub const ASSEMBLY: super::UniqueApidTargetId =
-        super::UniqueApidTargetId::new(super::Apid::Acs as u16, Id::Assembly as u32);
+        super::UniqueApidTargetId::new(super::Apid::Acs.raw_value(), Id::Assembly as u32);
    pub const MGM0: super::UniqueApidTargetId =
-        super::UniqueApidTargetId::new(super::Apid::Acs as u16, Id::Mgm0 as u32);
+        super::UniqueApidTargetId::new(super::Apid::Acs.raw_value(), Id::Mgm0 as u32);
    pub const MGM1: super::UniqueApidTargetId =
-        super::UniqueApidTargetId::new(super::Apid::Acs as u16, Id::Mgm1 as u32);
+        super::UniqueApidTargetId::new(super::Apid::Acs.raw_value(), Id::Mgm1 as u32);
 }

 pub mod eps {
@@ -38,9 +39,9 @@ pub mod eps {
    }

    pub const PCDU: super::UniqueApidTargetId =
-        super::UniqueApidTargetId::new(super::Apid::Eps as u16, Id::Pcdu as u32);
+        super::UniqueApidTargetId::new(super::Apid::Eps.raw_value(), Id::Pcdu as u32);
    pub const SUBSYSTEM: super::UniqueApidTargetId =
-        super::UniqueApidTargetId::new(super::Apid::Eps as u16, Id::Subsystem as u32);
+        super::UniqueApidTargetId::new(super::Apid::Eps.raw_value(), Id::Subsystem as u32);
 }

 pub mod generic_pus {
@@ -55,19 +56,19 @@ pub mod generic_pus {
    }

    pub const PUS_EVENT_MANAGEMENT: super::UniqueApidTargetId = super::UniqueApidTargetId::new(
-        super::Apid::GenericPus as u16,
+        super::Apid::GenericPus.raw_value(),
        Id::PusEventManagement as u32,
    );
    pub const PUS_ROUTING: super::UniqueApidTargetId =
-        super::UniqueApidTargetId::new(super::Apid::GenericPus as u16, Id::PusRouting as u32);
+        super::UniqueApidTargetId::new(super::Apid::GenericPus.raw_value(), Id::PusRouting as u32);
    pub const PUS_TEST: super::UniqueApidTargetId =
-        super::UniqueApidTargetId::new(super::Apid::GenericPus as u16, Id::PusTest as u32);
+        super::UniqueApidTargetId::new(super::Apid::GenericPus.raw_value(), Id::PusTest as u32);
    pub const PUS_ACTION: super::UniqueApidTargetId =
-        super::UniqueApidTargetId::new(super::Apid::GenericPus as u16, Id::PusAction as u32);
+        super::UniqueApidTargetId::new(super::Apid::GenericPus.raw_value(), Id::PusAction as u32);
    pub const PUS_MODE: super::UniqueApidTargetId =
-        super::UniqueApidTargetId::new(super::Apid::GenericPus as u16, Id::PusMode as u32);
+        super::UniqueApidTargetId::new(super::Apid::GenericPus.raw_value(), Id::PusMode as u32);
    pub const PUS_HK: super::UniqueApidTargetId =
-        super::UniqueApidTargetId::new(super::Apid::GenericPus as u16, Id::PusHk as u32);
+        super::UniqueApidTargetId::new(super::Apid::GenericPus.raw_value(), Id::PusHk as u32);
 }

 pub mod sched {
@@ -77,7 +78,7 @@ pub mod sched {
    }

    pub const PUS_SCHED: super::UniqueApidTargetId =
-        super::UniqueApidTargetId::new(super::Apid::Sched as u16, Id::PusSched as u32);
+        super::UniqueApidTargetId::new(super::Apid::Sched.raw_value(), Id::PusSched as u32);
 }

 pub mod tmtc {
@@ -88,7 +89,7 @@ pub mod tmtc {
    }

    pub const UDP_SERVER: super::UniqueApidTargetId =
-        super::UniqueApidTargetId::new(super::Apid::Tmtc as u16, Id::UdpServer as u32);
+        super::UniqueApidTargetId::new(super::Apid::Tmtc.raw_value(), Id::UdpServer as u32);
    pub const TCP_SERVER: super::UniqueApidTargetId =
-        super::UniqueApidTargetId::new(super::Apid::Tmtc as u16, Id::TcpServer as u32);
+        super::UniqueApidTargetId::new(super::Apid::Tmtc.raw_value(), Id::TcpServer as u32);
 }
--- a/satrs-example/src/interface/udp.rs
+++ b/satrs-example/src/interface/udp.rs
@@ -113,6 +113,9 @@ mod tests {
        sync::{Arc, Mutex},
    };

+    use arbitrary_int::traits::Integer as _;
+    use arbitrary_int::u14;
+    use satrs::spacepackets::ecss::CreatorConfig;
    use satrs::{
        spacepackets::{
            ecss::{tc::PusTcCreator, WritablePusPacket},
@@ -177,8 +180,8 @@ mod tests {
            udp_tc_server,
            tm_handler,
        };
-        let sph = SpHeader::new_for_unseg_tc(ids::Apid::GenericPus as u16, 0, 0);
-        let ping_tc = PusTcCreator::new_simple(sph, 17, 1, &[], true)
+        let sph = SpHeader::new_for_unseg_tc(ids::Apid::GenericPus.raw_value(), u14::ZERO, 0);
+        let ping_tc = PusTcCreator::new_simple(sph, 17, 1, &[], CreatorConfig::default())
            .to_vec()
            .unwrap();
        let client = UdpSocket::bind("127.0.0.1:0").expect("Connecting to UDP server failed");
--- a/satrs-example/src/lib.rs
+++ b/satrs-example/src/lib.rs
@@ -1,4 +1,4 @@
-use satrs::spacepackets::time::{cds::CdsTime, TimeWriter};
+use satrs::spacepackets::time::cds::CdsTime;

 pub mod config;
 pub mod ids;
--- a/satrs-example/src/main.rs
+++ b/satrs-example/src/main.rs
@@ -35,7 +35,7 @@ use satrs::{
    mode_tree::connect_mode_nodes,
    pus::{event_man::EventRequestWithToken, EcssTcCacher, HandlingStatus},
    request::{GenericMessage, MessageMetadata},
-    spacepackets::time::{cds::CdsTime, TimeWriter},
+    spacepackets::time::cds::CdsTime,
 };
 use satrs_example::{
    config::{
--- a/satrs-example/src/pus/action.rs
+++ b/satrs-example/src/pus/action.rs
@@ -276,6 +276,7 @@ mod tests {
    use satrs::pus::verification::test_util::TestVerificationReporter;
    use satrs::pus::{verification, EcssTcVecCacher};
    use satrs::request::MessageMetadata;
+    use satrs::spacepackets::ecss::CreatorConfig;
    use satrs::tmtc::PacketAsVec;
    use satrs::ComponentId;
    use satrs::{
@@ -453,7 +454,9 @@ mod tests {
        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(sp_header, sec_header, &app_data, true);
+        let pus8_packet =
+            PusTcCreator::new(sp_header, sec_header, &app_data, CreatorConfig::default());
+
        testbench.add_tc(&pus8_packet);
        let time_stamp: [u8; 7] = [0; 7];
        testbench.verify_next_tc_is_handled_properly(&time_stamp);
@@ -499,7 +502,7 @@ mod tests {
            SpHeader::new_from_apid(TEST_APID),
            sec_header,
            &app_data,
-            true,
+            CreatorConfig::default(),
        );
        testbench.add_tc(&pus8_packet);
        let time_stamp: [u8; 7] = [0; 7];
@@ -525,7 +528,7 @@ mod tests {
            SpHeader::new_from_apid(TEST_APID),
            sec_header,
            &app_data,
-            true,
+            CreatorConfig::default(),
        );
        let token = testbench.add_tc(&pus8_packet);
        let result = testbench.convert(token, &[], TEST_APID, TEST_UNIQUE_ID_0);
@@ -564,7 +567,7 @@ mod tests {
            SpHeader::new_from_apid(TEST_APID),
            sec_header,
            &app_data,
-            true,
+            CreatorConfig::default(),
        );
        let token = testbench.add_tc(&pus8_packet);
        let result = testbench.convert(token, &[], TEST_APID, TEST_UNIQUE_ID_0);
--- a/satrs-example/src/pus/hk.rs
+++ b/satrs-example/src/pus/hk.rs
@@ -302,10 +302,13 @@ impl TargetedPusService for HkServiceWrapper {

 #[cfg(test)]
 mod tests {
+    use arbitrary_int::traits::Integer;
+    use arbitrary_int::u14;
    use satrs::pus::test_util::{
        TEST_COMPONENT_ID_0, TEST_COMPONENT_ID_1, TEST_UNIQUE_ID_0, TEST_UNIQUE_ID_1,
    };
    use satrs::request::MessageMetadata;
+    use satrs::spacepackets::ecss::CreatorConfig;
    use satrs::{
        hk::HkRequestVariant,
        pus::test_util::TEST_APID,
@@ -324,11 +327,12 @@ mod tests {

    use super::{HkReply, HkReplyHandler, HkRequestConverter};

+    pub const ZERO_SEQ: u14 = u14::ZERO;
    #[test]
    fn hk_converter_one_shot_req() {
        let mut hk_bench =
            PusConverterTestbench::new(TEST_COMPONENT_ID_0.id(), HkRequestConverter::default());
-        let sp_header = SpHeader::new_for_unseg_tc(TEST_APID, 0, 0);
+        let sp_header = SpHeader::new_for_unseg_tc(TEST_APID, ZERO_SEQ, 0);
        let target_id = TEST_UNIQUE_ID_0;
        let unique_id = 5_u32;
        let mut app_data: [u8; 8] = [0; 8];
@@ -340,7 +344,7 @@ mod tests {
            3,
            Subservice::TcGenerateOneShotHk as u8,
            &app_data,
-            true,
+            CreatorConfig::default(),
        );
        let accepted_token = hk_bench.add_tc(&hk_req);
        let (_active_req, req) = hk_bench
@@ -358,7 +362,7 @@ mod tests {
    fn hk_converter_enable_periodic_generation() {
        let mut hk_bench =
            PusConverterTestbench::new(TEST_COMPONENT_ID_0.id(), HkRequestConverter::default());
-        let sp_header = SpHeader::new_for_unseg_tc(TEST_APID, 0, 0);
+        let sp_header = SpHeader::new_for_unseg_tc(TEST_APID, ZERO_SEQ, 0);
        let target_id = TEST_UNIQUE_ID_0;
        let unique_id = 5_u32;
        let mut app_data: [u8; 8] = [0; 8];
@@ -380,7 +384,7 @@ mod tests {
            3,
            Subservice::TcEnableHkGeneration as u8,
            &app_data,
-            true,
+            CreatorConfig::default(),
        );
        generic_check(&tc0);
        let tc1 = PusTcCreator::new_simple(
@@ -388,7 +392,7 @@ mod tests {
            3,
            Subservice::TcEnableDiagGeneration as u8,
            &app_data,
-            true,
+            CreatorConfig::default(),
        );
        generic_check(&tc1);
    }
@@ -397,7 +401,7 @@ mod tests {
    fn hk_conversion_disable_periodic_generation() {
        let mut hk_bench =
            PusConverterTestbench::new(TEST_COMPONENT_ID_0.id(), HkRequestConverter::default());
-        let sp_header = SpHeader::new_for_unseg_tc(TEST_APID, 0, 0);
+        let sp_header = SpHeader::new_for_unseg_tc(TEST_APID, ZERO_SEQ, 0);
        let target_id = TEST_UNIQUE_ID_0;
        let unique_id = 5_u32;
        let mut app_data: [u8; 8] = [0; 8];
@@ -419,7 +423,7 @@ mod tests {
            3,
            Subservice::TcDisableHkGeneration as u8,
            &app_data,
-            true,
+            CreatorConfig::default(),
        );
        generic_check(&tc0);
        let tc1 = PusTcCreator::new_simple(
@@ -427,7 +431,7 @@ mod tests {
            3,
            Subservice::TcDisableDiagGeneration as u8,
            &app_data,
-            true,
+            CreatorConfig::default(),
        );
        generic_check(&tc1);
    }
@@ -436,7 +440,7 @@ mod tests {
    fn hk_conversion_modify_interval() {
        let mut hk_bench =
            PusConverterTestbench::new(TEST_COMPONENT_ID_0.id(), HkRequestConverter::default());
-        let sp_header = SpHeader::new_for_unseg_tc(TEST_APID, 0, 0);
+        let sp_header = SpHeader::new_for_unseg_tc(TEST_APID, ZERO_SEQ, 0);
        let target_id = TEST_UNIQUE_ID_0;
        let unique_id = 5_u32;
        let mut app_data: [u8; 12] = [0; 12];
@@ -462,7 +466,7 @@ mod tests {
            3,
            Subservice::TcModifyHkCollectionInterval as u8,
            &app_data,
-            true,
+            CreatorConfig::default(),
        );
        generic_check(&tc0);
        let tc1 = PusTcCreator::new_simple(
@@ -470,7 +474,7 @@ mod tests {
            3,
            Subservice::TcModifyDiagCollectionInterval as u8,
            &app_data,
-            true,
+            CreatorConfig::default(),
        );
        generic_check(&tc1);
    }
--- a/satrs-example/src/pus/mod.rs
+++ b/satrs-example/src/pus/mod.rs
@@ -531,9 +531,11 @@ pub fn generic_pus_request_timeout_handler(
 pub(crate) mod tests {
    use std::time::Duration;

+    use arbitrary_int::u11;
    use satrs::pus::test_util::TEST_COMPONENT_ID_0;
    use satrs::pus::{MpscTmAsVecSender, PusTmVariant};
    use satrs::request::RequestId;
+    use satrs::spacepackets::ecss::CreatorConfig;
    use satrs::{
        pus::{
            verification::test_util::TestVerificationReporter, ActivePusRequestStd,
@@ -590,7 +592,7 @@ pub(crate) mod tests {

        pub fn add_tc(
            &mut self,
-            apid: u16,
+            apid: u11,
            apid_target: u32,
            time_stamp: &[u8],
        ) -> (verification::RequestId, ActivePusRequestStd) {
@@ -600,7 +602,7 @@ pub(crate) mod tests {
                sp_header,
                sec_header_dummy,
                &[],
-                true,
+                CreatorConfig::default(),
            ));
            let accepted = self
                .verif_reporter
@@ -719,7 +721,7 @@ pub(crate) mod tests {
            &mut self,
            token: VerificationToken<TcStateAccepted>,
            time_stamp: &[u8],
-            expected_apid: u16,
+            expected_apid: u11,
            expected_apid_target: u32,
        ) -> Result<(ActiveRequestInfo, Request), Converter::Error> {
            if self.current_packet.is_none() {
--- a/satrs-example/src/pus/mode.rs
+++ b/satrs-example/src/pus/mode.rs
@@ -1,5 +1,7 @@
+use arbitrary_int::u14;
 use derive_new::new;
 use satrs::mode_tree::{ModeNode, ModeParent};
+use satrs::spacepackets::ecss::CreatorConfig;
 use satrs_example::ids;
 use std::sync::mpsc;
 use std::time::Duration;
@@ -77,10 +79,16 @@ 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 sp_header = SpHeader::new_for_unseg_tm(req_id.packet_id().apid(), 0, 0);
+                let sp_header =
+                    SpHeader::new_for_unseg_tm(req_id.packet_id().apid(), u14::new(0), 0);
                let sec_header =
                    PusTmSecondaryHeader::new(200, Subservice::TmModeReply as u8, 0, 0, time_stamp);
-                let pus_tm = PusTmCreator::new(sp_header, sec_header, &source_data, true);
+                let pus_tm = PusTmCreator::new(
+                    sp_header,
+                    sec_header,
+                    &source_data,
+                    CreatorConfig::default(),
+                );
                tm_sender.send_tm(self.owner_id, PusTmVariant::Direct(pus_tm))?;
                verification_handler.completion_success(tm_sender, started_token, time_stamp)?;
            }
@@ -290,8 +298,10 @@ impl TargetedPusService for ModeServiceWrapper {

 #[cfg(test)]
 mod tests {
+    use arbitrary_int::u14;
    use satrs::pus::test_util::{TEST_APID, TEST_COMPONENT_ID_0, TEST_UNIQUE_ID_0};
    use satrs::request::MessageMetadata;
+    use satrs::spacepackets::ecss::CreatorConfig;
    use satrs::{
        mode::{ModeAndSubmode, ModeReply, ModeRequest},
        pus::mode::Subservice,
@@ -314,11 +324,11 @@ mod tests {
    fn mode_converter_read_mode_request() {
        let mut testbench =
            PusConverterTestbench::new(TEST_COMPONENT_ID_0.id(), ModeRequestConverter::default());
-        let sp_header = SpHeader::new_for_unseg_tc(TEST_APID, 0, 0);
+        let sp_header = SpHeader::new_for_unseg_tc(TEST_APID, u14::new(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(sp_header, sec_header, &app_data, true);
+        let tc = PusTcCreator::new(sp_header, sec_header, &app_data, CreatorConfig::default());
        let token = testbench.add_tc(&tc);
        let (_active_req, req) = testbench
            .convert(token, &[], TEST_APID, TEST_UNIQUE_ID_0)
@@ -330,7 +340,7 @@ mod tests {
    fn mode_converter_set_mode_request() {
        let mut testbench =
            PusConverterTestbench::new(TEST_COMPONENT_ID_0.id(), ModeRequestConverter::default());
-        let sp_header = SpHeader::new_for_unseg_tc(TEST_APID, 0, 0);
+        let sp_header = SpHeader::new_for_unseg_tc(TEST_APID, u14::new(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);
@@ -338,7 +348,7 @@ mod tests {
        mode_and_submode
            .write_to_be_bytes(&mut app_data[4..])
            .unwrap();
-        let tc = PusTcCreator::new(sp_header, sec_header, &app_data, true);
+        let tc = PusTcCreator::new(sp_header, sec_header, &app_data, CreatorConfig::default());
        let token = testbench.add_tc(&tc);
        let (_active_req, req) = testbench
            .convert(token, &[], TEST_APID, TEST_UNIQUE_ID_0)
@@ -356,11 +366,11 @@ mod tests {
    fn mode_converter_announce_mode() {
        let mut testbench =
            PusConverterTestbench::new(TEST_COMPONENT_ID_0.id(), ModeRequestConverter::default());
-        let sp_header = SpHeader::new_for_unseg_tc(TEST_APID, 0, 0);
+        let sp_header = SpHeader::new_for_unseg_tc(TEST_APID, u14::new(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(sp_header, sec_header, &app_data, true);
+        let tc = PusTcCreator::new(sp_header, sec_header, &app_data, CreatorConfig::default());
        let token = testbench.add_tc(&tc);
        let (_active_req, req) = testbench
            .convert(token, &[], TEST_APID, TEST_UNIQUE_ID_0)
@@ -372,12 +382,12 @@ mod tests {
    fn mode_converter_announce_mode_recursively() {
        let mut testbench =
            PusConverterTestbench::new(TEST_COMPONENT_ID_0.id(), ModeRequestConverter::default());
-        let sp_header = SpHeader::new_for_unseg_tc(TEST_APID, 0, 0);
+        let sp_header = SpHeader::new_for_unseg_tc(TEST_APID, u14::new(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(sp_header, sec_header, &app_data, true);
+        let tc = PusTcCreator::new(sp_header, sec_header, &app_data, CreatorConfig::default());
        let token = testbench.add_tc(&tc);
        let (_active_req, req) = testbench
            .convert(token, &[], TEST_APID, TEST_UNIQUE_ID_0)
--- a/satrs-example/src/tmtc/tm_sink.rs
+++ b/satrs-example/src/tmtc/tm_sink.rs
@@ -3,18 +3,19 @@ use std::{
    sync::mpsc::{self},
 };

+use arbitrary_int::{u11, u14};
 use log::info;
 use satrs::{
    pool::PoolProvider,
    spacepackets::{
        ecss::{tm::PusTmZeroCopyWriter, PusPacket},
-        seq_count::CcsdsSimpleSeqCountProvider,
+        seq_count::SequenceCounterCcsdsSimple,
        time::cds::MIN_CDS_FIELD_LEN,
        CcsdsPacket,
    },
 };
 use satrs::{
-    spacepackets::seq_count::SequenceCountProvider,
+    spacepackets::seq_count::SequenceCounter,
    tmtc::{PacketAsVec, PacketInPool, SharedPacketPool},
 };

@@ -22,14 +23,16 @@ use crate::interface::tcp::SyncTcpTmSource;

 #[derive(Default)]
 pub struct CcsdsSeqCounterMap {
-    apid_seq_counter_map: HashMap<u16, CcsdsSimpleSeqCountProvider>,
+    apid_seq_counter_map: HashMap<u11, SequenceCounterCcsdsSimple>,
 }
 impl CcsdsSeqCounterMap {
-    pub fn get_and_increment(&mut self, apid: u16) -> u16 {
+    pub fn get_and_increment(&mut self, apid: u11) -> u14 {
+        u14::new(
            self.apid_seq_counter_map
                .entry(apid)
                .or_default()
-            .get_and_increment()
+                .get_and_increment(),
+        )
    }
 }

@@ -114,7 +117,7 @@ impl TmSinkStatic {
            let mut tm_copy = Vec::new();
            pool_guard
                .modify(&pus_tm_in_pool.store_addr, |buf| {
-                    let zero_copy_writer = PusTmZeroCopyWriter::new(buf, MIN_CDS_FIELD_LEN)
+                    let zero_copy_writer = PusTmZeroCopyWriter::new(buf, MIN_CDS_FIELD_LEN, true)
                        .expect("Creating TM zero copy writer failed");
                    self.common.apply_packet_processing(zero_copy_writer);
                    tm_copy = buf.to_vec()
@@ -154,7 +157,8 @@ impl TmSinkDynamic {
        if let Ok(mut tm) = self.tm_funnel_rx.recv() {
            // Read the TM, set sequence counter and message counter, and finally update
            // the CRC.
-            let zero_copy_writer = PusTmZeroCopyWriter::new(&mut tm.packet, MIN_CDS_FIELD_LEN)
+            let zero_copy_writer =
+                PusTmZeroCopyWriter::new(&mut tm.packet, MIN_CDS_FIELD_LEN, true)
                    .expect("Creating TM zero copy writer failed");
            self.common.apply_packet_processing(zero_copy_writer);
            self.common.sync_tm_tcp_source.add_tm(&tm.packet);
--- a/satrs-shared/Cargo.toml
+++ b/satrs-shared/Cargo.toml
@@ -11,7 +11,7 @@ license = "Apache-2.0"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

 [dependencies]
-spacepackets = { version = ">=0.14, <=0.15", default-features = false }
+spacepackets = { git = "https://egit.irs.uni-stuttgart.de/rust/spacepackets.git", version = ">=0.14, <=0.16", default-features = false }

 [dependencies.serde]
 version = "1"
--- a/satrs/Cargo.toml
+++ b/satrs/Cargo.toml
@@ -14,8 +14,9 @@ categories = ["aerospace", "aerospace::space-protocols", "no-std", "hardware-sup

 [dependencies]
 satrs-shared = { version = "0.2", path = "../satrs-shared" }
-spacepackets = { version = ">=0.14, <=0.15", default-features = false }
+spacepackets = { git = "https://egit.irs.uni-stuttgart.de/rust/spacepackets.git", version = "0.16", default-features = false }

+arbitrary-int = "2"
 delegate = ">0.7, <=0.13"
 paste = "1"
 derive-new = ">=0.6, <=0.7"
--- a/satrs/src/encoding/ccsds.rs
+++ b/satrs/src/encoding/ccsds.rs
@@ -63,7 +63,7 @@ pub fn parse_buffer_for_ccsds_space_packets<SendError>(
        let sp_header = SpHeader::from_be_bytes(&buf[current_idx..]).unwrap().0;
        match packet_validator.validate(&sp_header, &buf[current_idx..]) {
            SpValidity::Valid => {
-                let packet_size = sp_header.total_len();
+                let packet_size = sp_header.packet_len();
                if (current_idx + packet_size) <= buf_len {
                    packet_sender
                        .send_packet(sender_id, &buf[current_idx..current_idx + packet_size])?;
@@ -76,7 +76,7 @@ pub fn parse_buffer_for_ccsds_space_packets<SendError>(
                continue;
            }
            SpValidity::Skip => {
-                current_idx += sp_header.total_len();
+                current_idx += sp_header.packet_len();
            }
            // We might have lost sync. Try to find the start of a new space packet header.
            SpValidity::Invalid => {
@@ -89,9 +89,10 @@ pub fn parse_buffer_for_ccsds_space_packets<SendError>(

 #[cfg(test)]
 mod tests {
+    use arbitrary_int::{u11, u14};
    use spacepackets::{
-        CcsdsPacket, PacketId, PacketSequenceCtrl, PacketType, SequenceFlags, SpHeader,
-        ecss::tc::PusTcCreator,
+        CcsdsPacket, PacketId, PacketSequenceControl, PacketType, SequenceFlags, SpHeader,
+        ecss::{CreatorConfig, tc::PusTcCreator},
    };

    use crate::{ComponentId, encoding::tests::TcCacher};
@@ -99,8 +100,8 @@ mod tests {
    use super::{SpValidity, SpacePacketValidator, parse_buffer_for_ccsds_space_packets};

    const PARSER_ID: ComponentId = 0x05;
-    const TEST_APID_0: u16 = 0x02;
-    const TEST_APID_1: u16 = 0x10;
+    const TEST_APID_0: u11 = u11::new(0x02);
+    const TEST_APID_1: u11 = u11::new(0x10);
    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);

@@ -131,7 +132,7 @@ mod tests {
    #[test]
    fn test_basic() {
        let sph = SpHeader::new_from_apid(TEST_APID_0);
-        let ping_tc = PusTcCreator::new_simple(sph, 17, 1, &[], true);
+        let ping_tc = PusTcCreator::new_simple(sph, 17, 1, &[], CreatorConfig::default());
        let mut buffer: [u8; 32] = [0; 32];
        let packet_len = ping_tc
            .write_to_bytes(&mut buffer)
@@ -156,8 +157,8 @@ mod tests {
    #[test]
    fn test_multi_packet() {
        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 ping_tc = PusTcCreator::new_simple(sph, 17, 1, &[], CreatorConfig::default());
+        let action_tc = PusTcCreator::new_simple(sph, 8, 0, &[], CreatorConfig::default());
        let mut buffer: [u8; 32] = [0; 32];
        let packet_len_ping = ping_tc
            .write_to_bytes(&mut buffer)
@@ -191,9 +192,9 @@ mod tests {
    #[test]
    fn test_multi_apid() {
        let sph = SpHeader::new_from_apid(TEST_APID_0);
-        let ping_tc = PusTcCreator::new_simple(sph, 17, 1, &[], true);
+        let ping_tc = PusTcCreator::new_simple(sph, 17, 1, &[], CreatorConfig::default());
        let sph = SpHeader::new_from_apid(TEST_APID_1);
-        let action_tc = PusTcCreator::new_simple(sph, 8, 0, &[], true);
+        let action_tc = PusTcCreator::new_simple(sph, 8, 0, &[], CreatorConfig::default());
        let mut buffer: [u8; 32] = [0; 32];
        let packet_len_ping = ping_tc
            .write_to_bytes(&mut buffer)
@@ -221,10 +222,20 @@ mod tests {

    #[test]
    fn test_split_packet_multi() {
-        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 ping_tc = PusTcCreator::new_simple(
+            SpHeader::new_from_apid(TEST_APID_0),
+            17,
+            1,
+            &[],
+            CreatorConfig::default(),
+        );
+        let action_tc = PusTcCreator::new_simple(
+            SpHeader::new_from_apid(TEST_APID_1),
+            8,
+            0,
+            &[],
+            CreatorConfig::default(),
+        );
        let mut buffer: [u8; 32] = [0; 32];
        let packet_len_ping = ping_tc
            .write_to_bytes(&mut buffer)
@@ -255,8 +266,13 @@ mod tests {

    #[test]
    fn test_one_split_packet() {
-        let ping_tc =
-            PusTcCreator::new_simple(SpHeader::new_from_apid(TEST_APID_0), 17, 1, &[], true);
+        let ping_tc = PusTcCreator::new_simple(
+            SpHeader::new_from_apid(TEST_APID_0),
+            17,
+            1,
+            &[],
+            CreatorConfig::default(),
+        );
        let mut buffer: [u8; 32] = [0; 32];
        let packet_len_ping = ping_tc
            .write_to_bytes(&mut buffer)
@@ -281,7 +297,7 @@ mod tests {
    fn test_smallest_packet() {
        let ccsds_header_only = SpHeader::new(
            PacketId::new(PacketType::Tc, true, TEST_APID_0),
-            PacketSequenceCtrl::new(SequenceFlags::Unsegmented, 0),
+            PacketSequenceControl::new(SequenceFlags::Unsegmented, u14::new(0)),
            0,
        );
        let mut buf: [u8; 7] = [0; 7];
--- a/satrs/src/hal/std/tcp_spacepackets_server.rs
+++ b/satrs/src/hal/std/tcp_spacepackets_server.rs
@@ -183,10 +183,11 @@ mod tests {
    };

    use alloc::sync::Arc;
+    use arbitrary_int::u11;
    use hashbrown::HashSet;
    use spacepackets::{
        CcsdsPacket, PacketId, SpHeader,
-        ecss::{WritablePusPacket, tc::PusTcCreator},
+        ecss::{CreatorConfig, WritablePusPacket, tc::PusTcCreator},
    };

    use crate::{
@@ -203,9 +204,9 @@ mod tests {
    use super::TcpSpacepacketsServer;

    const TCP_SERVER_ID: ComponentId = 0x05;
-    const TEST_APID_0: u16 = 0x02;
+    const TEST_APID_0: u11 = u11::new(0x02);
    const TEST_PACKET_ID_0: PacketId = PacketId::new_for_tc(true, TEST_APID_0);
-    const TEST_APID_1: u16 = 0x10;
+    const TEST_APID_1: u11 = u11::new(0x10);
    const TEST_PACKET_ID_1: PacketId = PacketId::new_for_tc(true, TEST_APID_1);

    #[derive(Default)]
@@ -283,8 +284,13 @@ mod tests {
                .check_no_connections_left();
            set_if_done.store(true, Ordering::Relaxed);
        });
-        let ping_tc =
-            PusTcCreator::new_simple(SpHeader::new_from_apid(TEST_APID_0), 17, 1, &[], true);
+        let ping_tc = PusTcCreator::new_simple(
+            SpHeader::new_from_apid(TEST_APID_0),
+            17,
+            1,
+            &[],
+            CreatorConfig::default(),
+        );
        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
@@ -314,13 +320,23 @@ mod tests {

        // Add telemetry
        let mut total_tm_len = 0;
-        let verif_tm =
-            PusTcCreator::new_simple(SpHeader::new_from_apid(TEST_APID_0), 1, 1, &[], true);
+        let verif_tm = PusTcCreator::new_simple(
+            SpHeader::new_from_apid(TEST_APID_0),
+            1,
+            1,
+            &[],
+            CreatorConfig::default(),
+        );
        let tm_0 = verif_tm.to_vec().expect("writing packet failed");
        total_tm_len += tm_0.len();
        tm_source.add_tm(&tm_0);
-        let verif_tm =
-            PusTcCreator::new_simple(SpHeader::new_from_apid(TEST_APID_1), 1, 3, &[], true);
+        let verif_tm = PusTcCreator::new_simple(
+            SpHeader::new_from_apid(TEST_APID_1),
+            1,
+            3,
+            &[],
+            CreatorConfig::default(),
+        );
        let tm_1 = verif_tm.to_vec().expect("writing packet failed");
        total_tm_len += tm_1.len();
        tm_source.add_tm(&tm_1);
@@ -366,14 +382,24 @@ mod tests {
            .expect("setting reas timeout failed");

        // Send telecommands
-        let ping_tc =
-            PusTcCreator::new_simple(SpHeader::new_from_apid(TEST_APID_0), 17, 1, &[], true);
+        let ping_tc = PusTcCreator::new_simple(
+            SpHeader::new_from_apid(TEST_APID_0),
+            17,
+            1,
+            &[],
+            CreatorConfig::default(),
+        );
        let tc_0 = ping_tc.to_vec().expect("ping tc creation failed");
        stream
            .write_all(&tc_0)
            .expect("writing to TCP server failed");
-        let action_tc =
-            PusTcCreator::new_simple(SpHeader::new_from_apid(TEST_APID_1), 8, 0, &[], true);
+        let action_tc = PusTcCreator::new_simple(
+            SpHeader::new_from_apid(TEST_APID_1),
+            8,
+            0,
+            &[],
+            CreatorConfig::default(),
+        );
        let tc_1 = action_tc.to_vec().expect("action tc creation failed");
        stream
            .write_all(&tc_1)
--- a/satrs/src/hal/std/udp_server.rs
+++ b/satrs/src/hal/std/udp_server.rs
@@ -127,8 +127,10 @@ mod tests {
    use crate::hal::std::udp_server::{ReceiveResult, UdpTcServer};
    use crate::queue::GenericSendError;
    use crate::tmtc::PacketSenderRaw;
+    use arbitrary_int::u11;
    use core::cell::RefCell;
    use spacepackets::SpHeader;
+    use spacepackets::ecss::CreatorConfig;
    use spacepackets::ecss::tc::PusTcCreator;
    use std::collections::VecDeque;
    use std::net::{IpAddr, Ipv4Addr, SocketAddr, UdpSocket};
@@ -165,8 +167,8 @@ mod tests {
        let mut udp_tc_server = UdpTcServer::new(UDP_SERVER_ID, dest_addr, 2048, ping_receiver)
            .expect("Creating UDP TMTC server failed");
        is_send(&udp_tc_server);
-        let sph = SpHeader::new_from_apid(0x02);
-        let pus_tc = PusTcCreator::new_simple(sph, 17, 1, &[], true);
+        let sph = SpHeader::new_from_apid(u11::new(0x02));
+        let pus_tc = PusTcCreator::new_simple(sph, 17, 1, &[], CreatorConfig::default());
        let len = pus_tc
            .write_to_bytes(&mut buf)
            .expect("Error writing PUS TC packet");
--- a/satrs/src/pus/event.rs
+++ b/satrs/src/pus/event.rs
@@ -1,9 +1,9 @@
 use crate::pus::source_buffer_large_enough;
+use arbitrary_int::u11;
 use spacepackets::ByteConversionError;
-use spacepackets::ecss::EcssEnumeration;
-use spacepackets::ecss::tm::PusTmCreator;
-use spacepackets::ecss::tm::PusTmSecondaryHeader;
-use spacepackets::{MAX_APID, SpHeader};
+use spacepackets::SpHeader;
+use spacepackets::ecss::tm::{PusTmCreator, PusTmSecondaryHeader};
+use spacepackets::ecss::{CreatorConfig, EcssEnumeration};

 #[cfg(feature = "alloc")]
 pub use alloc_mod::*;
@@ -11,16 +11,13 @@ pub use alloc_mod::*;
 pub use spacepackets::ecss::event::*;

 pub struct EventReportCreator {
-    apid: u16,
+    apid: u11,
    pub dest_id: u16,
 }

 impl EventReportCreator {
-    pub fn new(apid: u16, dest_id: u16) -> Option<Self> {
-        if apid > MAX_APID {
-            return None;
-        }
-        Some(Self { dest_id, apid })
+    pub fn new(apid: u11, dest_id: u16) -> Self {
+        Self { dest_id, apid }
    }

    pub fn event_info<'time, 'src_data>(
@@ -124,7 +121,7 @@ impl EventReportCreator {
            SpHeader::new_from_apid(self.apid),
            sec_header,
            &src_data_buf[0..current_idx],
-            true,
+            CreatorConfig::default(),
        ))
    }
 }
@@ -162,11 +159,11 @@ mod alloc_mod {
    impl EventReporter<DummyEventHook> {
        pub fn new(
            id: ComponentId,
-            default_apid: u16,
+            default_apid: u11,
            default_dest_id: u16,
            max_event_id_and_aux_data_size: usize,
        ) -> Option<Self> {
-            let reporter = EventReportCreator::new(default_apid, default_dest_id)?;
+            let reporter = EventReportCreator::new(default_apid, default_dest_id);
            Some(Self {
                id,
                source_data_buf: RefCell::new(vec![0; max_event_id_and_aux_data_size]),
@@ -178,12 +175,12 @@ mod alloc_mod {
    impl<EventTmHookInstance: EventTmHook> EventReporter<EventTmHookInstance> {
        pub fn new_with_hook(
            id: ComponentId,
-            default_apid: u16,
+            default_apid: u11,
            default_dest_id: u16,
            max_event_id_and_aux_data_size: usize,
            tm_hook: EventTmHookInstance,
        ) -> Option<Self> {
-            let reporter = EventReportCreator::new(default_apid, default_dest_id)?;
+            let reporter = EventReportCreator::new(default_apid, default_dest_id);
            Some(Self {
                id,
                source_data_buf: RefCell::new(vec![0; max_event_id_and_aux_data_size]),
@@ -276,7 +273,7 @@ mod tests {
    use std::collections::VecDeque;
    use std::vec::Vec;

-    const EXAMPLE_APID: u16 = 0xee;
+    const EXAMPLE_APID: u11 = u11::new(0xee);
    const EXAMPLE_GROUP_ID: u16 = 2;
    const EXAMPLE_EVENT_ID_0: u16 = 1;
    #[allow(dead_code)]
--- a/satrs/src/pus/event_man.rs
+++ b/satrs/src/pus/event_man.rs
@@ -311,6 +311,7 @@ pub mod alloc_mod {
 mod tests {
    use alloc::string::{String, ToString};
    use alloc::vec;
+    use arbitrary_int::u11;
    use spacepackets::ecss::PusPacket;
    use spacepackets::ecss::event::Subservice;
    use spacepackets::ecss::tm::PusTmReader;
@@ -323,7 +324,7 @@ mod tests {
    const INFO_EVENT: EventU32TypedSev<SeverityInfo> = EventU32TypedSev::<SeverityInfo>::new(1, 0);
    const LOW_SEV_EVENT: EventU32 = EventU32::new(Severity::Low, 1, 5);
    const EMPTY_STAMP: [u8; 7] = [0; 7];
-    const TEST_APID: u16 = 0x02;
+    const TEST_APID: u11 = u11::new(0x02);
    const TEST_ID: UniqueApidTargetId = UniqueApidTargetId::new(TEST_APID, 0x05);

    fn create_basic_man_1() -> DefaultPusEventU32TmCreator {
--- a/satrs/src/pus/event_srv.rs
+++ b/satrs/src/pus/event_srv.rs
@@ -144,7 +144,10 @@ impl<

 #[cfg(test)]
 mod tests {
+    use arbitrary_int::traits::Integer as _;
+    use arbitrary_int::u14;
    use delegate::delegate;
+    use spacepackets::ecss::CreatorConfig;
    use spacepackets::ecss::event::Subservice;
    use spacepackets::time::{TimeWriter, cds};
    use spacepackets::util::UnsignedEnum;
@@ -242,13 +245,13 @@ mod tests {
        expected_event_req: EventRequest,
        event_req_receiver: mpsc::Receiver<EventRequestWithToken>,
    ) {
-        let sp_header = SpHeader::new_for_unseg_tc(TEST_APID, 0, 0);
+        let sp_header = SpHeader::new_for_unseg_tc(TEST_APID, u14::ZERO, 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(sp_header, sec_header, &app_data, true);
+        let ping_tc = PusTcCreator::new(sp_header, sec_header, &app_data, CreatorConfig::default());
        let token = test_harness.start_verification(&ping_tc);
        test_harness.send_tc(&token, &ping_tc);
        let request_id = token.request_id();
@@ -307,9 +310,10 @@ mod tests {
    fn test_sending_custom_subservice() {
        let (event_request_tx, _) = mpsc::channel();
        let mut test_harness = Pus5HandlerWithStoreTester::new(event_request_tx);
-        let sp_header = SpHeader::new_for_unseg_tc(TEST_APID, 0, 0);
+        let sp_header = SpHeader::new_for_unseg_tc(TEST_APID, u14::ZERO, 0);
        let sec_header = PusTcSecondaryHeader::new_simple(5, 200);
-        let ping_tc = PusTcCreator::new_no_app_data(sp_header, sec_header, true);
+        let ping_tc =
+            PusTcCreator::new_no_app_data(sp_header, sec_header, CreatorConfig::default());
        let token = test_harness.start_verification(&ping_tc);
        test_harness.send_tc(&token, &ping_tc);
        let result = test_harness.handle_one_tc();
@@ -326,10 +330,11 @@ mod tests {
    fn test_sending_invalid_app_data() {
        let (event_request_tx, _) = mpsc::channel();
        let mut test_harness = Pus5HandlerWithStoreTester::new(event_request_tx);
-        let sp_header = SpHeader::new_for_unseg_tc(TEST_APID, 0, 0);
+        let sp_header = SpHeader::new_for_unseg_tc(TEST_APID, u14::ZERO, 0);
        let sec_header =
            PusTcSecondaryHeader::new_simple(5, Subservice::TcEnableEventGeneration as u8);
-        let ping_tc = PusTcCreator::new(sp_header, sec_header, &[0, 1, 2], true);
+        let ping_tc =
+            PusTcCreator::new(sp_header, sec_header, &[0, 1, 2], CreatorConfig::default());
        let token = test_harness.start_verification(&ping_tc);
        test_harness.send_tc(&token, &ping_tc);
        let result = test_harness.handle_one_tc();
--- a/satrs/src/pus/mod.rs
+++ b/satrs/src/pus/mod.rs
@@ -1258,6 +1258,7 @@ pub(crate) fn source_buffer_large_enough(

 #[cfg(any(feature = "test_util", test))]
 pub mod test_util {
+    use arbitrary_int::u11;
    use spacepackets::ecss::{tc::PusTcCreator, tm::PusTmReader};

    use crate::request::UniqueApidTargetId;
@@ -1267,7 +1268,7 @@ pub mod test_util {
        verification::{self, TcStateAccepted, VerificationToken},
    };

-    pub const TEST_APID: u16 = 0x101;
+    pub const TEST_APID: u11 = u11::new(0x101);
    pub const TEST_UNIQUE_ID_0: u32 = 0x05;
    pub const TEST_UNIQUE_ID_1: u32 = 0x06;

@@ -1302,6 +1303,7 @@ pub mod tests {

    use alloc::collections::VecDeque;
    use alloc::vec::Vec;
+    use arbitrary_int::{u11, u14};
    use satrs_shared::res_code::ResultU16;
    use spacepackets::CcsdsPacket;
    use spacepackets::ecss::tc::{PusTcCreator, PusTcReader};
@@ -1324,8 +1326,8 @@ pub mod tests {
    #[derive(Debug, Eq, PartialEq, Clone)]
    pub(crate) struct CommonTmInfo {
        pub subservice: u8,
-        pub apid: u16,
-        pub seq_count: u16,
+        pub apid: u11,
+        pub seq_count: u14,
        pub msg_counter: u16,
        pub dest_id: u16,
        pub timestamp: Vec<u8>,
@@ -1334,8 +1336,8 @@ pub mod tests {
    impl CommonTmInfo {
        pub fn new(
            subservice: u8,
-            apid: u16,
-            seq_count: u16,
+            apid: u11,
+            seq_count: u14,
            msg_counter: u16,
            dest_id: u16,
            timestamp: &[u8],
@@ -1351,11 +1353,11 @@ pub mod tests {
        }
        pub fn new_zero_seq_count(
            subservice: u8,
-            apid: u16,
+            apid: u11,
            dest_id: u16,
            timestamp: &[u8],
        ) -> Self {
-            Self::new(subservice, apid, 0, 0, dest_id, timestamp)
+            Self::new(subservice, apid, u14::new(0), 0, dest_id, timestamp)
        }

        pub fn new_from_tm(tm: &PusTmCreator) -> Self {
--- a/satrs/src/pus/scheduler.rs
+++ b/satrs/src/pus/scheduler.rs
@@ -2,6 +2,7 @@
 //!
 //! The core data structure of this module is the [PusScheduler]. This structure can be used
 //! to perform the scheduling of telecommands like specified in the ECSS standard.
+use arbitrary_int::{u11, u14};
 use core::fmt::{Debug, Display, Formatter};
 use core::time::Duration;
 #[cfg(feature = "serde")]
@@ -26,20 +27,23 @@ pub use alloc_mod::*;
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 pub struct RequestId {
    pub(crate) source_id: u16,
-    pub(crate) apid: u16,
-    pub(crate) seq_count: u16,
+    pub(crate) apid: u11,
+    pub(crate) seq_count: u14,
 }

 impl RequestId {
-    pub fn source_id(&self) -> u16 {
+    #[inline]
+    pub const fn source_id(&self) -> u16 {
        self.source_id
    }

-    pub fn apid(&self) -> u16 {
+    #[inline]
+    pub const fn apid(&self) -> u11 {
        self.apid
    }

-    pub fn seq_count(&self) -> u16 {
+    #[inline]
+    pub const fn seq_count(&self) -> u14 {
        self.seq_count
    }

@@ -53,8 +57,11 @@ impl RequestId {
        }
    }

-    pub fn as_u64(&self) -> u64 {
-        ((self.source_id as u64) << 32) | ((self.apid as u64) << 16) | self.seq_count as u64
+    #[inline]
+    pub const fn as_u64(&self) -> u64 {
+        ((self.source_id as u64) << 32)
+            | ((self.apid.value() as u64) << 16)
+            | self.seq_count.value() as u64
    }
 }

@@ -855,42 +862,45 @@ mod tests {
        PoolAddr, PoolError, PoolProvider, StaticMemoryPool, StaticPoolAddr, StaticPoolConfig,
    };
    use alloc::collections::btree_map::Range;
-    use spacepackets::ecss::WritablePusPacket;
+    use arbitrary_int::traits::Integer as _;
    use spacepackets::ecss::tc::{PusTcCreator, PusTcReader, PusTcSecondaryHeader};
+    use spacepackets::ecss::{CreatorConfig, WritablePusPacket};
    use spacepackets::time::{TimeWriter, UnixTime, cds};
-    use spacepackets::{PacketId, PacketSequenceCtrl, PacketType, SequenceFlags, SpHeader};
+    use spacepackets::{PacketId, PacketSequenceControl, PacketType, SequenceFlags, SpHeader};
    use std::time::Duration;
    use std::vec::Vec;
    #[allow(unused_imports)]
    use std::{println, vec};

+    const ZERO_SEQ: u14 = u14::ZERO;
+
    fn pus_tc_base(timestamp: UnixTime, buf: &mut [u8]) -> (SpHeader, usize) {
        let cds_time =
            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, &[])
+        let len_packet = base_ping_tc_simple_ctor(u14::new(0), &[])
            .write_to_bytes(&mut buf[len_time_stamp..])
            .unwrap();
        (
-            SpHeader::new_for_unseg_tc(0x02, 0x34, len_packet as u16),
+            SpHeader::new_for_unseg_tc(u11::new(0x02), u14::new(0x34), len_packet as u16),
            len_packet + len_time_stamp,
        )
    }

    fn scheduled_tc(timestamp: UnixTime, buf: &mut [u8]) -> PusTcCreator<'_> {
        let (sph, len_app_data) = pus_tc_base(timestamp, buf);
-        PusTcCreator::new_simple(sph, 11, 4, &buf[..len_app_data], true)
+        PusTcCreator::new_simple(sph, 11, 4, &buf[..len_app_data], CreatorConfig::default())
    }

    fn wrong_tc_service(timestamp: UnixTime, buf: &mut [u8]) -> PusTcCreator<'_> {
        let (sph, len_app_data) = pus_tc_base(timestamp, buf);
-        PusTcCreator::new_simple(sph, 12, 4, &buf[..len_app_data], true)
+        PusTcCreator::new_simple(sph, 12, 4, &buf[..len_app_data], CreatorConfig::default())
    }

    fn wrong_tc_subservice(timestamp: UnixTime, buf: &mut [u8]) -> PusTcCreator<'_> {
        let (sph, len_app_data) = pus_tc_base(timestamp, buf);
-        PusTcCreator::new_simple(sph, 11, 5, &buf[..len_app_data], true)
+        PusTcCreator::new_simple(sph, 11, 5, &buf[..len_app_data], CreatorConfig::default())
    }

    fn double_wrapped_time_tagged_tc(timestamp: UnixTime, buf: &mut [u8]) -> PusTcCreator<'_> {
@@ -898,30 +908,37 @@ 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 sph = SpHeader::new_for_unseg_tc(0x02, 0x34, 0);
+        let sph = SpHeader::new_for_unseg_tc(u11::new(0x02), u14::new(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(sph, 11, 4, &[], true);
+        let inner_time_tagged_tc =
+            PusTcCreator::new_simple(sph, 11, 4, &[], CreatorConfig::default());
        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(sph, 11, 4, &buf[..len_time_stamp + packet_len], true)
+        PusTcCreator::new_simple(
+            sph,
+            11,
+            4,
+            &buf[..len_time_stamp + packet_len],
+            CreatorConfig::default(),
+        )
    }

    fn invalid_time_tagged_cmd() -> PusTcCreator<'static> {
-        let sph = SpHeader::new_for_unseg_tc(0x02, 0x34, 1);
-        PusTcCreator::new_simple(sph, 11, 4, &[], true)
+        let sph = SpHeader::new_for_unseg_tc(u11::new(0x02), u14::new(0x34), 1);
+        PusTcCreator::new_simple(sph, 11, 4, &[], CreatorConfig::default())
    }

-    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 base_ping_tc_simple_ctor(seq_count: u14, app_data: &'static [u8]) -> PusTcCreator<'static> {
+        let sph = SpHeader::new_for_unseg_tc(u11::new(0x02), seq_count, 0);
+        PusTcCreator::new_simple(sph, 17, 1, app_data, CreatorConfig::default())
    }

    fn ping_tc_to_store(
        pool: &mut StaticMemoryPool,
        buf: &mut [u8],
-        seq_count: u16,
+        seq_count: u14,
        app_data: &'static [u8],
    ) -> TcInfo {
        let ping_tc = base_ping_tc_simple_ctor(seq_count, app_data);
@@ -949,7 +966,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, &[]);
+        let tc_info_0 = ping_tc_to_store(&mut pool, &mut buf, u14::new(0), &[]);

        scheduler
            .insert_unwrapped_and_stored_tc(
@@ -959,7 +976,7 @@ mod tests {
            .unwrap();

        let app_data = &[0, 1, 2];
-        let tc_info_1 = ping_tc_to_store(&mut pool, &mut buf, 1, app_data);
+        let tc_info_1 = ping_tc_to_store(&mut pool, &mut buf, u14::new(1), app_data);
        scheduler
            .insert_unwrapped_and_stored_tc(
                UnixTime::new_only_secs(200),
@@ -968,7 +985,7 @@ mod tests {
            .unwrap();

        let app_data = &[0, 1, 2];
-        let tc_info_2 = ping_tc_to_store(&mut pool, &mut buf, 2, app_data);
+        let tc_info_2 = ping_tc_to_store(&mut pool, &mut buf, u14::new(2), app_data);
        scheduler
            .insert_unwrapped_and_stored_tc(
                UnixTime::new_only_secs(300),
@@ -999,8 +1016,8 @@ mod tests {
                        packet_idx: 1,
                    }),
                    RequestId {
-                        seq_count: 1,
-                        apid: 0,
+                        seq_count: u14::new(1),
+                        apid: u11::new(0),
                        source_id: 0,
                    },
                ),
@@ -1016,8 +1033,8 @@ mod tests {
                        packet_idx: 2,
                    }),
                    RequestId {
-                        seq_count: 2,
-                        apid: 1,
+                        seq_count: u14::new(2),
+                        apid: u11::new(1),
                        source_id: 5,
                    },
                ),
@@ -1035,8 +1052,8 @@ mod tests {
                    .into(),
                    RequestId {
                        source_id: 10,
-                        seq_count: 20,
-                        apid: 23,
+                        seq_count: u14::new(20),
+                        apid: u11::new(23),
                    },
                ),
            )
@@ -1079,14 +1096,15 @@ mod tests {
        let src_id_to_set = 12;
        let apid_to_set = 0x22;
        let seq_count = 105;
-        let sp_header = SpHeader::new_for_unseg_tc(apid_to_set, 105, 0);
+        let sp_header = SpHeader::new_for_unseg_tc(u11::new(apid_to_set), u14::new(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(sp_header, sec_header, true);
+        let ping_tc =
+            PusTcCreator::new_no_app_data(sp_header, sec_header, CreatorConfig::default());
        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);
-        assert_eq!(req_id.seq_count(), seq_count);
+        assert_eq!(req_id.apid().value(), apid_to_set);
+        assert_eq!(req_id.seq_count().value(), seq_count);
        assert_eq!(
            req_id.as_u64(),
            ((src_id_to_set as u64) << 32) | (apid_to_set as u64) << 16 | seq_count as u64
@@ -1101,13 +1119,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, &[]);
+        let tc_info_0 = ping_tc_to_store(&mut pool, &mut buf, u14::new(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, &[]);
+        let tc_info_1 = ping_tc_to_store(&mut pool, &mut buf, u14::new(1), &[]);
        scheduler
            .insert_unwrapped_and_stored_tc(UnixTime::new_only_secs(200), tc_info_1)
            .expect("insertion failed");
@@ -1169,13 +1187,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, &[]);
+        let tc_info_0 = ping_tc_to_store(&mut pool, &mut buf, u14::new(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, &[]);
+        let tc_info_1 = ping_tc_to_store(&mut pool, &mut buf, u14::new(1), &[]);
        scheduler
            .insert_unwrapped_and_stored_tc(UnixTime::new_only_secs(100), tc_info_1)
            .expect("insertion failed");
@@ -1231,13 +1249,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, &[]);
+        let tc_info_0 = ping_tc_to_store(&mut pool, &mut buf, u14::new(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, &[]);
+        let tc_info_1 = ping_tc_to_store(&mut pool, &mut buf, u14::new(1), &[]);
        scheduler
            .insert_unwrapped_and_stored_tc(UnixTime::new_only_secs(200), tc_info_1)
            .expect("insertion failed");
@@ -1298,7 +1316,7 @@ mod tests {
            false,
        ));
        let mut buf: [u8; 32] = [0; 32];
-        let tc_info_0 = ping_tc_to_store(&mut pool, &mut buf, 0, &[]);
+        let tc_info_0 = ping_tc_to_store(&mut pool, &mut buf, u14::new(0), &[]);

        let info = scheduler
            .insert_unwrapped_tc(
@@ -1313,7 +1331,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, base_ping_tc_simple_ctor(0, &[]));
+        assert_eq!(check_tc, base_ping_tc_simple_ctor(u14::new(0), &[]));

        assert_eq!(scheduler.num_scheduled_telecommands(), 1);

@@ -1335,8 +1353,8 @@ 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.total_len());
-        assert_eq!(check_tc, base_ping_tc_simple_ctor(0, &[]));
+        assert_eq!(read_len, check_tc.packet_len());
+        assert_eq!(check_tc, base_ping_tc_simple_ctor(u14::new(0), &[]));
    }

    #[test]
@@ -1362,8 +1380,8 @@ 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.total_len());
-        assert_eq!(check_tc, base_ping_tc_simple_ctor(0, &[]));
+        assert_eq!(read_len, check_tc.packet_len());
+        assert_eq!(check_tc, base_ping_tc_simple_ctor(u14::new(0), &[]));

        assert_eq!(scheduler.num_scheduled_telecommands(), 1);

@@ -1387,8 +1405,8 @@ 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.total_len());
-        assert_eq!(check_tc, base_ping_tc_simple_ctor(0, &[]));
+        assert_eq!(read_len, check_tc.packet_len());
+        assert_eq!(check_tc, base_ping_tc_simple_ctor(u14::new(0), &[]));
    }

    #[test]
@@ -1531,7 +1549,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, &[]);
+        let tc_info_0 = ping_tc_to_store(&mut pool, &mut buf, u14::new(0), &[]);
        scheduler
            .insert_unwrapped_and_stored_tc(UnixTime::new_only_secs(100), tc_info_0)
            .expect("insertion failed");
@@ -1568,7 +1586,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, &[]);
+        let tc_info_0 = ping_tc_to_store(&mut pool, &mut buf, u14::new(0), &[]);
        scheduler
            .insert_unwrapped_and_stored_tc(UnixTime::new_only_secs(100), tc_info_0)
            .expect("insertion failed");
@@ -1594,7 +1612,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, &[]);
+        let tc_info_0 = ping_tc_to_store(&mut pool, &mut buf, u14::new(0), &[]);
        scheduler
            .insert_unwrapped_and_stored_tc(UnixTime::new_only_secs(100), tc_info_0)
            .expect("inserting tc failed");
@@ -1615,7 +1633,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, &[]);
+        let tc_info_0 = ping_tc_to_store(&mut pool, &mut buf, u14::new(0), &[]);
        scheduler
            .insert_unwrapped_and_stored_tc(UnixTime::new_only_secs(100), tc_info_0)
            .expect("inserting tc failed");
@@ -1636,15 +1654,15 @@ 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, &[]);
+        let tc_info_0 = ping_tc_to_store(&mut pool, &mut buf, u14::new(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, &[]);
+        let tc_info_1 = ping_tc_to_store(&mut pool, &mut buf, u14::new(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, &[]);
+        let tc_info_2 = ping_tc_to_store(&mut pool, &mut buf, u14::new(2), &[]);
        scheduler
            .insert_unwrapped_and_stored_tc(UnixTime::new_only_secs(100), tc_info_2)
            .expect("inserting tc failed");
@@ -1703,7 +1721,7 @@ mod tests {
    fn insert_command_with_release_time(
        pool: &mut StaticMemoryPool,
        scheduler: &mut PusScheduler,
-        seq_count: u16,
+        seq_count: u14,
        release_secs: u64,
    ) -> TcInfo {
        let mut buf: [u8; 32] = [0; 32];
@@ -1722,8 +1740,10 @@ mod tests {
            false,
        ));
        let mut scheduler = PusScheduler::new(UnixTime::new_only_secs(0), Duration::from_secs(5));
-        let tc_info_0 = insert_command_with_release_time(&mut pool, &mut scheduler, 0, 50);
-        let tc_info_1 = insert_command_with_release_time(&mut pool, &mut scheduler, 0, 100);
+        let tc_info_0 =
+            insert_command_with_release_time(&mut pool, &mut scheduler, u14::new(0), 50);
+        let tc_info_1 =
+            insert_command_with_release_time(&mut pool, &mut scheduler, u14::new(0), 100);
        assert_eq!(scheduler.num_scheduled_telecommands(), 2);
        let check_range = |range: Range<UnixTime, Vec<TcInfo>>| {
            let mut tcs_in_range = 0;
@@ -1754,9 +1774,11 @@ mod tests {
            false,
        ));
        let mut scheduler = PusScheduler::new(UnixTime::new_only_secs(0), Duration::from_secs(5));
-        let _ = insert_command_with_release_time(&mut pool, &mut scheduler, 0, 50);
-        let tc_info_1 = insert_command_with_release_time(&mut pool, &mut scheduler, 0, 100);
-        let tc_info_2 = insert_command_with_release_time(&mut pool, &mut scheduler, 0, 150);
+        let _ = insert_command_with_release_time(&mut pool, &mut scheduler, u14::new(0), 50);
+        let tc_info_1 =
+            insert_command_with_release_time(&mut pool, &mut scheduler, u14::new(0), 100);
+        let tc_info_2 =
+            insert_command_with_release_time(&mut pool, &mut scheduler, u14::new(0), 150);
        let start_stamp = cds::CdsTime::from_unix_time_with_u16_days(
            &UnixTime::new_only_secs(100),
            cds::SubmillisPrecision::Absent,
@@ -1789,9 +1811,11 @@ mod tests {
            false,
        ));
        let mut scheduler = PusScheduler::new(UnixTime::new_only_secs(0), Duration::from_secs(5));
-        let tc_info_0 = insert_command_with_release_time(&mut pool, &mut scheduler, 0, 50);
-        let tc_info_1 = insert_command_with_release_time(&mut pool, &mut scheduler, 0, 100);
-        let _ = insert_command_with_release_time(&mut pool, &mut scheduler, 0, 150);
+        let tc_info_0 =
+            insert_command_with_release_time(&mut pool, &mut scheduler, u14::new(0), 50);
+        let tc_info_1 =
+            insert_command_with_release_time(&mut pool, &mut scheduler, u14::new(0), 100);
+        let _ = insert_command_with_release_time(&mut pool, &mut scheduler, u14::new(0), 150);
        assert_eq!(scheduler.num_scheduled_telecommands(), 3);

        let end_stamp = cds::CdsTime::from_unix_time_with_u16_days(
@@ -1824,10 +1848,10 @@ mod tests {
            false,
        ));
        let mut scheduler = PusScheduler::new(UnixTime::new_only_secs(0), Duration::from_secs(5));
-        let _ = insert_command_with_release_time(&mut pool, &mut scheduler, 0, 50);
-        let tc_info_1 = insert_command_with_release_time(&mut pool, &mut scheduler, 0, 100);
-        let tc_info_2 = insert_command_with_release_time(&mut pool, &mut scheduler, 0, 150);
-        let _ = insert_command_with_release_time(&mut pool, &mut scheduler, 0, 200);
+        let _ = insert_command_with_release_time(&mut pool, &mut scheduler, ZERO_SEQ, 50);
+        let tc_info_1 = insert_command_with_release_time(&mut pool, &mut scheduler, ZERO_SEQ, 100);
+        let tc_info_2 = insert_command_with_release_time(&mut pool, &mut scheduler, ZERO_SEQ, 150);
+        let _ = insert_command_with_release_time(&mut pool, &mut scheduler, ZERO_SEQ, 200);
        assert_eq!(scheduler.num_scheduled_telecommands(), 4);

        let start_stamp = cds::CdsTime::from_unix_time_with_u16_days(
@@ -1865,8 +1889,8 @@ mod tests {
            false,
        ));
        let mut scheduler = PusScheduler::new(UnixTime::new_only_secs(0), Duration::from_secs(5));
-        insert_command_with_release_time(&mut pool, &mut scheduler, 0, 50);
-        insert_command_with_release_time(&mut pool, &mut scheduler, 0, 100);
+        insert_command_with_release_time(&mut pool, &mut scheduler, ZERO_SEQ, 50);
+        insert_command_with_release_time(&mut pool, &mut scheduler, ZERO_SEQ, 100);
        assert_eq!(scheduler.num_scheduled_telecommands(), 2);
        let del_res = scheduler.delete_all(&mut pool);
        assert!(del_res.is_ok());
@@ -1875,8 +1899,8 @@ mod tests {
        // Contrary to reset, this does not disable the scheduler.
        assert!(scheduler.is_enabled());

-        insert_command_with_release_time(&mut pool, &mut scheduler, 0, 50);
-        insert_command_with_release_time(&mut pool, &mut scheduler, 0, 100);
+        insert_command_with_release_time(&mut pool, &mut scheduler, ZERO_SEQ, 50);
+        insert_command_with_release_time(&mut pool, &mut scheduler, ZERO_SEQ, 100);
        assert_eq!(scheduler.num_scheduled_telecommands(), 2);
        let del_res = scheduler
            .delete_by_time_filter(TimeWindow::<cds::CdsTime>::new_select_all(), &mut pool);
@@ -1894,9 +1918,11 @@ mod tests {
            false,
        ));
        let mut scheduler = PusScheduler::new(UnixTime::new_only_secs(0), Duration::from_secs(5));
-        insert_command_with_release_time(&mut pool, &mut scheduler, 0, 50);
-        let cmd_0_to_delete = insert_command_with_release_time(&mut pool, &mut scheduler, 0, 100);
-        let cmd_1_to_delete = insert_command_with_release_time(&mut pool, &mut scheduler, 0, 150);
+        insert_command_with_release_time(&mut pool, &mut scheduler, ZERO_SEQ, 50);
+        let cmd_0_to_delete =
+            insert_command_with_release_time(&mut pool, &mut scheduler, ZERO_SEQ, 100);
+        let cmd_1_to_delete =
+            insert_command_with_release_time(&mut pool, &mut scheduler, ZERO_SEQ, 150);
        assert_eq!(scheduler.num_scheduled_telecommands(), 3);
        let start_stamp = cds::CdsTime::from_unix_time_with_u16_days(
            &UnixTime::new_only_secs(100),
@@ -1919,9 +1945,11 @@ mod tests {
            false,
        ));
        let mut scheduler = PusScheduler::new(UnixTime::new_only_secs(0), Duration::from_secs(5));
-        let cmd_0_to_delete = insert_command_with_release_time(&mut pool, &mut scheduler, 0, 50);
-        let cmd_1_to_delete = insert_command_with_release_time(&mut pool, &mut scheduler, 0, 100);
-        insert_command_with_release_time(&mut pool, &mut scheduler, 0, 150);
+        let cmd_0_to_delete =
+            insert_command_with_release_time(&mut pool, &mut scheduler, ZERO_SEQ, 50);
+        let cmd_1_to_delete =
+            insert_command_with_release_time(&mut pool, &mut scheduler, ZERO_SEQ, 100);
+        insert_command_with_release_time(&mut pool, &mut scheduler, ZERO_SEQ, 150);
        assert_eq!(scheduler.num_scheduled_telecommands(), 3);

        let end_stamp = cds::CdsTime::from_unix_time_with_u16_days(
@@ -1945,11 +1973,14 @@ mod tests {
            false,
        ));
        let mut scheduler = PusScheduler::new(UnixTime::new_only_secs(0), Duration::from_secs(5));
-        let cmd_out_of_range_0 = insert_command_with_release_time(&mut pool, &mut scheduler, 0, 50);
-        let cmd_0_to_delete = insert_command_with_release_time(&mut pool, &mut scheduler, 0, 100);
-        let cmd_1_to_delete = insert_command_with_release_time(&mut pool, &mut scheduler, 0, 150);
+        let cmd_out_of_range_0 =
+            insert_command_with_release_time(&mut pool, &mut scheduler, ZERO_SEQ, 50);
+        let cmd_0_to_delete =
+            insert_command_with_release_time(&mut pool, &mut scheduler, ZERO_SEQ, 100);
+        let cmd_1_to_delete =
+            insert_command_with_release_time(&mut pool, &mut scheduler, ZERO_SEQ, 150);
        let cmd_out_of_range_1 =
-            insert_command_with_release_time(&mut pool, &mut scheduler, 0, 200);
+            insert_command_with_release_time(&mut pool, &mut scheduler, ZERO_SEQ, 200);
        assert_eq!(scheduler.num_scheduled_telecommands(), 4);

        let start_stamp = cds::CdsTime::from_unix_time_with_u16_days(
@@ -1982,13 +2013,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, &[]);
+        let tc_info_0 = ping_tc_to_store(&mut pool, &mut buf, u14::new(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, &[]);
+        let tc_info_1 = ping_tc_to_store(&mut pool, &mut buf, u14::new(1), &[]);
        scheduler
            .insert_unwrapped_and_stored_tc(UnixTime::new_only_secs(200), tc_info_1)
            .expect("insertion failed");
@@ -2017,12 +2048,12 @@ mod tests {
    fn test_generic_insert_app_data_test() {
        let time_writer = cds::CdsTime::new_with_u16_days(1, 1);
        let sph = SpHeader::new(
-            PacketId::new(PacketType::Tc, true, 0x002),
-            PacketSequenceCtrl::new(SequenceFlags::Unsegmented, 5),
+            PacketId::new(PacketType::Tc, true, u11::new(0x002)),
+            PacketSequenceControl::new(SequenceFlags::Unsegmented, u14::new(5)),
            0,
        );
        let sec_header = PusTcSecondaryHeader::new_simple(17, 1);
-        let ping_tc = PusTcCreator::new_no_app_data(sph, sec_header, true);
+        let ping_tc = PusTcCreator::new_no_app_data(sph, sec_header, CreatorConfig::default());
        let mut buf: [u8; 64] = [0; 64];
        let result = generate_insert_telecommand_app_data(&mut buf, &time_writer, &ping_tc);
        assert!(result.is_ok());
@@ -2039,12 +2070,12 @@ mod tests {
    fn test_generic_insert_app_data_test_byte_conv_error() {
        let time_writer = cds::CdsTime::new_with_u16_days(1, 1);
        let sph = SpHeader::new(
-            PacketId::new(PacketType::Tc, true, 0x002),
-            PacketSequenceCtrl::new(SequenceFlags::Unsegmented, 5),
+            PacketId::new(PacketType::Tc, true, u11::new(0x002)),
+            PacketSequenceControl::new(SequenceFlags::Unsegmented, u14::new(5)),
            0,
        );
        let sec_header = PusTcSecondaryHeader::new_simple(17, 1);
-        let ping_tc = PusTcCreator::new_no_app_data(sph, sec_header, true);
+        let ping_tc = PusTcCreator::new_no_app_data(sph, sec_header, CreatorConfig::default());
        let mut buf: [u8; 16] = [0; 16];
        let result = generate_insert_telecommand_app_data(&mut buf, &time_writer, &ping_tc);
        assert!(result.is_err());
@@ -2068,12 +2099,12 @@ mod tests {
    fn test_generic_insert_app_data_test_as_vec() {
        let time_writer = cds::CdsTime::new_with_u16_days(1, 1);
        let sph = SpHeader::new(
-            PacketId::new(PacketType::Tc, true, 0x002),
-            PacketSequenceCtrl::new(SequenceFlags::Unsegmented, 5),
+            PacketId::new(PacketType::Tc, true, u11::new(0x002)),
+            PacketSequenceControl::new(SequenceFlags::Unsegmented, u14::new(5)),
            0,
        );
        let sec_header = PusTcSecondaryHeader::new_simple(17, 1);
-        let ping_tc = PusTcCreator::new_no_app_data(sph, sec_header, true);
+        let ping_tc = PusTcCreator::new_no_app_data(sph, sec_header, CreatorConfig::default());
        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)
--- a/satrs/src/pus/scheduler_srv.rs
+++ b/satrs/src/pus/scheduler_srv.rs
@@ -260,11 +260,13 @@ mod tests {
    };
    use crate::tmtc::PacketSenderWithSharedPool;
    use alloc::collections::VecDeque;
+    use arbitrary_int::traits::Integer;
+    use arbitrary_int::u14;
    use delegate::delegate;
    use spacepackets::SpHeader;
-    use spacepackets::ecss::WritablePusPacket;
    use spacepackets::ecss::scheduling::Subservice;
    use spacepackets::ecss::tc::PusTcSecondaryHeader;
+    use spacepackets::ecss::{CreatorConfig, WritablePusPacket};
    use spacepackets::time::TimeWriter;
    use spacepackets::{
        ecss::{tc::PusTcCreator, tm::PusTmReader},
@@ -386,9 +388,10 @@ mod tests {
        test_harness: &mut Pus11HandlerWithStoreTester,
        subservice: Subservice,
    ) {
-        let reply_header = SpHeader::new_for_unseg_tm(TEST_APID, 0, 0);
+        let reply_header = SpHeader::new_for_unseg_tm(TEST_APID, u14::ZERO, 0);
        let tc_header = PusTcSecondaryHeader::new_simple(11, subservice as u8);
-        let enable_scheduling = PusTcCreator::new(reply_header, tc_header, &[0; 7], true);
+        let enable_scheduling =
+            PusTcCreator::new(reply_header, tc_header, &[0; 7], CreatorConfig::default());
        let token = test_harness.start_verification(&enable_scheduling);
        test_harness.send_tc(&token, &enable_scheduling);

@@ -433,9 +436,9 @@ mod tests {
    #[test]
    fn test_insert_activity_tc() {
        let mut test_harness = Pus11HandlerWithStoreTester::new();
-        let mut reply_header = SpHeader::new_for_unseg_tc(TEST_APID, 0, 0);
+        let mut reply_header = SpHeader::new_for_unseg_tc(TEST_APID, u14::ZERO, 0);
        let mut sec_header = PusTcSecondaryHeader::new_simple(17, 1);
-        let ping_tc = PusTcCreator::new(reply_header, sec_header, &[], true);
+        let ping_tc = PusTcCreator::new(reply_header, sec_header, &[], CreatorConfig::default());
        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];
@@ -443,13 +446,13 @@ 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::new_for_unseg_tc(TEST_APID, 1, 0);
+        reply_header = SpHeader::new_for_unseg_tc(TEST_APID, u14::new(1), 0);
        sec_header = PusTcSecondaryHeader::new_simple(11, Subservice::TcInsertActivity as u8);
        let enable_scheduling = PusTcCreator::new(
            reply_header,
            sec_header,
            &sched_app_data[..written_len],
-            true,
+            CreatorConfig::default(),
        );
        let token = test_harness.start_verification(&enable_scheduling);
        test_harness.send_tc(&token, &enable_scheduling);
--- a/satrs/src/pus/test.rs
+++ b/satrs/src/pus/test.rs
@@ -2,9 +2,10 @@ use crate::pus::{
    DirectPusPacketHandlerResult, PartialPusHandlingError, PusPacketHandlingError, PusTmVariant,
 };
 use crate::tmtc::{PacketAsVec, PacketSenderWithSharedPool};
+use arbitrary_int::u14;
 use spacepackets::SpHeader;
-use spacepackets::ecss::PusPacket;
 use spacepackets::ecss::tm::{PusTmCreator, PusTmSecondaryHeader};
+use spacepackets::ecss::{CreatorConfig, PusPacket};
 use std::sync::mpsc;

 use super::verification::{VerificationReporter, VerificationReportingProvider};
@@ -75,10 +76,14 @@ impl<
            // Sequence count will be handled centrally in TM funnel.
            // 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 reply_header = SpHeader::new_for_unseg_tm(
+                self.service_helper.verif_reporter().apid(),
+                u14::new(0),
+                0,
+            );
            let tc_header = PusTmSecondaryHeader::new_simple(17, 2, time_stamp);
-            let ping_reply = PusTmCreator::new(reply_header, tc_header, &[], true);
+            let ping_reply =
+                PusTmCreator::new(reply_header, tc_header, &[], CreatorConfig::default());
            if let Err(e) = self
                .service_helper
                .common
@@ -148,11 +153,12 @@ mod tests {
        PartialPusHandlingError, PusPacketHandlingError,
    };
    use crate::tmtc::PacketSenderWithSharedPool;
+    use arbitrary_int::u14;
    use delegate::delegate;
    use spacepackets::SpHeader;
-    use spacepackets::ecss::PusPacket;
    use spacepackets::ecss::tc::{PusTcCreator, PusTcSecondaryHeader};
    use spacepackets::ecss::tm::PusTmReader;
+    use spacepackets::ecss::{CreatorConfig, PusPacket};
    use spacepackets::time::{TimeWriter, cds};

    use super::PusService17TestHandler;
@@ -283,9 +289,10 @@ mod tests {

    fn ping_test(test_harness: &mut (impl PusTestHarness + SimplePusPacketHandler)) {
        // Create a ping TC, verify acceptance.
-        let sp_header = SpHeader::new_for_unseg_tc(TEST_APID, 0, 0);
+        let sp_header = SpHeader::new_for_unseg_tc(TEST_APID, u14::new(0), 0);
        let sec_header = PusTcSecondaryHeader::new_simple(17, 1);
-        let ping_tc = PusTcCreator::new_no_app_data(sp_header, sec_header, true);
+        let ping_tc =
+            PusTcCreator::new_no_app_data(sp_header, sec_header, CreatorConfig::default());
        let token = test_harness.start_verification(&ping_tc);
        test_harness.send_tc(&token, &ping_tc);
        let request_id = token.request_id();
@@ -338,9 +345,10 @@ mod tests {
    #[test]
    fn test_sending_unsupported_service() {
        let mut test_harness = Pus17HandlerWithStoreTester::new(0);
-        let sp_header = SpHeader::new_for_unseg_tc(TEST_APID, 0, 0);
+        let sp_header = SpHeader::new_for_unseg_tc(TEST_APID, u14::new(0), 0);
        let sec_header = PusTcSecondaryHeader::new_simple(3, 1);
-        let ping_tc = PusTcCreator::new_no_app_data(sp_header, sec_header, true);
+        let ping_tc =
+            PusTcCreator::new_no_app_data(sp_header, sec_header, CreatorConfig::default());
        let token = test_harness.start_verification(&ping_tc);
        test_harness.send_tc(&token, &ping_tc);
        let result = test_harness.handle_one_tc();
@@ -359,9 +367,10 @@ mod tests {
    #[test]
    fn test_sending_custom_subservice() {
        let mut test_harness = Pus17HandlerWithStoreTester::new(0);
-        let sp_header = SpHeader::new_for_unseg_tc(TEST_APID, 0, 0);
+        let sp_header = SpHeader::new_for_unseg_tc(TEST_APID, u14::new(0), 0);
        let sec_header = PusTcSecondaryHeader::new_simple(17, 200);
-        let ping_tc = PusTcCreator::new_no_app_data(sp_header, sec_header, true);
+        let ping_tc =
+            PusTcCreator::new_no_app_data(sp_header, sec_header, CreatorConfig::default());
        let token = test_harness.start_verification(&ping_tc);
        test_harness.send_tc(&token, &ping_tc);
        let result = test_harness.handle_one_tc();
--- a/satrs/src/pus/verification.rs
+++ b/satrs/src/pus/verification.rs
@@ -82,6 +82,8 @@
 //! context involving multiple threads
 use crate::params::{Params, WritableToBeBytes};
 use crate::pus::{EcssTmSender, EcssTmtcError, source_buffer_large_enough};
+use arbitrary_int::traits::Integer as _;
+use arbitrary_int::{u3, u11, u14};
 use core::fmt::{Debug, Display, Formatter};
 use core::hash::{Hash, Hasher};
 use core::marker::PhantomData;
@@ -90,14 +92,13 @@ use core::mem::size_of;
 use delegate::delegate;
 #[cfg(feature = "serde")]
 use serde::{Deserialize, Serialize};
-use spacepackets::ecss::EcssEnumeration;
 use spacepackets::ecss::tc::IsPusTelecommand;
 use spacepackets::ecss::tm::{PusTmCreator, PusTmSecondaryHeader};
-use spacepackets::{ByteConversionError, CcsdsPacket, PacketId, PacketSequenceCtrl};
+use spacepackets::ecss::{CreatorConfig, EcssEnumeration};
+use spacepackets::{ByteConversionError, CcsdsPacket, PacketId, PacketSequenceControl};
 use spacepackets::{MAX_APID, SpHeader};

 pub use spacepackets::ecss::verification::*;
-pub use spacepackets::seq_count::SeqCountProviderSimple;

 #[cfg(feature = "alloc")]
 pub use alloc_mod::*;
@@ -113,9 +114,9 @@ use crate::request::Apid;
 #[derive(Debug, Eq, Copy, Clone)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 pub struct RequestId {
-    version_number: u8,
+    version_number: u3,
    packet_id: PacketId,
-    psc: PacketSequenceCtrl,
+    psc: PacketSequenceControl,
 }

 impl Display for RequestId {
@@ -157,7 +158,7 @@ impl RequestId {
    }

    pub fn raw(&self) -> u32 {
-        ((self.version_number as u32) << 29)
+        ((self.version_number.as_u32()) << 29)
            | ((self.packet_id.raw() as u32) << 16)
            | self.psc.raw() as u32
    }
@@ -166,7 +167,7 @@ impl RequestId {
        self.packet_id
    }

-    pub fn packet_seq_ctrl(&self) -> PacketSequenceCtrl {
+    pub fn packet_sequence_control(&self) -> PacketSequenceControl {
        self.psc
    }

@@ -181,9 +182,9 @@ impl RequestId {
        }
        let raw = u32::from_be_bytes(buf[0..Self::SIZE_AS_BYTES].try_into().unwrap());
        Some(Self {
-            version_number: ((raw >> 29) & 0b111) as u8,
+            version_number: u3::new(((raw >> 29) & 0b111) as u8),
            packet_id: PacketId::from(((raw >> 16) & 0xffff) as u16),
-            psc: PacketSequenceCtrl::from((raw & 0xffff) as u16),
+            psc: PacketSequenceControl::from((raw & 0xffff) as u16),
        })
    }
 }
@@ -191,9 +192,9 @@ impl RequestId {
 impl From<u32> for RequestId {
    fn from(value: u32) -> Self {
        Self {
-            version_number: ((value >> 29) & 0b111) as u8,
+            version_number: u3::new(((value >> 29) & 0b111) as u8),
            packet_id: PacketId::from(((value >> 16) & 0xffff) as u16),
-            psc: PacketSequenceCtrl::from((value & 0xffff) as u16),
+            psc: PacketSequenceControl::from((value & 0xffff) as u16),
        }
    }
 }
@@ -480,26 +481,19 @@ pub trait VerificationReportingProvider {
 #[derive(Debug, Clone)]
 pub struct VerificationReportCreator {
    pub dest_id: u16,
-    apid: u16,
+    apid: u11,
 }

 impl VerificationReportCreator {
-    pub fn new(apid: u16) -> Option<Self> {
-        if apid > MAX_APID {
-            return None;
-        }
-        Some(Self { apid, dest_id: 0 })
+    pub fn new(apid: u11) -> Self {
+        Self { apid, dest_id: 0 }
    }

-    pub fn set_apid(&mut self, apid: u16) -> bool {
-        if apid > MAX_APID {
-            return false;
-        }
+    pub fn set_apid(&mut self, apid: u11) {
        self.apid = apid;
-        true
    }

-    pub fn apid(&self) -> u16 {
+    pub fn apid(&self) -> u11 {
        self.apid
    }

@@ -522,7 +516,7 @@ impl VerificationReportCreator {
        src_data_buf: &'src_data mut [u8],
        subservice: u8,
        request_id: &RequestId,
-        seq_count: u16,
+        seq_count: u14,
        msg_count: u16,
        time_stamp: &'time [u8],
    ) -> Result<PusTmCreator<'time, 'src_data>, ByteConversionError> {
@@ -545,7 +539,7 @@ impl VerificationReportCreator {
        src_data_buf: &'src_data mut [u8],
        subservice: u8,
        request_id: &RequestId,
-        seq_count: u16,
+        seq_count: u14,
        msg_count: u16,
        step: Option<&(impl EcssEnumeration + ?Sized)>,
        params: &FailParams<'time, '_>,
@@ -567,7 +561,7 @@ impl VerificationReportCreator {
        &self,
        src_data_buf: &'src_data mut [u8],
        request_id: &RequestId,
-        seq_count: u16,
+        seq_count: u14,
        msg_count: u16,
        time_stamp: &'time [u8],
    ) -> Result<PusTmCreator<'time, 'src_data>, ByteConversionError> {
@@ -587,7 +581,7 @@ impl VerificationReportCreator {
        &self,
        src_data_buf: &'src_data mut [u8],
        request_id: &RequestId,
-        seq_count: u16,
+        seq_count: u14,
        msg_count: u16,
        params: FailParams<'time, '_>,
    ) -> Result<PusTmCreator<'time, 'src_data>, ByteConversionError> {
@@ -609,7 +603,7 @@ impl VerificationReportCreator {
        &self,
        src_data_buf: &'src_data mut [u8],
        request_id: &RequestId,
-        seq_count: u16,
+        seq_count: u14,
        msg_count: u16,
        time_stamp: &'time [u8],
    ) -> Result<PusTmCreator<'time, 'src_data>, ByteConversionError> {
@@ -632,7 +626,7 @@ impl VerificationReportCreator {
        &self,
        src_data_buf: &'src_data mut [u8],
        request_id: &RequestId,
-        seq_count: u16,
+        seq_count: u14,
        msg_count: u16,
        params: FailParams<'time, '_>,
    ) -> Result<PusTmCreator<'time, 'src_data>, ByteConversionError> {
@@ -654,7 +648,7 @@ impl VerificationReportCreator {
        &self,
        src_data_buf: &'src_data mut [u8],
        request_id: &RequestId,
-        seq_count: u16,
+        seq_count: u14,
        msg_count: u16,
        time_stamp: &'time [u8],
        step: impl EcssEnumeration,
@@ -678,7 +672,7 @@ impl VerificationReportCreator {
        &self,
        src_data_buf: &'src_data mut [u8],
        token: VerificationToken<TcStateStarted>,
-        seq_count: u16,
+        seq_count: u14,
        msg_count: u16,
        params: FailParamsWithStep<'time, '_>,
    ) -> Result<PusTmCreator<'time, 'src_data>, ByteConversionError> {
@@ -701,7 +695,7 @@ impl VerificationReportCreator {
        &self,
        src_data_buf: &'src_data mut [u8],
        request_id: &RequestId,
-        seq_counter: u16,
+        seq_counter: u14,
        msg_counter: u16,
        time_stamp: &'time [u8],
    ) -> Result<PusTmCreator<'time, 'src_data>, ByteConversionError> {
@@ -723,7 +717,7 @@ impl VerificationReportCreator {
        &self,
        src_data_buf: &'src_data mut [u8],
        request_id: &RequestId,
-        seq_count: u16,
+        seq_count: u14,
        msg_count: u16,
        params: FailParams<'time, '_>,
    ) -> Result<PusTmCreator<'time, 'src_data>, ByteConversionError> {
@@ -744,7 +738,7 @@ impl VerificationReportCreator {
        &self,
        src_data_buf: &'src_data mut [u8],
        subservice: u8,
-        seq_count: u16,
+        seq_count: u14,
        msg_counter: u16,
        req_id: &RequestId,
        time_stamp: &'time [u8],
@@ -780,7 +774,7 @@ impl VerificationReportCreator {
        &self,
        src_data_buf: &'src_data mut [u8],
        subservice: u8,
-        seq_count: u16,
+        seq_count: u14,
        msg_counter: u16,
        req_id: &RequestId,
        step: Option<&(impl EcssEnumeration + ?Sized)>,
@@ -832,13 +826,14 @@ impl VerificationReportCreator {
            sp_header,
            tm_sec_header,
            &src_data_buf[0..source_data_len],
-            true,
+            CreatorConfig::default(),
        )
    }
 }

 #[cfg(feature = "alloc")]
 pub mod alloc_mod {
+    use arbitrary_int::u11;
    use spacepackets::ecss::PusError;

    use super::*;
@@ -847,7 +842,7 @@ pub mod alloc_mod {

    #[derive(Clone)]
    pub struct VerificationReporterConfig {
-        apid: u16,
+        apid: u11,
        pub step_field_width: usize,
        pub fail_code_field_width: usize,
        pub max_fail_data_len: usize,
@@ -855,7 +850,7 @@ pub mod alloc_mod {

    impl VerificationReporterConfig {
        pub fn new(
-            apid: u16,
+            apid: u11,
            step_field_width: usize,
            fail_code_field_width: usize,
            max_fail_data_len: usize,
@@ -909,7 +904,7 @@ pub mod alloc_mod {

    impl VerificationReporter<DummyVerificationHook> {
        pub fn new(owner_id: ComponentId, cfg: &VerificationReporterConfig) -> Self {
-            let reporter = VerificationReportCreator::new(cfg.apid).unwrap();
+            let reporter = VerificationReportCreator::new(cfg.apid);
            Self {
                owner_id,
                source_data_buf: RefCell::new(alloc::vec![
@@ -933,7 +928,7 @@ pub mod alloc_mod {
            cfg: &VerificationReporterConfig,
            tm_hook: VerificationHookInstance,
        ) -> Self {
-            let reporter = VerificationReportCreator::new(cfg.apid).unwrap();
+            let reporter = VerificationReportCreator::new(cfg.apid);
            Self {
                owner_id,
                source_data_buf: RefCell::new(alloc::vec![
@@ -966,8 +961,8 @@ pub mod alloc_mod {

        delegate!(
            to self.reporter_creator {
-                pub fn set_apid(&mut self, apid: u16) -> bool;
-                pub fn apid(&self) -> u16;
+                pub fn set_apid(&mut self, apid: u11);
+                pub fn apid(&self) -> u11;
                pub fn dest_id(&self) -> u16;
                pub fn set_dest_id(&mut self, dest_id: u16);
            }
@@ -1012,7 +1007,7 @@ pub mod alloc_mod {
                .acceptance_success(
                    source_data_buf.as_mut_slice(),
                    &token.request_id(),
-                    0,
+                    u14::new(0),
                    0,
                    time_stamp,
                )
@@ -1032,7 +1027,13 @@ pub mod alloc_mod {
            let mut buf = self.source_data_buf.borrow_mut();
            let mut tm_creator = self
                .reporter_creator
-                .acceptance_failure(buf.as_mut_slice(), &token.request_id(), 0, 0, params)
+                .acceptance_failure(
+                    buf.as_mut_slice(),
+                    &token.request_id(),
+                    u14::new(0),
+                    0,
+                    params,
+                )
                .map_err(PusError::ByteConversion)?;
            self.tm_hook.modify_tm(&mut tm_creator);
            sender.send_tm(self.owner_id(), PusTmVariant::Direct(tm_creator))?;
@@ -1051,7 +1052,13 @@ pub mod alloc_mod {
            let mut buf = self.source_data_buf.borrow_mut();
            let mut tm_creator = self
                .reporter_creator
-                .start_success(buf.as_mut_slice(), &token.request_id(), 0, 0, time_stamp)
+                .start_success(
+                    buf.as_mut_slice(),
+                    &token.request_id(),
+                    u14::new(0),
+                    0,
+                    time_stamp,
+                )
                .map_err(PusError::ByteConversion)?;
            self.tm_hook.modify_tm(&mut tm_creator);
            sender.send_tm(self.owner_id(), PusTmVariant::Direct(tm_creator))?;
@@ -1071,7 +1078,13 @@ pub mod alloc_mod {
            let mut buf = self.source_data_buf.borrow_mut();
            let mut tm_creator = self
                .reporter_creator
-                .start_failure(buf.as_mut_slice(), &token.request_id(), 0, 0, params)
+                .start_failure(
+                    buf.as_mut_slice(),
+                    &token.request_id(),
+                    u14::new(0),
+                    0,
+                    params,
+                )
                .map_err(PusError::ByteConversion)?;
            self.tm_hook.modify_tm(&mut tm_creator);
            sender.send_tm(self.owner_id(), PusTmVariant::Direct(tm_creator))?;
@@ -1094,7 +1107,7 @@ pub mod alloc_mod {
                .step_success(
                    buf.as_mut_slice(),
                    &token.request_id(),
-                    0,
+                    u14::new(0),
                    0,
                    time_stamp,
                    step,
@@ -1118,7 +1131,7 @@ pub mod alloc_mod {
            let mut buf = self.source_data_buf.borrow_mut();
            let mut tm_creator = self
                .reporter_creator
-                .step_failure(buf.as_mut_slice(), token, 0, 0, params)
+                .step_failure(buf.as_mut_slice(), token, u14::new(0), 0, params)
                .map_err(PusError::ByteConversion)?;
            self.tm_hook.modify_tm(&mut tm_creator);
            sender.send_tm(self.owner_id(), PusTmVariant::Direct(tm_creator))?;
@@ -1139,7 +1152,13 @@ pub mod alloc_mod {
            let mut buf = self.source_data_buf.borrow_mut();
            let mut tm_creator = self
                .reporter_creator
-                .completion_success(buf.as_mut_slice(), &token.request_id(), 0, 0, time_stamp)
+                .completion_success(
+                    buf.as_mut_slice(),
+                    &token.request_id(),
+                    u14::new(0),
+                    0,
+                    time_stamp,
+                )
                .map_err(PusError::ByteConversion)?;
            self.tm_hook.modify_tm(&mut tm_creator);
            sender.send_tm(self.owner_id, PusTmVariant::Direct(tm_creator))?;
@@ -1159,7 +1178,13 @@ pub mod alloc_mod {
            let mut buf = self.source_data_buf.borrow_mut();
            let mut tm_creator = self
                .reporter_creator
-                .completion_failure(buf.as_mut_slice(), &token.request_id(), 0, 00, params)
+                .completion_failure(
+                    buf.as_mut_slice(),
+                    &token.request_id(),
+                    u14::new(0),
+                    0,
+                    params,
+                )
                .map_err(PusError::ByteConversion)?;
            self.tm_hook.modify_tm(&mut tm_creator);
            sender.send_tm(self.owner_id(), PusTmVariant::Direct(tm_creator))?;
@@ -1309,6 +1334,7 @@ pub fn handle_step_failure_with_generic_params(
 #[cfg(any(feature = "test_util", test))]
 pub mod test_util {
    use alloc::vec::Vec;
+    use arbitrary_int::u11;
    use core::cell::RefCell;
    use std::collections::VecDeque;

@@ -1370,7 +1396,7 @@ pub mod test_util {
        fn set_apid(&mut self, _apid: Apid) {}

        fn apid(&self) -> Apid {
-            0
+            u11::new(0)
        }

        fn acceptance_success(
@@ -1698,15 +1724,17 @@ pub mod tests {
    };
    use crate::pus::{ChannelWithId, PusTmVariant};
    use crate::request::MessageMetadata;
-    use crate::spacepackets::seq_count::{CcsdsSimpleSeqCountProvider, SequenceCountProvider};
+    use crate::spacepackets::seq_count::{SequenceCounter, SequenceCounterCcsdsSimple};
    use crate::tmtc::{PacketSenderWithSharedPool, SharedPacketPool};
    use alloc::format;
    use alloc::string::ToString;
+    use arbitrary_int::{u11, u14};
    use spacepackets::ecss::tc::{PusTcCreator, PusTcReader, PusTcSecondaryHeader};
    use spacepackets::ecss::{
-        EcssEnumU8, EcssEnumU16, EcssEnumU32, EcssEnumeration, PusError, PusPacket,
+        CreatorConfig, EcssEnumU8, EcssEnumU16, EcssEnumU32, EcssEnumeration, PusError, PusPacket,
        WritablePusPacket,
    };
+    use spacepackets::seq_count::SequenceCounterSimple;
    use spacepackets::util::UnsignedEnum;
    use spacepackets::{ByteConversionError, SpHeader};
    use std::cell::RefCell;
@@ -1716,8 +1744,8 @@ pub mod tests {
    use std::vec::Vec;

    use super::{
-        DummyVerificationHook, FailParamHelper, SeqCountProviderSimple, TcStateAccepted,
-        TcStateStarted, VerificationHook, VerificationReportingProvider, WasAtLeastAccepted,
+        DummyVerificationHook, FailParamHelper, TcStateAccepted, TcStateStarted, VerificationHook,
+        VerificationReportingProvider, WasAtLeastAccepted,
        handle_completion_failure_with_generic_params,
    };

@@ -1783,13 +1811,13 @@ pub mod tests {

    #[derive(Default)]
    pub struct SequenceCounterHook {
-        pub seq_counter: CcsdsSimpleSeqCountProvider,
-        pub msg_counter: SeqCountProviderSimple<u16>,
+        pub seq_counter: SequenceCounterCcsdsSimple,
+        pub msg_counter: SequenceCounterSimple<u16>,
    }

    impl VerificationHook for SequenceCounterHook {
        fn modify_tm(&self, tm: &mut spacepackets::ecss::tm::PusTmCreator) {
-            tm.set_seq_count(self.seq_counter.get_and_increment());
+            tm.set_seq_count(u14::new(self.seq_counter.get_and_increment()));
            tm.set_msg_counter(self.msg_counter.get_and_increment());
        }
    }
@@ -1912,7 +1940,14 @@ pub mod tests {
        fn check_acceptance_success(&self, timestamp: &[u8; 7]) {
            let cmp_info = TmInfo {
                requestor: MessageMetadata::new(self.request_id.into(), self.id),
-                common: CommonTmInfo::new(1, TEST_APID, 0, 0, self.reporter.dest_id(), timestamp),
+                common: CommonTmInfo::new(
+                    1,
+                    TEST_APID,
+                    u14::new(0),
+                    0,
+                    self.reporter.dest_id(),
+                    timestamp,
+                ),
                additional_data: None,
            };
            let mut service_queue = self.sender.service_queue.borrow_mut();
@@ -1921,7 +1956,7 @@ pub mod tests {
            assert_eq!(info, cmp_info);
        }

-        fn check_start_success(&mut self, seq_count: u16, msg_counter: u16, timestamp: &[u8]) {
+        fn check_start_success(&mut self, seq_count: u14, msg_counter: u16, timestamp: &[u8]) {
            let mut srv_queue = self.sender.service_queue.borrow_mut();
            let cmp_info = TmInfo {
                requestor: MessageMetadata::new(self.request_id.into(), self.id),
@@ -1939,7 +1974,7 @@ pub mod tests {
            assert_eq!(info, cmp_info);
        }

-        fn check_completion_success(&mut self, seq_count: u16, msg_counter: u16) {
+        fn check_completion_success(&mut self, seq_count: u14, msg_counter: u16) {
            let cmp_info = TmInfo {
                requestor: MessageMetadata::new(self.request_id.into(), self.id),
                common: CommonTmInfo::new(
@@ -1972,7 +2007,14 @@ pub mod tests {
        fn check_acceptance_failure(&mut self, timestamp: &[u8; 7]) {
            let cmp_info = TmInfo {
                requestor: MessageMetadata::new(self.request_id.into(), self.id),
-                common: CommonTmInfo::new(2, TEST_APID, 0, 0, self.reporter.dest_id(), timestamp),
+                common: CommonTmInfo::new(
+                    2,
+                    TEST_APID,
+                    u14::new(0),
+                    0,
+                    self.reporter.dest_id(),
+                    timestamp,
+                ),
                additional_data: Some([0, 2].to_vec()),
            };
            let service_queue = self.sender.service_queue.get_mut();
@@ -2060,9 +2102,9 @@ pub mod tests {
    }

    fn create_generic_ping() -> PusTcCreator<'static> {
-        let sph = SpHeader::new_for_unseg_tc(TEST_APID, 0x34, 0);
+        let sph = SpHeader::new_for_unseg_tc(TEST_APID, u14::new(0x34), 0);
        let tc_header = PusTcSecondaryHeader::new_simple(17, 1);
-        PusTcCreator::new(sph, tc_header, &[], true)
+        PusTcCreator::new(sph, tc_header, &[], CreatorConfig::default())
    }

    #[test]
@@ -2082,8 +2124,8 @@ pub mod tests {
    fn test_state() {
        let mut testbench = VerificationReporterTestbench::new(0, create_generic_ping(), 16);
        assert_eq!(testbench.reporter.apid(), TEST_APID);
-        testbench.reporter.set_apid(TEST_APID + 1);
-        assert_eq!(testbench.reporter.apid(), TEST_APID + 1);
+        testbench.reporter.set_apid(u11::new(TEST_APID.value() + 1));
+        assert_eq!(testbench.reporter.apid().value(), TEST_APID.value() + 1);
    }

    #[test]
@@ -2233,7 +2275,7 @@ pub mod tests {
            .expect("step 1 failed");
        assert_eq!(testbench.sender.service_queue.borrow().len(), 4);
        testbench.check_acceptance_success(&EMPTY_STAMP);
-        testbench.check_start_success(0, 0, &EMPTY_STAMP);
+        testbench.check_start_success(u14::new(0), 0, &EMPTY_STAMP);
        testbench.check_step_success(0, &EMPTY_STAMP);
        testbench.check_step_success(1, &EMPTY_STAMP);
    }
@@ -2267,7 +2309,7 @@ pub mod tests {
            .step_failure(started_token, fail_params)
            .expect("Step failure failed");
        testbench.check_acceptance_success(&EMPTY_STAMP);
-        testbench.check_start_success(0, 0, DUMMY_STAMP);
+        testbench.check_start_success(u14::new(0), 0, DUMMY_STAMP);
        testbench.check_step_success(0, &EMPTY_STAMP);
        testbench.check_step_failure(&fail_step, &fail_code, &fail_data_raw);
    }
@@ -2289,7 +2331,7 @@ pub mod tests {
            .completion_failure(started_token, fail_params)
            .expect("Completion failure");
        testbench.check_acceptance_success(&EMPTY_STAMP);
-        testbench.check_start_success(0, 0, DUMMY_STAMP);
+        testbench.check_start_success(u14::new(0), 0, DUMMY_STAMP);

        testbench.check_completion_failure(&fail_code, &[]);
    }
@@ -2309,8 +2351,8 @@ pub mod tests {
            .completion_success(started_token, &EMPTY_STAMP)
            .expect("Sending completion success failed");
        testbench.check_acceptance_success(&EMPTY_STAMP);
-        testbench.check_start_success(0, 0, DUMMY_STAMP);
-        testbench.check_completion_success(0, 0);
+        testbench.check_start_success(u14::new(0), 0, DUMMY_STAMP);
+        testbench.check_completion_success(u14::new(0), 0);
    }

    #[test]
@@ -2331,8 +2373,8 @@ pub mod tests {
            .completion_success(started_token, &EMPTY_STAMP)
            .expect("Sending completion success failed");
        testbench.check_acceptance_success(&EMPTY_STAMP);
-        testbench.check_start_success(1, 1, DUMMY_STAMP);
-        testbench.check_completion_success(2, 2);
+        testbench.check_start_success(u14::new(1), 1, DUMMY_STAMP);
+        testbench.check_completion_success(u14::new(2), 2);
    }

    #[test]
@@ -2391,7 +2433,7 @@ pub mod tests {
        );
        assert!(result.unwrap());
        testbench.check_acceptance_success(&EMPTY_STAMP);
-        testbench.check_start_success(0, 0, &EMPTY_STAMP);
+        testbench.check_start_success(u14::new(0), 0, &EMPTY_STAMP);
        testbench.check_step_failure(&step, &fail_code, fail_data.as_bytes());
    }

--- a/satrs/src/request.rs
+++ b/satrs/src/request.rs
@@ -1,3 +1,4 @@
+use arbitrary_int::{traits::Integer as _, u11};
 use core::{fmt, marker::PhantomData};
 #[cfg(feature = "serde")]
 use serde::{Deserialize, Serialize};
@@ -22,8 +23,8 @@ use crate::{
 /// for them. This can be useful for tasks like tracking their progress.
 pub type RequestId = u32;

-/// CCSDS APID type definition. Please note that the APID is a 14 bit value.
-pub type Apid = u16;
+/// CCSDS APID type definition. Please note that the APID is a 11 bit value.
+pub type Apid = u11;

 #[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
 pub struct UniqueApidTargetId {
@@ -40,7 +41,7 @@ impl UniqueApidTargetId {
    }

    pub fn raw(&self) -> ComponentId {
-        ((self.apid as u64) << 32) | (self.unique_id as u64)
+        ((self.apid.as_u64()) << 32) | (self.unique_id as u64)
    }

    pub fn id(&self) -> ComponentId {
@@ -68,7 +69,7 @@ impl UniqueApidTargetId {
 impl From<u64> for UniqueApidTargetId {
    fn from(raw: u64) -> Self {
        Self {
-            apid: (raw >> 32) as u16,
+            apid: u11::new((raw >> 32) as u16),
            unique_id: raw as u32,
        }
    }
@@ -495,16 +496,19 @@ pub mod std_mod {
 mod tests {
    use std::sync::mpsc;

-    use alloc::string::ToString;
-    use spacepackets::{
-        ByteConversionError, SpHeader,
-        ecss::tc::{PusTcCreator, PusTcSecondaryHeader},
-    };
-
    use crate::{
        queue::{GenericReceiveError, GenericSendError},
        request::{MessageMetadata, MessageSenderMap, MessageSenderStoreProvider},
    };
+    use alloc::string::ToString;
+    use arbitrary_int::{u11, u14};
+    use spacepackets::{
+        ByteConversionError, SpHeader,
+        ecss::{
+            CreatorConfig,
+            tc::{PusTcCreator, PusTcSecondaryHeader},
+        },
+    };

    use super::{GenericMessage, MessageReceiverWithId, UniqueApidTargetId};

@@ -514,8 +518,8 @@ mod tests {

    #[test]
    fn test_basic_target_id_with_apid() {
-        let id = UniqueApidTargetId::new(0x111, 0x01);
-        assert_eq!(id.apid, 0x111);
+        let id = UniqueApidTargetId::new(u11::new(0x111), 0x01);
+        assert_eq!(id.apid.value(), 0x111);
        assert_eq!(id.unique_id, 0x01);
        assert_eq!(id.id(), id.raw());
        assert_eq!(u64::from(id), id.raw());
@@ -532,19 +536,20 @@ mod tests {

    #[test]
    fn test_basic_target_id_with_apid_from_pus_tc() {
-        let sp_header = SpHeader::new_for_unseg_tc(0x111, 5, 0);
+        let sp_header = SpHeader::new_for_unseg_tc(u11::new(0x111), u14::new(5), 0);
        let app_data = 1_u32.to_be_bytes();
-        let pus_tc = PusTcCreator::new_simple(sp_header, 17, 1, &app_data, true);
+        let pus_tc =
+            PusTcCreator::new_simple(sp_header, 17, 1, &app_data, CreatorConfig::default());
        let id = UniqueApidTargetId::from_pus_tc(&pus_tc).unwrap();
-        assert_eq!(id.apid, 0x111);
+        assert_eq!(id.apid.value(), 0x111);
        assert_eq!(id.unique_id, 1);
    }

    #[test]
    fn test_basic_target_id_with_apid_from_pus_tc_invalid_app_data() {
-        let sp_header = SpHeader::new_for_unseg_tc(0x111, 5, 0);
+        let sp_header = SpHeader::new_for_unseg_tc(u11::new(0x111), u14::new(5), 0);
        let sec_header = PusTcSecondaryHeader::new_simple(17, 1);
-        let pus_tc = PusTcCreator::new_no_app_data(sp_header, sec_header, true);
+        let pus_tc = PusTcCreator::new_no_app_data(sp_header, sec_header, CreatorConfig::default());
        let error = UniqueApidTargetId::from_pus_tc(&pus_tc);
        assert!(error.is_err());
        let error = error.unwrap_err();
--- a/satrs/src/tmtc/tm_helper.rs
+++ b/satrs/src/tmtc/tm_helper.rs
@@ -1,15 +1,16 @@
+use arbitrary_int::{u11, u14};
 use spacepackets::SpHeader;
+use spacepackets::ecss::CreatorConfig;
 use spacepackets::ecss::tm::{PusTmCreator, PusTmSecondaryHeader};
-use spacepackets::time::TimeWriter;
 use spacepackets::time::cds::CdsTime;

 pub struct PusTmWithCdsShortHelper {
-    apid: u16,
+    apid: u11,
    cds_short_buf: [u8; 7],
 }

 impl PusTmWithCdsShortHelper {
-    pub fn new(apid: u16) -> Self {
+    pub fn new(apid: u11) -> Self {
        Self {
            apid,
            cds_short_buf: [0; 7],
@@ -22,7 +23,7 @@ impl PusTmWithCdsShortHelper {
        service: u8,
        subservice: u8,
        source_data: &'data [u8],
-        seq_count: u16,
+        seq_count: u14,
    ) -> PusTmCreator<'_, 'data> {
        let time_stamp = CdsTime::now_with_u16_days().unwrap();
        time_stamp.write_to_bytes(&mut self.cds_short_buf).unwrap();
@@ -35,7 +36,7 @@ impl PusTmWithCdsShortHelper {
        subservice: u8,
        source_data: &'data [u8],
        stamper: &CdsTime,
-        seq_count: u16,
+        seq_count: u14,
    ) -> PusTmCreator<'_, 'data> {
        stamper.write_to_bytes(&mut self.cds_short_buf).unwrap();
        self.create_pus_tm_common(service, subservice, source_data, seq_count)
@@ -46,11 +47,16 @@ impl PusTmWithCdsShortHelper {
        service: u8,
        subservice: u8,
        source_data: &'data [u8],
-        seq_count: u16,
+        seq_count: u14,
    ) -> PusTmCreator<'_, 'data> {
        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(reply_header, tc_header, source_data, true)
+        PusTmCreator::new(
+            reply_header,
+            tc_header,
+            source_data,
+            CreatorConfig::default(),
+        )
    }
 }

@@ -58,28 +64,29 @@ impl PusTmWithCdsShortHelper {
 mod tests {
    use spacepackets::{CcsdsPacket, ecss::PusPacket, time::cds::CdsTime};

-    use super::PusTmWithCdsShortHelper;
+    use super::*;

    #[test]
    fn test_helper_with_stamper() {
-        let mut pus_tm_helper = PusTmWithCdsShortHelper::new(0x123);
+        let mut pus_tm_helper = PusTmWithCdsShortHelper::new(u11::new(0x123));
        let stamper = CdsTime::new_with_u16_days(0, 0);
-        let tm = pus_tm_helper.create_pus_tm_with_stamper(17, 1, &[1, 2, 3, 4], &stamper, 25);
+        let tm =
+            pus_tm_helper.create_pus_tm_with_stamper(17, 1, &[1, 2, 3, 4], &stamper, u14::new(25));
        assert_eq!(tm.service(), 17);
        assert_eq!(tm.subservice(), 1);
        assert_eq!(tm.user_data(), &[1, 2, 3, 4]);
-        assert_eq!(tm.seq_count(), 25);
+        assert_eq!(tm.seq_count().value(), 25);
        assert_eq!(tm.timestamp(), [64, 0, 0, 0, 0, 0, 0])
    }

    #[test]
    fn test_helper_from_now() {
-        let mut pus_tm_helper = PusTmWithCdsShortHelper::new(0x123);
-        let tm = pus_tm_helper.create_pus_tm_timestamp_now(17, 1, &[1, 2, 3, 4], 25);
+        let mut pus_tm_helper = PusTmWithCdsShortHelper::new(u11::new(0x123));
+        let tm = pus_tm_helper.create_pus_tm_timestamp_now(17, 1, &[1, 2, 3, 4], u14::new(25));
        assert_eq!(tm.service(), 17);
        assert_eq!(tm.subservice(), 1);
        assert_eq!(tm.user_data(), &[1, 2, 3, 4]);
-        assert_eq!(tm.seq_count(), 25);
+        assert_eq!(tm.seq_count().value(), 25);
        assert_eq!(tm.timestamp().len(), 7);
    }
 }
--- a/satrs/tests/hk_helpers.rs
+++ b/satrs/tests/hk_helpers.rs
@@ -2,8 +2,8 @@
 use core::mem::size_of;
 use serde::{Deserialize, Serialize};
 use spacepackets::ecss::{PfcReal, PfcUnsigned, Ptc};
+use spacepackets::time::CcsdsTimeProvider;
 use spacepackets::time::cds::CdsTime;
-use spacepackets::time::{CcsdsTimeProvider, TimeWriter};

 enum NumOfParamsInfo {
    /// The parameter entry is a scalar field
--- a/satrs/tests/pus_events.rs
+++ b/satrs/tests/pus_events.rs
@@ -1,3 +1,4 @@
+use arbitrary_int::u11;
 use satrs::event_man::{
    EventManagerWithMpsc, EventMessage, EventMessageU32, EventRoutingError, EventSendProvider,
    EventU32SenderMpsc,
@@ -8,15 +9,15 @@ use satrs::params::{Params, ParamsHeapless, WritableToBeBytes};
 use satrs::pus::event_man::{DefaultPusEventReportingMap, EventReporter, PusEventTmCreatorWithMap};
 use satrs::request::UniqueApidTargetId;
 use satrs::tmtc::PacketAsVec;
+use spacepackets::ecss::PusError;
 use spacepackets::ecss::tm::PusTmReader;
-use spacepackets::ecss::{PusError, PusPacket};
 use std::sync::mpsc::{self, SendError, TryRecvError};
 use std::thread;

 const INFO_EVENT: EventU32TypedSev<SeverityInfo> = EventU32TypedSev::<SeverityInfo>::new(1, 0);
 const LOW_SEV_EVENT: EventU32 = EventU32::new(Severity::Low, 1, 5);
 const EMPTY_STAMP: [u8; 7] = [0; 7];
-const TEST_APID: u16 = 0x02;
+const TEST_APID: u11 = u11::new(0x02);
 const TEST_ID: UniqueApidTargetId = UniqueApidTargetId::new(TEST_APID, 0x05);

 #[derive(Debug, Clone)]
@@ -35,8 +36,8 @@ fn test_threaded_usage() {
    event_man.subscribe_all(pus_event_man_send_provider.target_id());
    event_man.add_sender(pus_event_man_send_provider);
    let (event_packet_tx, event_packet_rx) = mpsc::channel::<PacketAsVec>();
-    let reporter =
-        EventReporter::new(TEST_ID.raw(), 0x02, 0, 128).expect("Creating event reporter failed");
+    let reporter = EventReporter::new(TEST_ID.raw(), u11::new(0x02), 0, 128)
+        .expect("Creating event reporter failed");
    let pus_event_man =
        PusEventTmCreatorWithMap::new(reporter, DefaultPusEventReportingMap::default());
    let error_handler = |event_msg: &EventMessageU32, error: EventRoutingError| {
--- a/satrs/tests/pus_verification.rs
+++ b/satrs/tests/pus_verification.rs
@@ -1,5 +1,7 @@
 #[cfg(feature = "crossbeam")]
 pub mod crossbeam_test {
+    use arbitrary_int::traits::Integer as _;
+    use arbitrary_int::u14;
    use hashbrown::HashMap;
    use satrs::pool::{PoolProvider, PoolProviderWithGuards, StaticMemoryPool, StaticPoolConfig};
    use satrs::pus::test_util::{TEST_APID, TEST_COMPONENT_ID_0};
@@ -11,7 +13,7 @@ pub mod crossbeam_test {
    use spacepackets::SpHeader;
    use spacepackets::ecss::tc::{PusTcCreator, PusTcReader, PusTcSecondaryHeader};
    use spacepackets::ecss::tm::PusTmReader;
-    use spacepackets::ecss::{EcssEnumU8, EcssEnumU16, PusPacket, WritablePusPacket};
+    use spacepackets::ecss::{CreatorConfig, EcssEnumU8, EcssEnumU16, WritablePusPacket};
    use std::sync::RwLock;
    use std::thread;
    use std::time::Duration;
@@ -57,9 +59,9 @@ pub mod crossbeam_test {
        let (tx_tc_1, rx_tc_1) = crossbeam_channel::bounded(3);
        {
            let mut tc_guard = shared_tc_pool.write().unwrap();
-            let sph = SpHeader::new_for_unseg_tc(TEST_APID, 0, 0);
+            let sph = SpHeader::new_for_unseg_tc(TEST_APID, u14::ZERO, 0);
            let tc_header = PusTcSecondaryHeader::new_simple(17, 1);
-            let pus_tc_0 = PusTcCreator::new_no_app_data(sph, tc_header, true);
+            let pus_tc_0 = PusTcCreator::new_no_app_data(sph, tc_header, CreatorConfig::default());
            req_id_0 = RequestId::new(&pus_tc_0);
            let addr = tc_guard
                .free_element(pus_tc_0.len_written(), |buf| {
@@ -67,9 +69,9 @@ pub mod crossbeam_test {
                })
                .unwrap();
            tx_tc_0.send(addr).unwrap();
-            let sph = SpHeader::new_for_unseg_tc(TEST_APID, 1, 0);
+            let sph = SpHeader::new_for_unseg_tc(TEST_APID, u14::new(1), 0);
            let tc_header = PusTcSecondaryHeader::new_simple(5, 1);
-            let pus_tc_1 = PusTcCreator::new_no_app_data(sph, tc_header, true);
+            let pus_tc_1 = PusTcCreator::new_no_app_data(sph, tc_header, CreatorConfig::default());
            req_id_1 = RequestId::new(&pus_tc_1);
            let addr = tc_guard
                .free_element(pus_tc_0.len_written(), |buf| {
--- a/satrs/tests/tcp_servers.rs
+++ b/satrs/tests/tcp_servers.rs
@@ -21,6 +21,7 @@ use std::{
    thread,
 };

+use arbitrary_int::{traits::Integer, u11, u14};
 use hashbrown::HashSet;
 use satrs::{
    ComponentId,
@@ -36,7 +37,7 @@ use satrs::{
 };
 use spacepackets::{
    CcsdsPacket, PacketId, SpHeader,
-    ecss::{WritablePusPacket, tc::PusTcCreator},
+    ecss::{CreatorConfig, WritablePusPacket, tc::PusTcCreator},
 };
 use std::{collections::VecDeque, sync::Arc, vec::Vec};

@@ -192,7 +193,7 @@ fn test_cobs_server() {
    matches!(tc_receiver.try_recv(), Err(mpsc::TryRecvError::Empty));
 }

-const TEST_APID_0: u16 = 0x02;
+const TEST_APID_0: u11 = u11::new(0x02);
 const TEST_PACKET_ID_0: PacketId = PacketId::new_for_tc(true, TEST_APID_0);

 #[derive(Default)]
@@ -217,8 +218,8 @@ impl SpacePacketValidator for SimpleVerificator {
 fn test_ccsds_server() {
    let (tc_sender, tc_receiver) = mpsc::channel();
    let mut tm_source = SyncTmSource::default();
-    let sph = SpHeader::new_for_unseg_tc(TEST_APID_0, 0, 0);
-    let verif_tm = PusTcCreator::new_simple(sph, 1, 1, &[], true);
+    let sph = SpHeader::new_for_unseg_tc(TEST_APID_0, u14::new(0), 0);
+    let verif_tm = PusTcCreator::new_simple(sph, 1, 1, &[], CreatorConfig::default());
    let tm_0 = verif_tm.to_vec().expect("tm generation failed");
    tm_source.add_tm(&tm_0);
    let mut packet_id_lookup = SimpleVerificator::default();
@@ -267,8 +268,8 @@ fn test_ccsds_server() {
        .expect("setting reas timeout failed");

    // Send ping telecommand.
-    let sph = SpHeader::new_for_unseg_tc(TEST_APID_0, 0, 0);
-    let ping_tc = PusTcCreator::new_simple(sph, 17, 1, &[], true);
+    let sph = SpHeader::new_for_unseg_tc(TEST_APID_0, u14::ZERO, 0);
+    let ping_tc = PusTcCreator::new_simple(sph, 17, 1, &[], CreatorConfig::default());
    let tc_0 = ping_tc.to_vec().expect("packet creation failed");
    stream
        .write_all(&tc_0)
Author	SHA1	Message	Date
Robin Mueller	45a99cabce	bump spacepackets	2025-09-11 09:29:34 +02:00
Robin Mueller	ab44e3312c	update all the code	2025-09-10 19:01:44 +02:00