bump spacepackets

update all the code
2025-09-11 09:29:34 +02:00 · 2025-09-10 19:01:44 +02:00
29 changed files with 180 additions and 201 deletions
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -47,8 +47,6 @@ jobs:
    steps:
      - uses: actions/checkout@v4
      - uses: dtolnay/rust-toolchain@stable
-        with:
-          components: rustfmt
      - run: cargo fmt --all -- --check

  docs:
@@ -65,6 +63,4 @@ jobs:
    steps:
      - uses: actions/checkout@v4
      - uses: dtolnay/rust-toolchain@stable
-        with:
-          components: clippy
      - run: cargo clippy -- -D warnings
--- a/21
+++ b/21
@@ -1,21 +0,0 @@
-all: check embedded test fmt clippy docs
-
-check:
-  cargo check
-  cargo check -p satrs-example --no-default-features
-
-test:
-  cargo nextest run --all-features
-  cargo test --doc --all-features
-
-embedded:
-  cargo check -p satrs --target=thumbv7em-none-eabihf --no-default-features
-
-fmt:
-  cargo fmt --all -- --check
-
-clippy:
-  cargo clippy -- -D warnings
-
-docs:
-  cargo +nightly doc --all-features --config 'build.rustdocflags=["--cfg", "docs_rs"]'
--- 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"
@@ -21,8 +23,6 @@ lazy_static = "1"
 strum = { version = "0.27", features = ["derive"] }
 derive-new = "0.7"
 cfg-if = "1"
-arbitrary-int = "2"
-bitbybit = "1.4"
 serde = { version = "1", features = ["derive"] }
 serde_json = "1"

@@ -38,8 +38,8 @@ version = "0.1.1"
 path = "../satrs-mib"

 [features]
-default = ["heap_tmtc"]
 heap_tmtc = []
+default = ["heap_tmtc"]

 [dev-dependencies]
 env_logger = "0.11"
--- a/satrs-example/src/config.rs
+++ b/satrs-example/src/config.rs
@@ -1,4 +1,3 @@
-use arbitrary_int::u11;
 use lazy_static::lazy_static;
 use satrs::{
    res_code::ResultU16,
@@ -45,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, u11::new(id as u16)));
+            set.insert(PacketId::new(PacketType::Tc, true, id.raw_value()));
        }
        set
    };
--- a/satrs-example/src/events.rs
+++ b/satrs-example/src/events.rs
@@ -1,7 +1,6 @@
 use std::sync::mpsc::{self};

 use crate::pus::create_verification_reporter;
-use arbitrary_int::traits::Integer as _;
 use arbitrary_int::u11;
 use satrs::event_man::{EventMessageU32, EventRoutingError};
 use satrs::pus::event::EventTmHook;
@@ -61,11 +60,12 @@ impl<TmSender: EcssTmSender> PusEventHandler<TmSender> {
        // telemetry for each event.
        let event_reporter = EventReporter::new_with_hook(
            PUS_EVENT_MANAGEMENT.raw(),
-            u11::ZERO,
+            u11::new(0),
            0,
            128,
            EventApidSetter::default(),
-        );
+        )
+        .unwrap();
        let pus_event_dispatcher =
            DefaultPusEventU32TmCreator::new_with_default_backend(event_reporter);
        let pus_event_man_send_provider = EventU32SenderMpscBounded::new(
@@ -242,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(u11::new(0x05), 2, 2, 128);
+            let verif_reporter_cfg =
+                VerificationReporterConfig::new(u11::new(0x05), 2, 2, 128).unwrap();
            let verif_reporter =
                VerificationReporter::new(PUS_EVENT_MANAGEMENT.id(), &verif_reporter_cfg);
            let mut event_manager = EventManagerWithBoundedMpsc::new(event_rx);
--- a/satrs-example/src/ids.rs
+++ b/satrs-example/src/ids.rs
@@ -2,7 +2,7 @@
 use satrs::request::UniqueApidTargetId;

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

 pub mod acs {
-
    #[derive(Debug, Copy, Clone, PartialEq, Eq)]
    pub enum Id {
        Subsystem = 1,
--- a/satrs-example/src/interface/udp.rs
+++ b/satrs-example/src/interface/udp.rs
@@ -1,14 +1,13 @@
-#![allow(dead_code)]
 use std::net::{SocketAddr, UdpSocket};
 use std::sync::mpsc;

 use log::{info, warn};
-use satrs::hal::std::udp_server::{ReceiveResult, UdpTcServer};
 use satrs::pus::HandlingStatus;
-use satrs::tmtc::{PacketAsVec, StoreAndSendError};
-
-use satrs::pool::{PoolProviderWithGuards, SharedStaticMemoryPool};
-use satrs::tmtc::PacketInPool;
+use satrs::tmtc::{PacketAsVec, PacketInPool, StoreAndSendError};
+use satrs::{
+    hal::std::udp_server::{ReceiveResult, UdpTcServer},
+    pool::{PoolProviderWithGuards, SharedStaticMemoryPool},
+};

 use crate::tmtc::sender::TmTcSender;

@@ -16,6 +15,7 @@ pub trait UdpTmHandler {
    fn send_tm_to_udp_client(&mut self, socket: &UdpSocket, recv_addr: &SocketAddr);
 }

+#[allow(dead_code)]
 pub struct StaticUdpTmHandler {
    pub tm_rx: mpsc::Receiver<PacketInPool>,
    pub tm_store: SharedStaticMemoryPool,
--- a/satrs-example/src/pus/action.rs
+++ b/satrs-example/src/pus/action.rs
@@ -456,6 +456,7 @@ mod tests {
        app_data[4..8].copy_from_slice(&action_id.to_be_bytes());
        let pus8_packet =
            PusTcCreator::new(sp_header, sec_header, &app_data, CreatorConfig::default());
+
        testbench.add_tc(&pus8_packet);
        let time_stamp: [u8; 7] = [0; 7];
        testbench.verify_next_tc_is_handled_properly(&time_stamp);
--- a/satrs-example/src/pus/hk.rs
+++ b/satrs-example/src/pus/hk.rs
@@ -302,7 +302,7 @@ impl TargetedPusService for HkServiceWrapper {

 #[cfg(test)]
 mod tests {
-    use arbitrary_int::traits::Integer as _;
+    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,
@@ -327,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, u14::ZERO, 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];
@@ -361,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, u14::ZERO, 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];
@@ -400,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, u14::ZERO, 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];
@@ -439,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, u14::ZERO, 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];
--- a/satrs-example/src/pus/mod.rs
+++ b/satrs-example/src/pus/mod.rs
@@ -33,7 +33,7 @@ pub mod stack;
 pub mod test;

 pub fn create_verification_reporter(owner_id: ComponentId, apid: Apid) -> VerificationReporter {
-    let verif_cfg = VerificationReporterConfig::new(apid, 1, 2, 8);
+    let verif_cfg = VerificationReporterConfig::new(apid, 1, 2, 8).unwrap();
    // Every software component which needs to generate verification telemetry, gets a cloned
    // verification reporter.
    VerificationReporter::new(owner_id, &verif_cfg)
--- a/satrs-example/src/pus/mode.rs
+++ b/satrs-example/src/pus/mode.rs
@@ -1,4 +1,3 @@
-use arbitrary_int::traits::Integer as _;
 use arbitrary_int::u14;
 use derive_new::new;
 use satrs::mode_tree::{ModeNode, ModeParent};
@@ -80,7 +79,8 @@ 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(), u14::ZERO, 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(
@@ -298,7 +298,6 @@ impl TargetedPusService for ModeServiceWrapper {

 #[cfg(test)]
 mod tests {
-    use arbitrary_int::traits::Integer;
    use arbitrary_int::u14;
    use satrs::pus::test_util::{TEST_APID, TEST_COMPONENT_ID_0, TEST_UNIQUE_ID_0};
    use satrs::request::MessageMetadata;
@@ -325,7 +324,7 @@ 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, u14::ZERO, 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());
@@ -341,7 +340,7 @@ mod tests {
    fn mode_converter_set_mode_request() {
        let mut testbench =
            PusConverterTestbench::new(TEST_COMPONENT_ID_0.id(), ModeRequestConverter::default());
-        let sp_header = SpHeader::new_for_unseg_tc(TEST_APID, u14::ZERO, 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);
@@ -367,7 +366,7 @@ 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, u14::ZERO, 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());
@@ -383,7 +382,7 @@ 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, u14::ZERO, 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];
--- a/satrs-example/src/tmtc/tm_sink.rs
+++ b/satrs-example/src/tmtc/tm_sink.rs
@@ -9,11 +9,13 @@ use satrs::{
    pool::PoolProvider,
    spacepackets::{
        ecss::{tm::PusTmZeroCopyWriter, PusPacket},
-        seq_count::SequenceCounter,
        seq_count::SequenceCounterCcsdsSimple,
        time::cds::MIN_CDS_FIELD_LEN,
        CcsdsPacket,
    },
+};
+use satrs::{
+    spacepackets::seq_count::SequenceCounter,
    tmtc::{PacketAsVec, PacketInPool, SharedPacketPool},
 };

--- 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.16", default-features = false }
+spacepackets = { git = "https://egit.irs.uni-stuttgart.de/rust/spacepackets.git", version = ">=0.14, <=0.16", default-features = false }

 [dependencies.serde]
 version = "1"
--- a/satrs/CHANGELOG.md
+++ b/satrs/CHANGELOG.md
@@ -8,10 +8,7 @@ and this project adheres to [Semantic Versioning](http://semver.org/).

 # [unreleased]

-# [v0.3.0-alpha.3] 2025-09-??
-
 - Bump `sat-rs` edition to 2024.
- Bumped `spacepackets` to v0.16

 ## Changed

@@ -222,8 +219,7 @@ docs-rs hotfix

 Initial release.

-[unreleased]: https://egit.irs.uni-stuttgart.de/rust/sat-rs/compare/satrs-v0.3.0-alpha.3...HEAD
-[v0.3.0-alpha.3]: https://egit.irs.uni-stuttgart.de/rust/sat-rs/compare/satrs-v0.3.0-alpha.2...satrs-v0.3.0-alpha.3
+[unreleased]: https://egit.irs.uni-stuttgart.de/rust/sat-rs/compare/satrs-v0.3.0-alpha.2...HEAD
 [v0.3.0-alpha.2]: https://egit.irs.uni-stuttgart.de/rust/sat-rs/compare/satrs-v0.3.0-alpha.1...satrs-v0.3.0-alpha.2
 [v0.3.0-alpha.1]: https://egit.irs.uni-stuttgart.de/rust/sat-rs/compare/satrs-v0.3.0-alpha.0...satrs-v0.3.0-alpha.1
 [v0.3.0-alpha.0]: https://egit.irs.uni-stuttgart.de/rust/sat-rs/compare/satrs-v0.2.1...satrs-v0.3.0-alpha.0
--- 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.16", 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"
@@ -32,7 +33,6 @@ bus = { version = "2.2", optional = true }
 crossbeam-channel = { version = "0.5", default-features = false, optional = true }
 serde = { version = "1", default-features = false, optional = true }
 socket2 = { version = "0.6", features = ["all"], optional = true }
-arbitrary-int = "2"
 mio = { version = "1", features = ["os-poll", "net"], optional = true }
 defmt = { version = "1", optional = true }

--- a/satrs/src/encoding/ccsds.rs
+++ b/satrs/src/encoding/ccsds.rs
@@ -1,4 +1,4 @@
-use spacepackets::SpHeader;
+use spacepackets::{CcsdsPacket, SpHeader};

 use crate::{ComponentId, tmtc::PacketSenderRaw};

--- a/satrs/src/hal/std/udp_server.rs
+++ b/satrs/src/hal/std/udp_server.rs
@@ -26,8 +26,7 @@ use std::vec::Vec;
 /// use satrs::ComponentId;
 /// use satrs::tmtc::PacketSenderRaw;
 /// use spacepackets::SpHeader;
-/// use spacepackets::ecss::tc::{PusTcCreator, CreatorConfig};
-/// use arbitrary_int::u11;
+/// use spacepackets::ecss::tc::PusTcCreator;
 ///
 /// const UDP_SERVER_ID: ComponentId = 0x05;
 ///
@@ -35,8 +34,8 @@ use std::vec::Vec;
 /// let dest_addr = SocketAddr::new(IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1)), 7777);
 /// let mut udp_tc_server = UdpTcServer::new(UDP_SERVER_ID, dest_addr, 2048, packet_sender)
 ///       .expect("Creating UDP TMTC server failed");
-/// let sph = SpHeader::new_from_apid(u11::new(0x02));
-/// let pus_tc = PusTcCreator::new_simple(sph, 17, 1, &[], CreatorConfig::default());
+/// let sph = SpHeader::new_from_apid(0x02);
+/// let pus_tc = PusTcCreator::new_simple(sph, 17, 1, &[], true);
 /// // Can not fail.
 /// let ping_tc_raw = pus_tc.to_vec().unwrap();
 ///
--- a/satrs/src/pus/event.rs
+++ b/satrs/src/pus/event.rs
@@ -2,10 +2,8 @@ use crate::pus::source_buffer_large_enough;
 use arbitrary_int::u11;
 use spacepackets::ByteConversionError;
 use spacepackets::SpHeader;
-use spacepackets::ecss::CreatorConfig;
-use spacepackets::ecss::EcssEnumeration;
-use spacepackets::ecss::tm::PusTmCreator;
-use spacepackets::ecss::tm::PusTmSecondaryHeader;
+use spacepackets::ecss::tm::{PusTmCreator, PusTmSecondaryHeader};
+use spacepackets::ecss::{CreatorConfig, EcssEnumeration};

 #[cfg(feature = "alloc")]
 pub use alloc_mod::*;
@@ -164,14 +162,14 @@ mod alloc_mod {
            default_apid: u11,
            default_dest_id: u16,
            max_event_id_and_aux_data_size: usize,
-        ) -> Self {
+        ) -> Option<Self> {
            let reporter = EventReportCreator::new(default_apid, default_dest_id);
-            Self {
+            Some(Self {
                id,
                source_data_buf: RefCell::new(vec![0; max_event_id_and_aux_data_size]),
                report_creator: reporter,
                tm_hook: DummyEventHook::default(),
-            }
+            })
        }
    }
    impl<EventTmHookInstance: EventTmHook> EventReporter<EventTmHookInstance> {
@@ -181,14 +179,14 @@ mod alloc_mod {
            default_dest_id: u16,
            max_event_id_and_aux_data_size: usize,
            tm_hook: EventTmHookInstance,
-        ) -> Self {
+        ) -> Option<Self> {
            let reporter = EventReportCreator::new(default_apid, default_dest_id);
-            Self {
+            Some(Self {
                id,
                source_data_buf: RefCell::new(vec![0; max_event_id_and_aux_data_size]),
                report_creator: reporter,
                tm_hook,
-            }
+            })
        }

        pub fn event_info(
@@ -375,12 +373,14 @@ mod tests {
        error_data: Option<&[u8]>,
    ) {
        let mut sender = TestSender::default();
-        let mut reporter = EventReporter::new(
+        let reporter = EventReporter::new(
            TEST_COMPONENT_ID_0.id(),
            EXAMPLE_APID,
            0,
            max_event_aux_data_buf,
        );
+        assert!(reporter.is_some());
+        let mut reporter = reporter.unwrap();
        let time_stamp_empty: [u8; 7] = [0; 7];
        let mut error_copy = Vec::new();
        if let Some(err_data) = error_data {
@@ -471,7 +471,9 @@ mod tests {
    fn insufficient_buffer() {
        let mut sender = TestSender::default();
        for i in 0..3 {
-            let mut reporter = EventReporter::new(0, EXAMPLE_APID, 0, i);
+            let reporter = EventReporter::new(0, EXAMPLE_APID, 0, i);
+            assert!(reporter.is_some());
+            let mut reporter = reporter.unwrap();
            check_buf_too_small(&mut reporter, &mut sender, i);
        }
    }
--- a/satrs/src/pus/event_man.rs
+++ b/satrs/src/pus/event_man.rs
@@ -328,11 +328,13 @@ mod tests {
    const TEST_ID: UniqueApidTargetId = UniqueApidTargetId::new(TEST_APID, 0x05);

    fn create_basic_man_1() -> DefaultPusEventU32TmCreator {
-        let reporter = EventReporter::new(TEST_ID.raw(), TEST_APID, 0, 128);
+        let reporter = EventReporter::new(TEST_ID.raw(), TEST_APID, 0, 128)
+            .expect("Creating event repoter failed");
        PusEventTmCreatorWithMap::new_with_default_backend(reporter)
    }
    fn create_basic_man_2() -> DefaultPusEventU32TmCreator {
-        let reporter = EventReporter::new(TEST_ID.raw(), TEST_APID, 0, 128);
+        let reporter = EventReporter::new(TEST_ID.raw(), TEST_APID, 0, 128)
+            .expect("Creating event repoter failed");
        let backend = DefaultPusEventReportingMap::default();
        PusEventTmCreatorWithMap::new(reporter, backend)
    }
--- a/satrs/src/pus/mod.rs
+++ b/satrs/src/pus/mod.rs
@@ -449,7 +449,7 @@ pub mod alloc_mod {
    /// Having a dedicated trait for this allows maximum flexiblity and tailoring of the standard.
    /// The only requirement is that a valid active request information instance and a request
    /// are returned by the core conversion function. The active request type needs to fulfill
-    /// the [ActiveRequest] trait bound.
+    /// the [ActiveRequestProvider] trait bound.
    ///
    /// The user should take care of performing the error handling as well. Some of the following
    /// aspects might be relevant:
@@ -1126,7 +1126,7 @@ pub mod std_mod {
    /// groups (for example individual services).
    ///
    /// This base class can handle PUS telecommands backed by different memory storage machanisms
-    /// by using the [CacheAndReadRawEcssTc] abstraction. This object provides some convenience
+    /// by using the [EcssTcInMemConverter] abstraction. This object provides some convenience
    /// methods to make the generic parts of TC handling easier.
    pub struct PusServiceHelper<
        TcReceiver: EcssTcReceiver,
@@ -1409,7 +1409,7 @@ pub mod tests {
            let (test_srv_tc_tx, test_srv_tc_rx) = mpsc::sync_channel(10);
            let (tm_tx, tm_rx) = mpsc::sync_channel(10);

-            let verif_cfg = VerificationReporterConfig::new(TEST_APID, 1, 2, 8);
+            let verif_cfg = VerificationReporterConfig::new(TEST_APID, 1, 2, 8).unwrap();
            let verification_handler =
                VerificationReporter::new(TEST_COMPONENT_ID_0.id(), &verif_cfg);
            let test_srv_tm_sender =
@@ -1502,7 +1502,7 @@ pub mod tests {
            let (test_srv_tc_tx, test_srv_tc_rx) = mpsc::channel();
            let (tm_tx, tm_rx) = mpsc::channel();

-            let verif_cfg = VerificationReporterConfig::new(TEST_APID, 1, 2, 8);
+            let verif_cfg = VerificationReporterConfig::new(TEST_APID, 1, 2, 8).unwrap();
            let verification_handler =
                VerificationReporter::new(TEST_COMPONENT_ID_0.id(), &verif_cfg);
            let in_store_converter = EcssTcVecCacher::default();
--- a/satrs/src/pus/scheduler.rs
+++ b/satrs/src/pus/scheduler.rs
@@ -25,7 +25,6 @@ pub use alloc_mod::*;
 /// the source ID found in the secondary header of PUS telecommands.
 #[derive(Debug, Copy, Clone, PartialEq, Eq)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
-#[cfg_attr(feature = "defmt", derive(defmt::Format))]
 pub struct RequestId {
    pub(crate) source_id: u16,
    pub(crate) apid: u11,
@@ -58,6 +57,7 @@ impl RequestId {
        }
    }

+    #[inline]
    pub const fn as_u64(&self) -> u64 {
        ((self.source_id as u64) << 32)
            | ((self.apid.value() as u64) << 16)
@@ -862,8 +862,7 @@ mod tests {
        PoolAddr, PoolError, PoolProvider, StaticMemoryPool, StaticPoolAddr, StaticPoolConfig,
    };
    use alloc::collections::btree_map::Range;
-    use arbitrary_int::traits::Integer;
-    use arbitrary_int::{u11, u14};
+    use arbitrary_int::traits::Integer as _;
    use spacepackets::ecss::tc::{PusTcCreator, PusTcReader, PusTcSecondaryHeader};
    use spacepackets::ecss::{CreatorConfig, WritablePusPacket};
    use spacepackets::time::{TimeWriter, UnixTime, cds};
@@ -873,6 +872,8 @@ mod tests {
    #[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)
@@ -1016,7 +1017,7 @@ mod tests {
                    }),
                    RequestId {
                        seq_count: u14::new(1),
-                        apid: u11::ZERO,
+                        apid: u11::new(0),
                        source_id: 0,
                    },
                ),
@@ -1093,22 +1094,20 @@ mod tests {
    #[test]
    fn test_request_id() {
        let src_id_to_set = 12;
-        let apid_to_set = u11::new(0x22);
-        let seq_count = u14::new(105);
-        let sp_header = SpHeader::new_for_unseg_tc(apid_to_set, u14::new(105), 0);
+        let apid_to_set = 0x22;
+        let seq_count = 105;
+        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, 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.value() as u64) << 16
-                | seq_count.value() as u64
+            ((src_id_to_set as u64) << 32) | (apid_to_set as u64) << 16 | seq_count as u64
        );
    }
    #[test]
@@ -1120,7 +1119,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, u14::ZERO, &[]);
+        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)
@@ -1188,7 +1187,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, u14::ZERO, &[]);
+        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)
@@ -1250,7 +1249,7 @@ mod tests {
        scheduler.disable();

        let mut buf: [u8; 32] = [0; 32];
-        let tc_info_0 = ping_tc_to_store(&mut pool, &mut buf, u14::ZERO, &[]);
+        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)
@@ -1317,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, u14::ZERO, &[]);
+        let tc_info_0 = ping_tc_to_store(&mut pool, &mut buf, u14::new(0), &[]);

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

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

@@ -1382,7 +1381,7 @@ mod tests {
        let read_len = pool.read(&info.addr, &mut buf).unwrap();
        let check_tc = PusTcReader::new(&buf).expect("incorrect Pus tc raw data");
        assert_eq!(read_len, check_tc.packet_len());
-        assert_eq!(check_tc, base_ping_tc_simple_ctor(u14::ZERO, &[]));
+        assert_eq!(check_tc, base_ping_tc_simple_ctor(u14::new(0), &[]));

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

@@ -1550,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, u14::ZERO, &[]);
+        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");
@@ -1587,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, u14::ZERO, &[]);
+        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");
@@ -1613,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, u14::ZERO, &[]);
+        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");
@@ -1634,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, u14::ZERO, &[]);
+        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");
@@ -1655,7 +1654,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, u14::ZERO, &[]);
+        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");
@@ -1741,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, u14::ZERO, 50);
-        let tc_info_1 = insert_command_with_release_time(&mut pool, &mut scheduler, u14::ZERO, 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;
@@ -1773,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, u14::ZERO, 50);
-        let tc_info_1 = insert_command_with_release_time(&mut pool, &mut scheduler, u14::ZERO, 100);
-        let tc_info_2 = insert_command_with_release_time(&mut pool, &mut scheduler, u14::ZERO, 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,
@@ -1808,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, u14::ZERO, 50);
-        let tc_info_1 = insert_command_with_release_time(&mut pool, &mut scheduler, u14::ZERO, 100);
-        let _ = insert_command_with_release_time(&mut pool, &mut scheduler, u14::ZERO, 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(
@@ -1843,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, u14::ZERO, 50);
-        let tc_info_1 = insert_command_with_release_time(&mut pool, &mut scheduler, u14::ZERO, 100);
-        let tc_info_2 = insert_command_with_release_time(&mut pool, &mut scheduler, u14::ZERO, 150);
-        let _ = insert_command_with_release_time(&mut pool, &mut scheduler, u14::ZERO, 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(
@@ -1884,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, u14::ZERO, 50);
-        insert_command_with_release_time(&mut pool, &mut scheduler, u14::ZERO, 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());
@@ -1894,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, u14::ZERO, 50);
-        insert_command_with_release_time(&mut pool, &mut scheduler, u14::ZERO, 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);
@@ -1913,11 +1918,11 @@ mod tests {
            false,
        ));
        let mut scheduler = PusScheduler::new(UnixTime::new_only_secs(0), Duration::from_secs(5));
-        insert_command_with_release_time(&mut pool, &mut scheduler, u14::ZERO, 50);
+        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, u14::ZERO, 100);
+            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, u14::ZERO, 150);
+            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),
@@ -1941,10 +1946,10 @@ mod tests {
        ));
        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, u14::ZERO, 50);
+            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, u14::ZERO, 100);
-        insert_command_with_release_time(&mut pool, &mut scheduler, u14::ZERO, 150);
+            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(
@@ -1969,13 +1974,13 @@ mod tests {
        ));
        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, u14::ZERO, 50);
+            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, u14::ZERO, 100);
+            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, u14::ZERO, 150);
+            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, u14::ZERO, 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(
@@ -2008,7 +2013,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, u14::ZERO, &[]);
+        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)
--- a/satrs/src/pus/scheduler_srv.rs
+++ b/satrs/src/pus/scheduler_srv.rs
@@ -260,7 +260,7 @@ mod tests {
    };
    use crate::tmtc::PacketSenderWithSharedPool;
    use alloc::collections::VecDeque;
-    use arbitrary_int::traits::Integer as _;
+    use arbitrary_int::traits::Integer;
    use arbitrary_int::u14;
    use delegate::delegate;
    use spacepackets::SpHeader;
@@ -446,7 +446,7 @@ mod tests {
        let ping_raw = ping_tc.to_vec().expect("generating raw tc failed");
        sched_app_data[written_len..written_len + ping_raw.len()].copy_from_slice(&ping_raw);
        written_len += ping_raw.len();
-        reply_header = SpHeader::new_for_unseg_tc(TEST_APID, u14::ZERO, 0);
+        reply_header = SpHeader::new_for_unseg_tc(TEST_APID, u14::new(1), 0);
        sec_header = PusTcSecondaryHeader::new_simple(11, Subservice::TcInsertActivity as u8);
        let enable_scheduling = PusTcCreator::new(
            reply_header,
--- a/satrs/src/pus/test.rs
+++ b/satrs/src/pus/test.rs
@@ -2,7 +2,6 @@ use crate::pus::{
    DirectPusPacketHandlerResult, PartialPusHandlingError, PusPacketHandlingError, PusTmVariant,
 };
 use crate::tmtc::{PacketAsVec, PacketSenderWithSharedPool};
-use arbitrary_int::traits::Integer as _;
 use arbitrary_int::u14;
 use spacepackets::SpHeader;
 use spacepackets::ecss::tm::{PusTmCreator, PusTmSecondaryHeader};
@@ -79,7 +78,7 @@ impl<
            // the unchecked API here.
            let reply_header = SpHeader::new_for_unseg_tm(
                self.service_helper.verif_reporter().apid(),
-                u14::ZERO,
+                u14::new(0),
                0,
            );
            let tc_header = PusTmSecondaryHeader::new_simple(17, 2, time_stamp);
@@ -154,7 +153,6 @@ mod tests {
        PartialPusHandlingError, PusPacketHandlingError,
    };
    use crate::tmtc::PacketSenderWithSharedPool;
-    use arbitrary_int::traits::Integer as _;
    use arbitrary_int::u14;
    use delegate::delegate;
    use spacepackets::SpHeader;
@@ -291,7 +289,7 @@ 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, u14::ZERO, 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, CreatorConfig::default());
@@ -347,7 +345,7 @@ 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, u14::ZERO, 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, CreatorConfig::default());
@@ -369,7 +367,7 @@ 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, u14::ZERO, 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, CreatorConfig::default());
--- a/satrs/src/pus/verification.rs
+++ b/satrs/src/pus/verification.rs
@@ -20,15 +20,15 @@
 //!     VerificationReportingProvider, VerificationReporterConfig, VerificationReporter
 //! };
 //! use satrs::tmtc::{SharedStaticMemoryPool, PacketSenderWithSharedPool};
+//! use satrs::spacepackets::seq_count::SeqCountProviderSimple;
 //! use satrs::request::UniqueApidTargetId;
 //! use spacepackets::ecss::PusPacket;
 //! use spacepackets::SpHeader;
-//! use spacepackets::ecss::tc::{PusTcCreator, PusTcSecondaryHeader, CreatorConfig};
+//! use spacepackets::ecss::tc::{PusTcCreator, PusTcSecondaryHeader};
 //! use spacepackets::ecss::tm::PusTmReader;
-//! use arbitrary_int::u11;
 //!
 //! const EMPTY_STAMP: [u8; 7] = [0; 7];
-//! const TEST_APID: u11 = u11::new(0x02);
+//! const TEST_APID: u16 = 0x02;
 //! const TEST_COMPONENT_ID: UniqueApidTargetId = UniqueApidTargetId::new(TEST_APID, 0x05);
 //!
 //! let pool_cfg = StaticPoolConfig::new_from_subpool_cfg_tuples(
@@ -38,14 +38,14 @@
 //! let shared_tm_pool = SharedStaticMemoryPool::new(RwLock::new(tm_pool));
 //! let (verif_tx, verif_rx) = mpsc::sync_channel(10);
 //! let sender = PacketSenderWithSharedPool::new_with_shared_packet_pool(verif_tx, &shared_tm_pool);
-//! let cfg = VerificationReporterConfig::new(TEST_APID, 1, 2, 8);
+//! let cfg = VerificationReporterConfig::new(TEST_APID, 1, 2, 8).unwrap();
 //! let mut  reporter = VerificationReporter::new(TEST_COMPONENT_ID.id(), &cfg);
 //!
 //! let tc_header = PusTcSecondaryHeader::new_simple(17, 1);
 //! let pus_tc_0 = PusTcCreator::new_no_app_data(
 //!     SpHeader::new_from_apid(TEST_APID),
 //!     tc_header,
-//!     CreatorConfig::default()
+//!     true
 //! );
 //! let init_token = reporter.start_verification(&pus_tc_0);
 //!
@@ -82,6 +82,7 @@
 //! context involving multiple threads
 use crate::params::{Params, WritableToBeBytes};
 use crate::pus::{EcssTmSender, EcssTmtcError, source_buffer_large_enough};
+use arbitrary_int::traits::Integer as _;
 use arbitrary_int::{u3, u11, u14};
 use core::fmt::{Debug, Display, Formatter};
 use core::hash::{Hash, Hasher};
@@ -91,14 +92,13 @@ use core::mem::size_of;
 use delegate::delegate;
 #[cfg(feature = "serde")]
 use serde::{Deserialize, Serialize};
-use spacepackets::SpHeader;
 use spacepackets::ecss::tc::IsPusTelecommand;
 use spacepackets::ecss::tm::{PusTmCreator, PusTmSecondaryHeader};
 use spacepackets::ecss::{CreatorConfig, EcssEnumeration};
 use spacepackets::{ByteConversionError, CcsdsPacket, PacketId, PacketSequenceControl};
+use spacepackets::{MAX_APID, SpHeader};

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

 #[cfg(feature = "alloc")]
 pub use alloc_mod::*;
@@ -158,18 +158,16 @@ impl RequestId {
    }

    pub fn raw(&self) -> u32 {
-        ((self.version_number.value() as u32) << 29)
+        ((self.version_number.as_u32()) << 29)
            | ((self.packet_id.raw() as u32) << 16)
            | self.psc.raw() as u32
    }

-    #[inline]
-    pub const fn packet_id(&self) -> PacketId {
+    pub fn packet_id(&self) -> PacketId {
        self.packet_id
    }

-    #[inline]
-    pub const fn packet_seq_ctrl(&self) -> PacketSequenceControl {
+    pub fn packet_sequence_control(&self) -> PacketSequenceControl {
        self.psc
    }

@@ -835,7 +833,7 @@ impl VerificationReportCreator {

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

    use super::*;
@@ -856,13 +854,16 @@ pub mod alloc_mod {
            step_field_width: usize,
            fail_code_field_width: usize,
            max_fail_data_len: usize,
-        ) -> Self {
-            Self {
+        ) -> Option<Self> {
+            if apid > MAX_APID {
+                return None;
+            }
+            Some(Self {
                apid,
                step_field_width,
                fail_code_field_width,
                max_fail_data_len,
-            }
+            })
        }
    }

@@ -874,7 +875,7 @@ pub mod alloc_mod {
        fn modify_tm(&self, tm: &mut PusTmCreator);
    }

-    /// [VerificationHook] which does nothing. This is the default hook variant for
+    /// [VerificationHookProvider] which does nothing. This is the default hook variant for
    /// the [VerificationReporter], assuming that any necessary packet manipulation is performed by
    /// a centralized TM funnel or inlet.
    #[derive(Default, Copy, Clone)]
@@ -920,7 +921,7 @@ pub mod alloc_mod {
    }

    impl<VerificationHookInstance: VerificationHook> VerificationReporter<VerificationHookInstance> {
-        /// The provided [VerificationHook] can be used to modify a verification packet
+        /// The provided [VerificationHookProvider] can be used to modify a verification packet
        /// before it is sent.
        pub fn new_with_hook(
            owner_id: ComponentId,
@@ -1006,7 +1007,7 @@ pub mod alloc_mod {
                .acceptance_success(
                    source_data_buf.as_mut_slice(),
                    &token.request_id(),
-                    u14::ZERO,
+                    u14::new(0),
                    0,
                    time_stamp,
                )
@@ -1029,7 +1030,7 @@ pub mod alloc_mod {
                .acceptance_failure(
                    buf.as_mut_slice(),
                    &token.request_id(),
-                    u14::ZERO,
+                    u14::new(0),
                    0,
                    params,
                )
@@ -1054,7 +1055,7 @@ pub mod alloc_mod {
                .start_success(
                    buf.as_mut_slice(),
                    &token.request_id(),
-                    u14::ZERO,
+                    u14::new(0),
                    0,
                    time_stamp,
                )
@@ -1080,7 +1081,7 @@ pub mod alloc_mod {
                .start_failure(
                    buf.as_mut_slice(),
                    &token.request_id(),
-                    u14::ZERO,
+                    u14::new(0),
                    0,
                    params,
                )
@@ -1106,7 +1107,7 @@ pub mod alloc_mod {
                .step_success(
                    buf.as_mut_slice(),
                    &token.request_id(),
-                    u14::ZERO,
+                    u14::new(0),
                    0,
                    time_stamp,
                    step,
@@ -1130,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, u14::ZERO, 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))?;
@@ -1154,7 +1155,7 @@ pub mod alloc_mod {
                .completion_success(
                    buf.as_mut_slice(),
                    &token.request_id(),
-                    u14::ZERO,
+                    u14::new(0),
                    0,
                    time_stamp,
                )
@@ -1180,7 +1181,7 @@ pub mod alloc_mod {
                .completion_failure(
                    buf.as_mut_slice(),
                    &token.request_id(),
-                    u14::ZERO,
+                    u14::new(0),
                    0,
                    params,
                )
@@ -1333,7 +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::traits::Integer;
+    use arbitrary_int::u11;
    use core::cell::RefCell;
    use std::collections::VecDeque;

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

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

        fn acceptance_success(
@@ -1727,13 +1728,13 @@ pub mod tests {
    use crate::tmtc::{PacketSenderWithSharedPool, SharedPacketPool};
    use alloc::format;
    use alloc::string::ToString;
-    use arbitrary_int::traits::Integer;
    use arbitrary_int::{u11, u14};
    use spacepackets::ecss::tc::{PusTcCreator, PusTcReader, PusTcSecondaryHeader};
    use spacepackets::ecss::{
        CreatorConfig, EcssEnumU8, EcssEnumU16, EcssEnumU32, EcssEnumeration, PusError, PusPacket,
        WritablePusPacket,
    };
+    use spacepackets::seq_count::SequenceCounterSimple;
    use spacepackets::util::UnsignedEnum;
    use spacepackets::{ByteConversionError, SpHeader};
    use std::cell::RefCell;
@@ -1743,8 +1744,8 @@ pub mod tests {
    use std::vec::Vec;

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

@@ -1832,7 +1833,7 @@ pub mod tests {
    }

    fn base_reporter(id: ComponentId, max_fail_data_len: usize) -> VerificationReporter {
-        let cfg = VerificationReporterConfig::new(TEST_APID, 1, 2, max_fail_data_len);
+        let cfg = VerificationReporterConfig::new(TEST_APID, 1, 2, max_fail_data_len).unwrap();
        VerificationReporter::new(id, &cfg)
    }

@@ -1840,7 +1841,7 @@ pub mod tests {
        id: ComponentId,
        hook: VerificationHookInstance,
    ) -> VerificationReporter<VerificationHookInstance> {
-        let cfg = VerificationReporterConfig::new(TEST_APID, 1, 2, 8);
+        let cfg = VerificationReporterConfig::new(TEST_APID, 1, 2, 8).unwrap();
        VerificationReporter::new_with_hook(id, &cfg, hook)
    }

@@ -1942,7 +1943,7 @@ pub mod tests {
                common: CommonTmInfo::new(
                    1,
                    TEST_APID,
-                    u14::ZERO,
+                    u14::new(0),
                    0,
                    self.reporter.dest_id(),
                    timestamp,
@@ -2009,7 +2010,7 @@ pub mod tests {
                common: CommonTmInfo::new(
                    2,
                    TEST_APID,
-                    u14::ZERO,
+                    u14::new(0),
                    0,
                    self.reporter.dest_id(),
                    timestamp,
@@ -2274,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(u14::ZERO, 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);
    }
@@ -2308,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(u14::ZERO, 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);
    }
@@ -2330,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(u14::ZERO, 0, DUMMY_STAMP);
+        testbench.check_start_success(u14::new(0), 0, DUMMY_STAMP);

        testbench.check_completion_failure(&fail_code, &[]);
    }
@@ -2350,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(u14::ZERO, 0, DUMMY_STAMP);
-        testbench.check_completion_success(u14::ZERO, 0);
+        testbench.check_start_success(u14::new(0), 0, DUMMY_STAMP);
+        testbench.check_completion_success(u14::new(0), 0);
    }

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

--- a/satrs/src/request.rs
+++ b/satrs/src/request.rs
@@ -1,4 +1,4 @@
-use arbitrary_int::u11;
+use arbitrary_int::{traits::Integer as _, u11};
 use core::{fmt, marker::PhantomData};
 #[cfg(feature = "serde")]
 use serde::{Deserialize, Serialize};
@@ -23,7 +23,7 @@ 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.
+/// 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)]
@@ -41,7 +41,7 @@ impl UniqueApidTargetId {
    }

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

    pub fn id(&self) -> ComponentId {
@@ -496,6 +496,10 @@ pub mod std_mod {
 mod tests {
    use std::sync::mpsc;

+    use crate::{
+        queue::{GenericReceiveError, GenericSendError},
+        request::{MessageMetadata, MessageSenderMap, MessageSenderStoreProvider},
+    };
    use alloc::string::ToString;
    use arbitrary_int::{u11, u14};
    use spacepackets::{
@@ -506,11 +510,6 @@ mod tests {
        },
    };

-    use crate::{
-        queue::{GenericReceiveError, GenericSendError},
-        request::{Apid, MessageMetadata, MessageSenderMap, MessageSenderStoreProvider},
-    };
-
    use super::{GenericMessage, MessageReceiverWithId, UniqueApidTargetId};

    const TEST_CHANNEL_ID_0: u64 = 1;
@@ -519,7 +518,7 @@ mod tests {

    #[test]
    fn test_basic_target_id_with_apid() {
-        let id = UniqueApidTargetId::new(Apid::new(0x111), 0x01);
+        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());
--- a/satrs/src/tmtc/tm_helper.rs
+++ b/satrs/src/tmtc/tm_helper.rs
@@ -62,10 +62,9 @@ impl PusTmWithCdsShortHelper {

 #[cfg(test)]
 mod tests {
-    use arbitrary_int::{u11, u14};
    use spacepackets::{CcsdsPacket, ecss::PusPacket, time::cds::CdsTime};

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

    #[test]
    fn test_helper_with_stamper() {
--- a/satrs/tests/pus_events.rs
+++ b/satrs/tests/pus_events.rs
@@ -36,7 +36,8 @@ fn test_threaded_usage() {
    event_man.subscribe_all(pus_event_man_send_provider.target_id());
    event_man.add_sender(pus_event_man_send_provider);
    let (event_packet_tx, event_packet_rx) = mpsc::channel::<PacketAsVec>();
-    let reporter = EventReporter::new(TEST_ID.raw(), u11::new(0x02), 0, 128);
+    let reporter = EventReporter::new(TEST_ID.raw(), u11::new(0x02), 0, 128)
+        .expect("Creating event reporter failed");
    let pus_event_man =
        PusEventTmCreatorWithMap::new(reporter, DefaultPusEventReportingMap::default());
    let error_handler = |event_msg: &EventMessageU32, error: EventRoutingError| {
--- a/satrs/tests/pus_verification.rs
+++ b/satrs/tests/pus_verification.rs
@@ -33,7 +33,7 @@ pub mod crossbeam_test {
        // We use a synced sequence count provider here because both verification reporters have the
        // the same APID. If they had distinct APIDs, the more correct approach would be to have
        // each reporter have an own sequence count provider.
-        let cfg = VerificationReporterConfig::new(TEST_APID, 1, 2, 8);
+        let cfg = VerificationReporterConfig::new(TEST_APID, 1, 2, 8).unwrap();
        // Shared pool object to store the verification PUS telemetry
        let pool_cfg = StaticPoolConfig::new_from_subpool_cfg_tuples(
            vec![(10, 32), (10, 64), (10, 128), (10, 1024)],
--- a/satrs/tests/tcp_servers.rs
+++ b/satrs/tests/tcp_servers.rs
@@ -21,7 +21,7 @@ use std::{
    thread,
 };

-use arbitrary_int::{u11, u14};
+use arbitrary_int::{traits::Integer, u11, u14};
 use hashbrown::HashSet;
 use satrs::{
    ComponentId,
@@ -268,7 +268,7 @@ fn test_ccsds_server() {
        .expect("setting reas timeout failed");

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