diff --git a/satrs-example/Cargo.toml b/satrs-example/Cargo.toml
index 2c74d58..6c83458 100644
--- 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"
diff --git a/satrs-example/src/bin/simpleclient.rs b/satrs-example/src/bin/simpleclient.rs
index 12e2b35..4fd3015 100644
--- 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}");
diff --git a/satrs-example/src/config.rs b/satrs-example/src/config.rs
index 24068d1..e08db67 100644
--- 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
     };
diff --git a/satrs-example/src/events.rs b/satrs-example/src/events.rs
index 2496b9a..779dfe9 100644
--- 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);
diff --git a/satrs-example/src/hk.rs b/satrs-example/src/hk.rs
index bfad5e8..f00438f 100644
--- a/satrs-example/src/hk.rs
+++ b/satrs-example/src/hk.rs
@@ -1,7 +1,7 @@
 use derive_new::new;
 use satrs::hk::UniqueId;
 use satrs::request::UniqueApidTargetId;
-use satrs::spacepackets::ecss::hk;
+use satrs::spacepackets::ecss::{hk, CreatorConfig};
 use satrs::spacepackets::ecss::tm::{PusTmCreator, PusTmSecondaryHeader};
 use satrs::spacepackets::{ByteConversionError, SpHeader};
 
@@ -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(),
         ))
     }
 }
diff --git a/satrs-example/src/ids.rs b/satrs-example/src/ids.rs
index 8da7094..9240e3e 100644
--- 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);
 }
diff --git a/satrs-example/src/lib.rs b/satrs-example/src/lib.rs
index 6a097fe..ff51a19 100644
--- 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;
diff --git a/satrs-example/src/main.rs b/satrs-example/src/main.rs
index a96f2de..4e7577e 100644
--- 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::{
diff --git a/satrs-example/src/pus/hk.rs b/satrs-example/src/pus/hk.rs
index 2232998..e3a0acd 100644
--- 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);
     }
diff --git a/satrs-example/src/pus/mod.rs b/satrs-example/src/pus/mod.rs
index 8c1060e..823612d 100644
--- 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() {
diff --git a/satrs-example/src/pus/mode.rs b/satrs-example/src/pus/mode.rs
index 4f71195..66bc8a9 100644
--- 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,10 @@ impl PusReplyHandler<ActivePusRequestStd, ModeReply> for ModeReplyHandler {
                     .write_to_be_bytes(&mut source_data)
                     .expect("writing mode reply failed");
                 let req_id = verification::RequestId::from(reply.request_id());
-                let 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 +292,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 +318,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 +334,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 +342,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 +360,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 +376,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)
diff --git a/satrs-example/src/tmtc/tm_sink.rs b/satrs-example/src/tmtc/tm_sink.rs
index 5cfe118..d92dcf6 100644
--- 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 {
-        self.apid_seq_counter_map
-            .entry(apid)
-            .or_default()
-            .get_and_increment()
+    pub fn get_and_increment(&mut self, apid: u11) -> u14 {
+        u14::new(
+            self.apid_seq_counter_map
+                .entry(apid)
+                .or_default()
+                .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,7 @@ 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);
diff --git a/satrs-shared/Cargo.toml b/satrs-shared/Cargo.toml
index e548c89..d2b87c8 100644
--- 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"
diff --git a/satrs/Cargo.toml b/satrs/Cargo.toml
index 88fe247..d84f562 100644
--- 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"
diff --git a/satrs/src/encoding/ccsds.rs b/satrs/src/encoding/ccsds.rs
index d569a3a..c1ed634 100644
--- 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,9 @@ 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,
+        ecss::{tc::PusTcCreator, CreatorConfig}, CcsdsPacket, PacketId, PacketSequenceControl, PacketType, SequenceFlags, SpHeader
     };
 
     use crate::{ComponentId, encoding::tests::TcCacher};
@@ -99,8 +99,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 +131,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 +156,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 +191,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)
@@ -222,9 +222,9 @@ mod tests {
     #[test]
     fn test_split_packet_multi() {
         let ping_tc =
-            PusTcCreator::new_simple(SpHeader::new_from_apid(TEST_APID_0), 17, 1, &[], true);
+            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, &[], true);
+            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)
@@ -256,7 +256,7 @@ mod tests {
     #[test]
     fn test_one_split_packet() {
         let ping_tc =
-            PusTcCreator::new_simple(SpHeader::new_from_apid(TEST_APID_0), 17, 1, &[], true);
+            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 +281,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];
diff --git a/satrs/src/pus/event.rs b/satrs/src/pus/event.rs
index 90cc767..ba367aa 100644
--- 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::ecss::tm::{PusTmCreator, PusTmSecondaryHeader};
+use spacepackets::ecss::{CreatorConfig, EcssEnumeration};
 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;
 
 #[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()
         ))
     }
 }
@@ -132,8 +129,8 @@ impl EventReportCreator {
 #[cfg(feature = "alloc")]
 mod alloc_mod {
     use super::*;
-    use crate::ComponentId;
     use crate::pus::{EcssTmSender, EcssTmtcError};
+    use crate::ComponentId;
     use alloc::vec;
     use alloc::vec::Vec;
     use core::cell::RefCell;
@@ -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]),
@@ -265,18 +262,18 @@ mod alloc_mod {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::ComponentId;
     use crate::events::{EventU32, Severity};
     use crate::pus::test_util::TEST_COMPONENT_ID_0;
     use crate::pus::tests::CommonTmInfo;
     use crate::pus::{ChannelWithId, EcssTmSender, EcssTmtcError, PusTmVariant};
-    use spacepackets::ByteConversionError;
+    use crate::ComponentId;
     use spacepackets::ecss::PusError;
+    use spacepackets::ByteConversionError;
     use std::cell::RefCell;
     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)]
diff --git a/satrs/src/pus/mod.rs b/satrs/src/pus/mod.rs
index b59b177..26e2b3a 100644
--- 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 {
diff --git a/satrs/src/pus/scheduler.rs b/satrs/src/pus/scheduler.rs
index a03325f..ea86622 100644
--- 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
     }
 }
 
@@ -340,8 +347,8 @@ pub fn generate_insert_telecommand_app_data(
 pub mod alloc_mod {
     use alloc::{
         collections::{
-            BTreeMap,
             btree_map::{Entry, Range},
+            BTreeMap,
         },
         vec::Vec,
     };
@@ -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::time::{TimeWriter, UnixTime, cds};
-    use spacepackets::{PacketId, PacketSequenceCtrl, PacketType, SequenceFlags, SpHeader};
+    use spacepackets::ecss::{CreatorConfig, WritablePusPacket};
+    use spacepackets::time::{cds, TimeWriter, UnixTime};
+    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,9 @@ 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 +1943,9 @@ 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 +1969,11 @@ 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 +2006,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 +2041,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 +2063,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 +2092,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)
diff --git a/satrs/src/pus/test.rs b/satrs/src/pus/test.rs
index 6c1e620..4bea1f0 100644
--- a/satrs/src/pus/test.rs
+++ b/satrs/src/pus/test.rs
@@ -2,8 +2,9 @@ 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::{CreatorConfig, PusPacket};
 use spacepackets::ecss::tm::{PusTmCreator, PusTmSecondaryHeader};
 use std::sync::mpsc;
 
@@ -76,9 +77,9 @@ impl<
             // 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);
+                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,9 +149,10 @@ 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::{CreatorConfig, PusPacket};
     use spacepackets::ecss::tc::{PusTcCreator, PusTcSecondaryHeader};
     use spacepackets::ecss::tm::PusTmReader;
     use spacepackets::time::{TimeWriter, cds};
@@ -283,9 +285,9 @@ 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 +340,9 @@ 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 +361,9 @@ 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();
diff --git a/satrs/src/pus/verification.rs b/satrs/src/pus/verification.rs
index 2db42c4..7b4aa5b 100644
--- a/satrs/src/pus/verification.rs
+++ b/satrs/src/pus/verification.rs
@@ -81,7 +81,9 @@
 //! for the verification module contains examples how this module could be used in a more complex
 //! context involving multiple threads
 use crate::params::{Params, WritableToBeBytes};
-use crate::pus::{EcssTmSender, EcssTmtcError, source_buffer_large_enough};
+use crate::pus::{source_buffer_large_enough, EcssTmSender, EcssTmtcError};
+use arbitrary_int::traits::Integer as _;
+use arbitrary_int::{u11, u14, u3};
 use core::fmt::{Debug, Display, Formatter};
 use core::hash::{Hash, Hasher};
 use core::marker::PhantomData;
@@ -90,20 +92,19 @@ 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::{MAX_APID, SpHeader};
+use spacepackets::ecss::{CreatorConfig, EcssEnumeration};
+use spacepackets::{ByteConversionError, CcsdsPacket, PacketId, PacketSequenceControl};
+use spacepackets::{SpHeader, MAX_APID};
 
 pub use spacepackets::ecss::verification::*;
-pub use spacepackets::seq_count::SeqCountProviderSimple;
 
 #[cfg(feature = "alloc")]
 pub use alloc_mod::*;
 
-use crate::ComponentId;
 use crate::request::Apid;
+use crate::ComponentId;
 
 /// This is a request identifier as specified in 5.4.11.2 c. of the PUS standard.
 ///
@@ -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(
@@ -1686,39 +1712,41 @@ pub mod test_util {
 
 #[cfg(test)]
 pub mod tests {
-    use crate::ComponentId;
     use crate::params::Params;
     use crate::pool::{SharedStaticMemoryPool, StaticMemoryPool, StaticPoolConfig};
     use crate::pus::test_util::{TEST_APID, TEST_COMPONENT_ID_0};
     use crate::pus::tests::CommonTmInfo;
     use crate::pus::verification::{
-        EcssTmSender, EcssTmtcError, FailParams, FailParamsWithStep, RequestId, TcStateNone,
-        VerificationReporter, VerificationReporterConfig, VerificationToken,
-        handle_step_failure_with_generic_params,
+        handle_step_failure_with_generic_params, EcssTmSender, EcssTmtcError, FailParams,
+        FailParamsWithStep, RequestId, TcStateNone, VerificationReporter,
+        VerificationReporterConfig, VerificationToken,
     };
     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 crate::ComponentId;
     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, EcssEnumU16, EcssEnumU32, EcssEnumU8, EcssEnumeration, PusError, PusPacket,
         WritablePusPacket,
     };
+    use spacepackets::seq_count::SequenceCounterSimple;
     use spacepackets::util::UnsignedEnum;
     use spacepackets::{ByteConversionError, SpHeader};
     use std::cell::RefCell;
     use std::collections::VecDeque;
-    use std::sync::{RwLock, mpsc};
+    use std::sync::{mpsc, RwLock};
     use std::vec;
     use std::vec::Vec;
 
     use super::{
-        DummyVerificationHook, FailParamHelper, SeqCountProviderSimple, TcStateAccepted,
-        TcStateStarted, VerificationHook, VerificationReportingProvider, WasAtLeastAccepted,
-        handle_completion_failure_with_generic_params,
+        handle_completion_failure_with_generic_params, DummyVerificationHook, FailParamHelper,
+        TcStateAccepted, TcStateStarted, VerificationHook, VerificationReportingProvider,
+        WasAtLeastAccepted,
     };
 
     fn is_send<T: Send>(_: &T) {}
@@ -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());
     }
 
diff --git a/satrs/src/request.rs b/satrs/src/request.rs
index e3d03d1..824f237 100644
--- a/satrs/src/request.rs
+++ b/satrs/src/request.rs
@@ -1,4 +1,5 @@
 use core::{fmt, marker::PhantomData};
+use arbitrary_int::{traits::Integer as _, u11};
 #[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,
         }
     }
@@ -496,11 +497,10 @@ mod tests {
     use std::sync::mpsc;
 
     use alloc::string::ToString;
+    use arbitrary_int::{u11, u14};
     use spacepackets::{
-        ByteConversionError, SpHeader,
-        ecss::tc::{PusTcCreator, PusTcSecondaryHeader},
+        ecss::{tc::{PusTcCreator, PusTcSecondaryHeader}, CreatorConfig}, ByteConversionError, SpHeader
     };
-
     use crate::{
         queue::{GenericReceiveError, GenericSendError},
         request::{MessageMetadata, MessageSenderMap, MessageSenderStoreProvider},
@@ -514,8 +514,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 +532,18 @@ 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 app_data = 1_u32.to_be_bytes();
-        let pus_tc = PusTcCreator::new_simple(sp_header, 17, 1, &app_data, true);
+        let sp_header = SpHeader::new_for_unseg_tc(u11::new(0x111), u14::new(5), 0);
+        let pus_tc = PusTcCreator::new_simple(sp_header, 17, 1, &[], 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();
diff --git a/satrs/src/tmtc/tm_helper.rs b/satrs/src/tmtc/tm_helper.rs
index 26ea8d4..25923f7 100644
--- 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::ecss::CreatorConfig;
 use spacepackets::SpHeader;
 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,11 @@ 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 +59,28 @@ 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);
     }
 }