re-worked TMTC modules

.github/workflows/ci.yml

@@ -1,64 +0,0 @@
-name: ci
-on: [push, pull_request]
-
-jobs:
-  check:
-    name: Check build
-    strategy:
-      matrix:
-        os: [ubuntu-latest, macos-latest, windows-latest]
-    runs-on: ${{ matrix.os }}
-    steps:
-      - uses: actions/checkout@v4
-      - uses: dtolnay/rust-toolchain@stable
-      - run: cargo check --release
-
-  test:
-    name: Run Tests
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-      - uses: dtolnay/rust-toolchain@stable
-      - name: Install nextest
-        uses: taiki-e/install-action@nextest
-      - run: cargo nextest run --all-features
-      - run: cargo test --doc
-
-  cross-check:
-    name: Check Cross-Compilation
-    runs-on: ubuntu-latest
-    strategy:
-      matrix:
-        target:
-          - armv7-unknown-linux-gnueabihf
-          - thumbv7em-none-eabihf
-    steps:
-      - uses: actions/checkout@v4
-      - uses: dtolnay/rust-toolchain@stable
-        with:
-          targets: "armv7-unknown-linux-gnueabihf, thumbv7em-none-eabihf"
-      - run: cargo check -p satrs --release --target=${{matrix.target}} --no-default-features
-
-  fmt:
-    name: Check formatting
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-      - uses: dtolnay/rust-toolchain@stable
-      - run: cargo fmt --all -- --check
-
-  docs:
-    name: Check Documentation Build
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-      - uses: dtolnay/rust-toolchain@nightly
-      - run: cargo +nightly doc --all-features --config 'build.rustdocflags=["--cfg", "docs_rs"]'
-
-  clippy:
-    name: Clippy
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-      - uses: dtolnay/rust-toolchain@stable
-      - run: cargo clippy -- -D warnings

automation/Jenkinsfile

@@ -33,7 +33,6 @@ pipeline {
     stage('Test') {
       steps {
         sh 'cargo nextest r --all-features'
-        sh 'cargo test --doc'
       }
     }
     stage('Check with all features') {

satrs-book/src/events.md

@@ -1,17 +1,14 @@
 # Events
 
-Events are an important mechanism used for remote systems to monitor unexpected
-or expected anomalies and events occuring on these systems. 
-
-One common use case for events on remote systems is to offer a light-weight publish-subscribe
-mechanism and IPC mechanism for software and hardware events which are also packaged as telemetry
-(TM) or can trigger a system response. They can also be tied to
+Events can be an extremely important mechanism used for remote systems to monitor unexpected
+or expected anomalies and events occuring on these systems. They are oftentimes tied to
 Fault Detection, Isolation and Recovery (FDIR) operations, which need to happen autonomously.
 
-The PUS Service 5 standardizes how the ground interface for events might look like, but does not
-specify how other software components might react to those events. There is the PUS Service 19,
-which might be used for that purpose, but the event components recommended by this framework do not
-rely on the present of this service.
+Events can also be used as a convenient Inter-Process Communication (IPC) mechansism, which is
+also observable for the Ground segment. The PUS Service 5 standardizes how the ground interface
+for events might look like, but does not specify how other software components might react
+to those events. There is the PUS Service 19, which might be used for that purpose, but the
+event components recommended by this framework do not really need this service.
 
 The following images shows how the flow of events could look like in a system where components
 can generate events, and where other system components might be interested in those events:

satrs-example/satrs-tmtc/common.py

@@ -10,7 +10,6 @@ class Apid(enum.IntEnum):
     GENERIC_PUS = 2
     ACS = 3
     CFDP = 4
-    TMTC = 5
 
 
 class EventSeverity(enum.IntEnum):

satrs-example/satrs-tmtc/main.py

@@ -103,9 +103,7 @@ class PusHandler(GenericApidHandlerBase):
 
     def handle_tm(self, apid: int, packet: bytes, _user_args: Any):
         try:
-            pus_tm = PusTelemetry.unpack(
-                packet, timestamp_len=CdsShortTimestamp.TIMESTAMP_SIZE
-            )
+            pus_tm = PusTelemetry.unpack(packet, time_reader=CdsShortTimestamp.empty())
         except ValueError as e:
             _LOGGER.warning("Could not generate PUS TM object from raw data")
             _LOGGER.warning(f"Raw Packet: [{packet.hex(sep=',')}], REPR: {packet!r}")
@@ -113,7 +111,7 @@ class PusHandler(GenericApidHandlerBase):
         service = pus_tm.service
         if service == 1:
             tm_packet = Service1Tm.unpack(
-                data=packet, params=UnpackParams(CdsShortTimestamp.TIMESTAMP_SIZE, 1, 2)
+                data=packet, params=UnpackParams(CdsShortTimestamp.empty(), 1, 2)
             )
             res = self.verif_wrapper.add_tm(tm_packet)
             if res is None:
@@ -130,9 +128,7 @@ class PusHandler(GenericApidHandlerBase):
         elif service == 3:
             _LOGGER.info("No handling for HK packets implemented")
             _LOGGER.info(f"Raw packet: 0x[{packet.hex(sep=',')}]")
-            pus_tm = PusTelemetry.unpack(
-                packet, timestamp_len=CdsShortTimestamp.TIMESTAMP_SIZE
-            )
+            pus_tm = PusTelemetry.unpack(packet, time_reader=CdsShortTimestamp.empty())
             if pus_tm.subservice == 25:
                 if len(pus_tm.source_data) < 8:
                     raise ValueError("No addressable ID in HK packet")
@@ -140,18 +136,16 @@ class PusHandler(GenericApidHandlerBase):
                 _LOGGER.info(json_str)
         elif service == 5:
             tm_packet = PusTelemetry.unpack(
-                packet, timestamp_len=CdsShortTimestamp.TIMESTAMP_SIZE
+                packet, time_reader=CdsShortTimestamp.empty()
             )
             src_data = tm_packet.source_data
             event_u32 = EventU32.unpack(src_data)
-            _LOGGER.info(
-                f"Received event packet. Source APID: {Apid(tm_packet.apid)!r}, Event: {event_u32}"
-            )
+            _LOGGER.info(f"Received event packet. Event: {event_u32}")
             if event_u32.group_id == 0 and event_u32.unique_id == 0:
                 _LOGGER.info("Received test event")
         elif service == 17:
             tm_packet = Service17Tm.unpack(
-                packet, timestamp_len=CdsShortTimestamp.TIMESTAMP_SIZE
+                packet, time_reader=CdsShortTimestamp.empty()
             )
             if tm_packet.subservice == 2:
                 self.file_logger.info("Received Ping Reply TM[17,2]")
@@ -168,7 +162,7 @@ class PusHandler(GenericApidHandlerBase):
                 f"The service {service} is not implemented in Telemetry Factory"
             )
             tm_packet = PusTelemetry.unpack(
-                packet, timestamp_len=CdsShortTimestamp.TIMESTAMP_SIZE
+                packet, time_reader=CdsShortTimestamp.empty()
             )
         self.raw_logger.log_tm(pus_tm)
 
@@ -203,15 +197,15 @@ class TcHandler(TcHandlerBase):
             _LOGGER.info(log_entry.log_str)
 
     def queue_finished_cb(self, info: ProcedureWrapper):
-        if info.proc_type == TcProcedureType.TREE_COMMANDING:
-            def_proc = info.to_tree_commanding_procedure()
+        if info.proc_type == TcProcedureType.DEFAULT:
+            def_proc = info.to_def_procedure()
             _LOGGER.info(f"Queue handling finished for command {def_proc.cmd_path}")
 
     def feed_cb(self, info: ProcedureWrapper, wrapper: FeedWrapper):
         q = self.queue_helper
         q.queue_wrapper = wrapper.queue_wrapper
-        if info.proc_type == TcProcedureType.TREE_COMMANDING:
-            def_proc = info.to_tree_commanding_procedure()
+        if info.proc_type == TcProcedureType.DEFAULT:
+            def_proc = info.to_def_procedure()
             assert def_proc.cmd_path is not None
             pus_tc.pack_pus_telecommands(q, def_proc.cmd_path)
 
@@ -262,7 +256,6 @@ def main():
         while True:
             state = tmtc_backend.periodic_op(None)
             if state.request == BackendRequest.TERMINATION_NO_ERROR:
-                tmtc_backend.close_com_if()
                 sys.exit(0)
             elif state.request == BackendRequest.DELAY_IDLE:
                 _LOGGER.info("TMTC Client in IDLE mode")
@@ -277,7 +270,6 @@ def main():
             elif state.request == BackendRequest.CALL_NEXT:
                 pass
     except KeyboardInterrupt:
-        tmtc_backend.close_com_if()
         sys.exit(0)
 
 

satrs-example/satrs-tmtc/requirements.txt

@@ -1,2 +1,2 @@
-tmtccmd == 8.0.0rc2
+tmtccmd == 8.0.0rc1
 # -e git+https://github.com/robamu-org/tmtccmd@97e5e51101a08b21472b3ddecc2063359f7e307a#egg=tmtccmd

satrs-example/src/config.rs

@@ -38,7 +38,8 @@ pub enum GroupId {
 pub const OBSW_SERVER_ADDR: Ipv4Addr = Ipv4Addr::UNSPECIFIED;
 pub const SERVER_PORT: u16 = 7301;
 
-pub const TEST_EVENT: EventU32TypedSev<SeverityInfo> = EventU32TypedSev::<SeverityInfo>::new(0, 0);
+pub const TEST_EVENT: EventU32TypedSev<SeverityInfo> =
+    EventU32TypedSev::<SeverityInfo>::const_new(0, 0);
 
 lazy_static! {
     pub static ref PACKET_ID_VALIDATOR: HashSet<PacketId> = {

satrs-example/src/events.rs

@@ -2,15 +2,19 @@ use std::sync::mpsc::{self};
 
 use crate::pus::create_verification_reporter;
 use satrs::event_man::{EventMessageU32, EventRoutingError};
+use satrs::params::WritableToBeBytes;
 use satrs::pus::event::EventTmHookProvider;
 use satrs::pus::verification::VerificationReporter;
 use satrs::pus::EcssTmSender;
 use satrs::request::UniqueApidTargetId;
 use satrs::{
-    event_man::{EventManagerWithBoundedMpsc, EventSendProvider, EventU32SenderMpscBounded},
+    event_man::{
+        EventManagerWithBoundedMpsc, EventSendProvider, EventU32SenderMpscBounded,
+        MpscEventReceiver,
+    },
     pus::{
         event_man::{
-            DefaultPusEventU32TmCreator, EventReporter, EventRequest, EventRequestWithToken,
+            DefaultPusEventU32Dispatcher, EventReporter, EventRequest, EventRequestWithToken,
         },
         verification::{TcStateStarted, VerificationReportingProvider, VerificationToken},
     },
@@ -36,13 +40,13 @@ impl EventTmHookProvider for EventApidSetter {
 /// packets. It also handles the verification completion of PUS event service requests.
 pub struct PusEventHandler<TmSender: EcssTmSender> {
     event_request_rx: mpsc::Receiver<EventRequestWithToken>,
-    pus_event_tm_creator: DefaultPusEventU32TmCreator<EventApidSetter>,
+    pus_event_dispatcher: DefaultPusEventU32Dispatcher<()>,
     pus_event_man_rx: mpsc::Receiver<EventMessageU32>,
     tm_sender: TmSender,
     time_provider: CdsTime,
     timestamp: [u8; 7],
-    small_data_buf: [u8; 64],
     verif_handler: VerificationReporter,
+    event_apid_setter: EventApidSetter,
 }
 
 impl<TmSender: EcssTmSender> PusEventHandler<TmSender> {
@@ -57,16 +61,9 @@ impl<TmSender: EcssTmSender> PusEventHandler<TmSender> {
 
         // All events sent to the manager are routed to the PUS event manager, which generates PUS event
         // telemetry for each event.
-        let event_reporter = EventReporter::new_with_hook(
-            PUS_EVENT_MANAGEMENT.raw(),
-            0,
-            0,
-            128,
-            EventApidSetter::default(),
-        )
-        .unwrap();
+        let event_reporter = EventReporter::new(PUS_EVENT_MANAGEMENT.raw(), 0, 0, 128).unwrap();
         let pus_event_dispatcher =
-            DefaultPusEventU32TmCreator::new_with_default_backend(event_reporter);
+            DefaultPusEventU32Dispatcher::new_with_default_backend(event_reporter);
         let pus_event_man_send_provider = EventU32SenderMpscBounded::new(
             PUS_EVENT_MANAGEMENT.raw(),
             pus_event_man_tx,
@@ -78,13 +75,13 @@ impl<TmSender: EcssTmSender> PusEventHandler<TmSender> {
 
         Self {
             event_request_rx,
-            pus_event_tm_creator: pus_event_dispatcher,
+            pus_event_dispatcher,
             pus_event_man_rx,
             time_provider: CdsTime::new_with_u16_days(0, 0),
             timestamp: [0; 7],
-            small_data_buf: [0; 64],
             verif_handler,
             tm_sender,
+            event_apid_setter: EventApidSetter::default(),
         }
     }
 
@@ -98,110 +95,75 @@ impl<TmSender: EcssTmSender> PusEventHandler<TmSender> {
                 .completion_success(&self.tm_sender, started_token, timestamp)
                 .expect("Sending completion success failed");
         };
-        loop {
-            // handle event requests
-            match self.event_request_rx.try_recv() {
-                Ok(event_req) => match event_req.request {
-                    EventRequest::Enable(event) => {
-                        self.pus_event_tm_creator
-                            .enable_tm_for_event(&event)
-                            .expect("Enabling TM failed");
-                        update_time(&mut self.time_provider, &mut self.timestamp);
-                        report_completion(event_req, &self.timestamp);
-                    }
-                    EventRequest::Disable(event) => {
-                        self.pus_event_tm_creator
-                            .disable_tm_for_event(&event)
-                            .expect("Disabling TM failed");
-                        update_time(&mut self.time_provider, &mut self.timestamp);
-                        report_completion(event_req, &self.timestamp);
-                    }
-                },
-                Err(e) => match e {
-                    mpsc::TryRecvError::Empty => break,
-                    mpsc::TryRecvError::Disconnected => {
-                        log::warn!("all event request senders have disconnected");
-                        break;
-                    }
-                },
+        // handle event requests
+        if let Ok(event_req) = self.event_request_rx.try_recv() {
+            match event_req.request {
+                EventRequest::Enable(event) => {
+                    self.pus_event_dispatcher
+                        .enable_tm_for_event(&event)
+                        .expect("Enabling TM failed");
+                    update_time(&mut self.time_provider, &mut self.timestamp);
+                    report_completion(event_req, &self.timestamp);
+                }
+                EventRequest::Disable(event) => {
+                    self.pus_event_dispatcher
+                        .disable_tm_for_event(&event)
+                        .expect("Disabling TM failed");
+                    update_time(&mut self.time_provider, &mut self.timestamp);
+                    report_completion(event_req, &self.timestamp);
+                }
             }
         }
     }
 
     pub fn generate_pus_event_tm(&mut self) {
-        loop {
-            // Perform the generation of PUS event packets
-            match self.pus_event_man_rx.try_recv() {
-                Ok(event_msg) => {
-                    // We use the TM modification hook to set the sender APID for each event.
-                    self.pus_event_tm_creator.reporter.tm_hook.next_apid =
-                        UniqueApidTargetId::from(event_msg.sender_id()).apid;
-                    update_time(&mut self.time_provider, &mut self.timestamp);
-                    let generation_result = self
-                        .pus_event_tm_creator
-                        .generate_pus_event_tm_generic_with_generic_params(
-                            &self.tm_sender,
-                            &self.timestamp,
-                            event_msg.event(),
-                            &mut self.small_data_buf,
-                            event_msg.params(),
-                        )
-                        .expect("Sending TM as event failed");
-                    if !generation_result.params_were_propagated {
-                        log::warn!(
-                            "Event TM parameters were not propagated: {:?}",
-                            event_msg.params()
-                        );
-                    }
-                }
-                Err(e) => match e {
-                    mpsc::TryRecvError::Empty => break,
-                    mpsc::TryRecvError::Disconnected => {
-                        log::warn!("All event senders have disconnected");
-                        break;
-                    }
-                },
-            }
+        // Perform the generation of PUS event packets
+        if let Ok(event_msg) = self.pus_event_man_rx.try_recv() {
+            update_time(&mut self.time_provider, &mut self.timestamp);
+            let param_vec = event_msg.params().map_or(Vec::new(), |param| {
+                param.to_vec().expect("failed to convert params to vec")
+            });
+            self.event_apid_setter.next_apid = UniqueApidTargetId::from(event_msg.sender_id()).apid;
+            self.pus_event_dispatcher
+                .generate_pus_event_tm_generic(
+                    &self.tm_sender,
+                    &self.timestamp,
+                    event_msg.event(),
+                    Some(&param_vec),
+                )
+                .expect("Sending TM as event failed");
         }
     }
 }
 
-pub struct EventHandler<TmSender: EcssTmSender> {
-    pub pus_event_handler: PusEventHandler<TmSender>,
+/// This is a thin wrapper around the event manager which also caches the sender component
+/// used to send events to the event manager.
+pub struct EventManagerWrapper {
     event_manager: EventManagerWithBoundedMpsc,
+    event_sender: mpsc::Sender<EventMessageU32>,
 }
 
-impl<TmSender: EcssTmSender> EventHandler<TmSender> {
-    pub fn new(
-        tm_sender: TmSender,
-        event_rx: mpsc::Receiver<EventMessageU32>,
-        event_request_rx: mpsc::Receiver<EventRequestWithToken>,
-    ) -> Self {
-        let mut event_manager = EventManagerWithBoundedMpsc::new(event_rx);
-        let pus_event_handler = PusEventHandler::new(
-            tm_sender,
-            create_verification_reporter(PUS_EVENT_MANAGEMENT.id(), PUS_EVENT_MANAGEMENT.apid),
-            &mut event_manager,
-            event_request_rx,
-        );
-
+impl EventManagerWrapper {
+    pub fn new() -> Self {
+        // The sender handle is the primary sender handle for all components which want to create events.
+        // The event manager will receive the RX handle to receive all the events.
+        let (event_sender, event_man_rx) = mpsc::channel();
+        let event_recv = MpscEventReceiver::new(event_man_rx);
         Self {
-            pus_event_handler,
-            event_manager,
+            event_manager: EventManagerWithBoundedMpsc::new(event_recv),
+            event_sender,
         }
     }
 
-    #[allow(dead_code)]
+    // Returns a cached event sender to send events to the event manager for routing.
+    pub fn clone_event_sender(&self) -> mpsc::Sender<EventMessageU32> {
+        self.event_sender.clone()
+    }
+
     pub fn event_manager(&mut self) -> &mut EventManagerWithBoundedMpsc {
         &mut self.event_manager
     }
 
-    pub fn periodic_operation(&mut self) {
-        self.pus_event_handler.handle_event_requests();
-        self.try_event_routing();
-        self.pus_event_handler.generate_pus_event_tm();
-    }
-
     pub fn try_event_routing(&mut self) {
         let error_handler = |event_msg: &EventMessageU32, error: EventRoutingError| {
             self.routing_error_handler(event_msg, error)
@@ -215,83 +177,41 @@ impl<TmSender: EcssTmSender> EventHandler<TmSender> {
     }
 }
 
-#[cfg(test)]
-mod tests {
-    use satrs::{
-        events::EventU32,
-        pus::verification::VerificationReporterCfg,
-        spacepackets::{
-            ecss::{tm::PusTmReader, PusPacket},
-            CcsdsPacket,
-        },
-        tmtc::PacketAsVec,
-    };
+pub struct EventHandler<TmSender: EcssTmSender> {
+    pub event_man_wrapper: EventManagerWrapper,
+    pub pus_event_handler: PusEventHandler<TmSender>,
+}
 
-    use super::*;
-
-    const TEST_CREATOR_ID: UniqueApidTargetId = UniqueApidTargetId::new(1, 2);
-    const TEST_EVENT: EventU32 = EventU32::new(satrs::events::Severity::Info, 1, 1);
-
-    pub struct EventManagementTestbench {
-        pub event_tx: mpsc::SyncSender<EventMessageU32>,
-        pub event_manager: EventManagerWithBoundedMpsc,
-        pub tm_receiver: mpsc::Receiver<PacketAsVec>,
-        pub pus_event_handler: PusEventHandler<mpsc::Sender<PacketAsVec>>,
-    }
-
-    impl EventManagementTestbench {
-        pub fn new() -> Self {
-            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 = VerificationReporterCfg::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);
-            let pus_event_handler = PusEventHandler::<mpsc::Sender<PacketAsVec>>::new(
-                tm_sender,
-                verif_reporter,
-                &mut event_manager,
-                event_req_rx,
-            );
-            Self {
-                event_tx,
-                tm_receiver,
-                event_manager,
-                pus_event_handler,
-            }
+impl<TmSender: EcssTmSender> EventHandler<TmSender> {
+    pub fn new(
+        tm_sender: TmSender,
+        event_request_rx: mpsc::Receiver<EventRequestWithToken>,
+    ) -> Self {
+        let mut event_man_wrapper = EventManagerWrapper::new();
+        let pus_event_handler = PusEventHandler::new(
+            tm_sender,
+            create_verification_reporter(PUS_EVENT_MANAGEMENT.id(), PUS_EVENT_MANAGEMENT.apid),
+            event_man_wrapper.event_manager(),
+            event_request_rx,
+        );
+        Self {
+            event_man_wrapper,
+            pus_event_handler,
         }
     }
 
-    #[test]
-    fn test_basic_event_generation() {
-        let mut testbench = EventManagementTestbench::new();
-        testbench
-            .event_tx
-            .send(EventMessageU32::new(
-                TEST_CREATOR_ID.id(),
-                EventU32::new(satrs::events::Severity::Info, 1, 1),
-            ))
-            .expect("failed to send event");
-        testbench.pus_event_handler.handle_event_requests();
-        testbench.event_manager.try_event_handling(|_, _| {});
-        testbench.pus_event_handler.generate_pus_event_tm();
-        let tm_packet = testbench
-            .tm_receiver
-            .try_recv()
-            .expect("failed to receive TM packet");
-        assert_eq!(tm_packet.sender_id, PUS_EVENT_MANAGEMENT.id());
-        let tm_reader = PusTmReader::new(&tm_packet.packet, 7)
-            .expect("failed to create TM reader")
-            .0;
-        assert_eq!(tm_reader.apid(), TEST_CREATOR_ID.apid);
-        assert_eq!(tm_reader.user_data().len(), 4);
-        let event_read_back = EventU32::from_be_bytes(tm_reader.user_data().try_into().unwrap());
-        assert_eq!(event_read_back, TEST_EVENT);
+    pub fn clone_event_sender(&self) -> mpsc::Sender<EventMessageU32> {
+        self.event_man_wrapper.clone_event_sender()
     }
 
-    #[test]
-    fn test_basic_event_disabled() {
-        // TODO: Add test.
+    #[allow(dead_code)]
+    pub fn event_manager(&mut self) -> &mut EventManagerWithBoundedMpsc {
+        self.event_man_wrapper.event_manager()
+    }
+
+    pub fn periodic_operation(&mut self) {
+        self.pus_event_handler.handle_event_requests();
+        self.event_man_wrapper.try_event_routing();
+        self.pus_event_handler.generate_pus_event_tm();
     }
 }

satrs-example/src/interface/tcp.rs

@@ -1,4 +1,3 @@
-use std::time::Duration;
 use std::{
     collections::{HashSet, VecDeque},
     fmt::Debug,
@@ -8,35 +7,14 @@ use std::{
 
 use log::{info, warn};
 use satrs::{
-    encoding::ccsds::{SpValidity, SpacePacketValidator},
     hal::std::tcp_server::{HandledConnectionHandler, ServerConfig, TcpSpacepacketsServer},
-    spacepackets::{CcsdsPacket, PacketId},
+    spacepackets::PacketId,
     tmtc::{PacketSenderRaw, PacketSource},
 };
 
 #[derive(Default)]
 pub struct ConnectionFinishedHandler {}
 
-pub struct SimplePacketValidator {
-    pub valid_ids: HashSet<PacketId>,
-}
-
-impl SpacePacketValidator for SimplePacketValidator {
-    fn validate(
-        &self,
-        sp_header: &satrs::spacepackets::SpHeader,
-        _raw_buf: &[u8],
-    ) -> satrs::encoding::ccsds::SpValidity {
-        if self.valid_ids.contains(&sp_header.packet_id()) {
-            return SpValidity::Valid;
-        }
-        log::warn!("ignoring space packet with header {:?}", sp_header);
-        // We could perform a CRC check.. but lets keep this simple and assume that TCP ensures
-        // data integrity.
-        SpValidity::Skip
-    }
-}
-
 impl HandledConnectionHandler for ConnectionFinishedHandler {
     fn handled_connection(&mut self, info: satrs::hal::std::tcp_server::HandledConnectionInfo) {
         info!(
@@ -105,7 +83,7 @@ impl PacketSource for SyncTcpTmSource {
 pub type TcpServer<ReceivesTc, SendError> = TcpSpacepacketsServer<
     SyncTcpTmSource,
     ReceivesTc,
-    SimplePacketValidator,
+    HashSet<PacketId>,
     ConnectionFinishedHandler,
     (),
     SendError,
@@ -123,14 +101,14 @@ impl<TcSender: PacketSenderRaw<Error = SendError>, SendError: Debug + 'static>
         cfg: ServerConfig,
         tm_source: SyncTcpTmSource,
         tc_sender: TcSender,
-        valid_ids: HashSet<PacketId>,
+        packet_id_lookup: HashSet<PacketId>,
     ) -> Result<Self, std::io::Error> {
         Ok(Self(
             TcpSpacepacketsServer::new(
                 cfg,
                 tm_source,
                 tc_sender,
-                SimplePacketValidator { valid_ids },
+                packet_id_lookup,
                 ConnectionFinishedHandler::default(),
                 None,
             )?,
@@ -140,9 +118,7 @@ impl<TcSender: PacketSenderRaw<Error = SendError>, SendError: Debug + 'static>
 
     pub fn periodic_operation(&mut self) {
         loop {
-            let result = self
-                .0
-                .handle_all_connections(Some(Duration::from_millis(400)));
+            let result = self.0.handle_next_connection(None);
             match result {
                 Ok(_conn_result) => (),
                 Err(e) => {

satrs-example/src/interface/udp.rs

@@ -3,13 +3,15 @@ use std::net::{SocketAddr, UdpSocket};
 use std::sync::mpsc;
 
 use log::{info, warn};
-use satrs::pus::HandlingStatus;
-use satrs::tmtc::{PacketAsVec, PacketInPool, PacketSenderRaw};
+use satrs::pus::{PacketAsVec, PacketInPool};
+use satrs::tmtc::PacketSenderRaw;
 use satrs::{
     hal::std::udp_server::{ReceiveResult, UdpTcServer},
     pool::{PoolProviderWithGuards, SharedStaticMemoryPool},
 };
 
+use crate::pus::HandlingStatus;
+
 pub trait UdpTmHandler {
     fn send_tm_to_udp_client(&mut self, socket: &UdpSocket, recv_addr: &SocketAddr);
 }
@@ -113,7 +115,6 @@ impl<
 
 #[cfg(test)]
 mod tests {
-    use std::net::Ipv4Addr;
     use std::{
         cell::RefCell,
         collections::VecDeque,
@@ -182,7 +183,7 @@ mod tests {
 
     #[test]
     fn test_transactions() {
-        let sock_addr = SocketAddr::new(IpAddr::V4(Ipv4Addr::LOCALHOST), 0);
+        let sock_addr = SocketAddr::new(IpAddr::V4(OBSW_SERVER_ADDR), 0);
         let test_receiver = TestSender::default();
         // let tc_queue = test_receiver.tc_vec.clone();
         let udp_tc_server =
@@ -200,8 +201,8 @@ mod tests {
             .unwrap();
         let client = UdpSocket::bind("127.0.0.1:0").expect("Connecting to UDP server failed");
         let client_addr = client.local_addr().unwrap();
-        println!("{}", server_addr);
-        client.send_to(&ping_tc, server_addr).unwrap();
+        client.connect(server_addr).unwrap();
+        client.send(&ping_tc).unwrap();
         udp_dyn_server.periodic_operation();
         {
             let mut queue = udp_dyn_server.udp_tc_server.tc_sender.tc_vec.borrow_mut();

satrs-example/src/main.rs

@@ -11,7 +11,7 @@ use crate::events::EventHandler;
 use crate::interface::udp::DynamicUdpTmHandler;
 use crate::pus::stack::PusStack;
 use crate::tmtc::tc_source::{TcSourceTaskDynamic, TcSourceTaskStatic};
-use crate::tmtc::tm_sink::{TmSinkDynamic, TmSinkStatic};
+use crate::tmtc::tm_sink::{TmFunnelDynamic, TmFunnelStatic};
 use log::info;
 use pus::test::create_test_service_dynamic;
 use satrs::hal::std::tcp_server::ServerConfig;
@@ -54,11 +54,11 @@ fn static_tmtc_pool_main() {
     let shared_tm_pool_wrapper = SharedPacketPool::new(&shared_tm_pool);
     let shared_tc_pool_wrapper = SharedPacketPool::new(&shared_tc_pool);
     let (tc_source_tx, tc_source_rx) = mpsc::sync_channel(50);
-    let (tm_sink_tx, tm_sink_rx) = mpsc::sync_channel(50);
+    let (tm_funnel_tx, tm_funnel_rx) = mpsc::sync_channel(50);
     let (tm_server_tx, tm_server_rx) = mpsc::sync_channel(50);
 
-    let tm_sink_tx_sender =
-        PacketSenderWithSharedPool::new(tm_sink_tx.clone(), shared_tm_pool_wrapper.clone());
+    let tm_funnel_tx_sender =
+        PacketSenderWithSharedPool::new(tm_funnel_tx.clone(), shared_tm_pool_wrapper.clone());
 
     let (mgm_handler_composite_tx, mgm_handler_composite_rx) =
         mpsc::channel::<GenericMessage<CompositeRequest>>();
@@ -80,12 +80,11 @@ fn static_tmtc_pool_main() {
     // Create event handling components
     // These sender handles are used to send event requests, for example to enable or disable
     // certain events.
-    let (event_tx, event_rx) = mpsc::sync_channel(100);
     let (event_request_tx, event_request_rx) = mpsc::channel::<EventRequestWithToken>();
 
     // The event task is the core handler to perform the event routing and TM handling as specified
     // in the sat-rs documentation.
-    let mut event_handler = EventHandler::new(tm_sink_tx.clone(), event_rx, event_request_rx);
+    let mut event_handler = EventHandler::new(tm_funnel_tx.clone(), event_request_rx);
 
     let (pus_test_tx, pus_test_rx) = mpsc::channel();
     let (pus_event_tx, pus_event_rx) = mpsc::channel();
@@ -107,39 +106,39 @@ fn static_tmtc_pool_main() {
         mode_tc_sender: pus_mode_tx,
     };
     let pus_test_service = create_test_service_static(
-        tm_sink_tx_sender.clone(),
+        tm_funnel_tx_sender.clone(),
         shared_tc_pool.clone(),
-        event_tx.clone(),
+        event_handler.clone_event_sender(),
         pus_test_rx,
     );
     let pus_scheduler_service = create_scheduler_service_static(
-        tm_sink_tx_sender.clone(),
+        tm_funnel_tx_sender.clone(),
         tc_source.clone(),
         pus_sched_rx,
         create_sched_tc_pool(),
     );
     let pus_event_service = create_event_service_static(
-        tm_sink_tx_sender.clone(),
+        tm_funnel_tx_sender.clone(),
         shared_tc_pool.clone(),
         pus_event_rx,
         event_request_tx,
     );
     let pus_action_service = create_action_service_static(
-        tm_sink_tx_sender.clone(),
+        tm_funnel_tx_sender.clone(),
         shared_tc_pool.clone(),
         pus_action_rx,
         request_map.clone(),
         pus_action_reply_rx,
     );
     let pus_hk_service = create_hk_service_static(
-        tm_sink_tx_sender.clone(),
+        tm_funnel_tx_sender.clone(),
         shared_tc_pool.clone(),
         pus_hk_rx,
         request_map.clone(),
         pus_hk_reply_rx,
     );
     let pus_mode_service = create_mode_service_static(
-        tm_sink_tx_sender.clone(),
+        tm_funnel_tx_sender.clone(),
         shared_tc_pool.clone(),
         pus_mode_rx,
         request_map,
@@ -157,7 +156,7 @@ fn static_tmtc_pool_main() {
     let mut tmtc_task = TcSourceTaskStatic::new(
         shared_tc_pool_wrapper.clone(),
         tc_source_rx,
-        PusTcDistributor::new(tm_sink_tx_sender, pus_router),
+        PusTcDistributor::new(tm_funnel_tx_sender, pus_router),
     );
 
     let sock_addr = SocketAddr::new(IpAddr::V4(OBSW_SERVER_ADDR), SERVER_PORT);
@@ -187,10 +186,10 @@ fn static_tmtc_pool_main() {
     )
     .expect("tcp server creation failed");
 
-    let mut tm_sink = TmSinkStatic::new(
+    let mut tm_funnel = TmFunnelStatic::new(
         shared_tm_pool_wrapper,
         sync_tm_tcp_source,
-        tm_sink_rx,
+        tm_funnel_rx,
         tm_server_tx,
     );
 
@@ -210,7 +209,7 @@ fn static_tmtc_pool_main() {
         mode_leaf_interface,
         mgm_handler_composite_rx,
         pus_hk_reply_tx,
-        tm_sink_tx,
+        tm_funnel_tx,
         dummy_spi_interface,
         shared_mgm_set,
     );
@@ -241,9 +240,9 @@ fn static_tmtc_pool_main() {
 
     info!("Starting TM funnel task");
     let jh_tm_funnel = thread::Builder::new()
-        .name("tm sink".to_string())
+        .name("TM Funnel".to_string())
         .spawn(move || loop {
-            tm_sink.operation();
+            tm_funnel.operation();
         })
         .unwrap();
 
@@ -315,11 +314,10 @@ fn dyn_tmtc_pool_main() {
     // Create event handling components
     // These sender handles are used to send event requests, for example to enable or disable
     // certain events.
-    let (event_tx, event_rx) = mpsc::sync_channel(100);
     let (event_request_tx, event_request_rx) = mpsc::channel::<EventRequestWithToken>();
     // The event task is the core handler to perform the event routing and TM handling as specified
     // in the sat-rs documentation.
-    let mut event_handler = EventHandler::new(tm_funnel_tx.clone(), event_rx, event_request_rx);
+    let mut event_handler = EventHandler::new(tm_funnel_tx.clone(), event_request_rx);
 
     let (pus_test_tx, pus_test_rx) = mpsc::channel();
     let (pus_event_tx, pus_event_rx) = mpsc::channel();
@@ -341,8 +339,11 @@ fn dyn_tmtc_pool_main() {
         mode_tc_sender: pus_mode_tx,
     };
 
-    let pus_test_service =
-        create_test_service_dynamic(tm_funnel_tx.clone(), event_tx.clone(), pus_test_rx);
+    let pus_test_service = create_test_service_dynamic(
+        tm_funnel_tx.clone(),
+        event_handler.clone_event_sender(),
+        pus_test_rx,
+    );
     let pus_scheduler_service = create_scheduler_service_dynamic(
         tm_funnel_tx.clone(),
         tc_source_tx.clone(),
@@ -410,7 +411,7 @@ fn dyn_tmtc_pool_main() {
     )
     .expect("tcp server creation failed");
 
-    let mut tm_funnel = TmSinkDynamic::new(sync_tm_tcp_source, tm_funnel_rx, tm_server_tx);
+    let mut tm_funnel = TmFunnelDynamic::new(sync_tm_tcp_source, tm_funnel_rx, tm_server_tx);
 
     let (mgm_handler_mode_reply_to_parent_tx, _mgm_handler_mode_reply_to_parent_rx) =
         mpsc::channel();
@@ -458,7 +459,7 @@ fn dyn_tmtc_pool_main() {
 
     info!("Starting TM funnel task");
     let jh_tm_funnel = thread::Builder::new()
-        .name("sat-rs tm-sink".to_string())
+        .name("sat-rs tm-funnel".to_string())
         .spawn(move || loop {
             tm_funnel.operation();
         })

satrs-example/src/pus/action.rs

@@ -1,24 +1,24 @@
-use log::warn;
+use log::{error, warn};
 use satrs::action::{ActionRequest, ActionRequestVariant};
+use satrs::params::WritableToBeBytes;
 use satrs::pool::SharedStaticMemoryPool;
 use satrs::pus::action::{
     ActionReplyPus, ActionReplyVariant, ActivePusActionRequestStd, DefaultActiveActionRequestMap,
 };
 use satrs::pus::verification::{
-    handle_completion_failure_with_generic_params, handle_step_failure_with_generic_params,
-    FailParamHelper, FailParams, TcStateAccepted, TcStateStarted, VerificationReporter,
+    FailParams, FailParamsWithStep, TcStateAccepted, TcStateStarted, VerificationReporter,
     VerificationReportingProvider, VerificationToken,
 };
 use satrs::pus::{
     ActiveRequestProvider, EcssTcAndToken, EcssTcInMemConverter, EcssTcInSharedStoreConverter,
     EcssTcInVecConverter, EcssTmSender, EcssTmtcError, GenericConversionError, MpscTcReceiver,
-    MpscTmAsVecSender, PusPacketHandlingError, PusReplyHandler, PusServiceHelper,
+    MpscTmAsVecSender, PacketAsVec, PusPacketHandlerResult, PusReplyHandler, PusServiceHelper,
     PusTcToRequestConverter,
 };
 use satrs::request::{GenericMessage, UniqueApidTargetId};
 use satrs::spacepackets::ecss::tc::PusTcReader;
-use satrs::spacepackets::ecss::{EcssEnumU16, PusPacket, PusServiceId};
-use satrs::tmtc::{PacketAsVec, PacketSenderWithSharedPool};
+use satrs::spacepackets::ecss::{EcssEnumU16, PusPacket};
+use satrs::tmtc::PacketSenderWithSharedPool;
 use satrs_example::config::components::PUS_ACTION_SERVICE;
 use satrs_example::config::tmtc_err;
 use std::sync::mpsc;
@@ -61,7 +61,7 @@ impl PusReplyHandler<ActivePusActionRequestStd, ActionReplyPus> for ActionReplyH
         active_request: &ActivePusActionRequestStd,
         tm_sender: &(impl EcssTmSender + ?Sized),
         verification_handler: &impl VerificationReportingProvider,
-        timestamp: &[u8],
+        time_stamp: &[u8],
     ) -> Result<bool, Self::Error> {
         let verif_token: VerificationToken<TcStateStarted> = active_request
             .token()
@@ -69,23 +69,15 @@ impl PusReplyHandler<ActivePusActionRequestStd, ActionReplyPus> for ActionReplyH
             .expect("invalid token state");
         let remove_entry = match &reply.message.variant {
             ActionReplyVariant::CompletionFailed { error_code, params } => {
-                let error_propagated = handle_completion_failure_with_generic_params(
+                let mut fail_data_len = 0;
+                if let Some(params) = params {
+                    fail_data_len = params.write_to_be_bytes(&mut self.fail_data_buf)?;
+                }
+                verification_handler.completion_failure(
                     tm_sender,
                     verif_token,
-                    verification_handler,
-                    FailParamHelper {
-                        error_code,
-                        params: params.as_ref(),
-                        timestamp,
-                        small_data_buf: &mut self.fail_data_buf,
-                    },
+                    FailParams::new(time_stamp, error_code, &self.fail_data_buf[..fail_data_len]),
                 )?;
-                if !error_propagated {
-                    log::warn!(
-                        "error params for completion failure were not propated: {:?}",
-                        params.as_ref()
-                    );
-                }
                 true
             }
             ActionReplyVariant::StepFailed {
@@ -93,35 +85,31 @@ impl PusReplyHandler<ActivePusActionRequestStd, ActionReplyPus> for ActionReplyH
                 step,
                 params,
             } => {
-                let error_propagated = handle_step_failure_with_generic_params(
+                let mut fail_data_len = 0;
+                if let Some(params) = params {
+                    fail_data_len = params.write_to_be_bytes(&mut self.fail_data_buf)?;
+                }
+                verification_handler.step_failure(
                     tm_sender,
                     verif_token,
-                    verification_handler,
-                    FailParamHelper {
+                    FailParamsWithStep::new(
+                        time_stamp,
+                        &EcssEnumU16::new(*step),
                         error_code,
-                        params: params.as_ref(),
-                        timestamp,
-                        small_data_buf: &mut self.fail_data_buf,
-                    },
-                    &EcssEnumU16::new(*step),
+                        &self.fail_data_buf[..fail_data_len],
+                    ),
                 )?;
-                if !error_propagated {
-                    log::warn!(
-                        "error params for completion failure were not propated: {:?}",
-                        params.as_ref()
-                    );
-                }
                 true
             }
             ActionReplyVariant::Completed => {
-                verification_handler.completion_success(tm_sender, verif_token, timestamp)?;
+                verification_handler.completion_success(tm_sender, verif_token, time_stamp)?;
                 true
             }
             ActionReplyVariant::StepSuccess { step } => {
                 verification_handler.step_success(
                     tm_sender,
                     &verif_token,
-                    timestamp,
+                    time_stamp,
                     EcssEnumU16::new(*step),
                 )?;
                 false
@@ -278,23 +266,43 @@ pub struct ActionServiceWrapper<TmSender: EcssTmSender, TcInMemConverter: EcssTc
 impl<TmSender: EcssTmSender, TcInMemConverter: EcssTcInMemConverter> TargetedPusService
     for ActionServiceWrapper<TmSender, TcInMemConverter>
 {
-    const SERVICE_ID: u8 = PusServiceId::Action as u8;
-    const SERVICE_STR: &'static str = "action";
-
-    delegate::delegate! {
-        to self.service {
-            fn poll_and_handle_next_tc(
-                &mut self,
-                time_stamp: &[u8],
-            ) -> Result<HandlingStatus, PusPacketHandlingError>;
-
-            fn poll_and_handle_next_reply(
-                &mut self,
-                time_stamp: &[u8],
-            ) -> Result<HandlingStatus, EcssTmtcError>;
-
-            fn check_for_request_timeouts(&mut self);
+    /// Returns [true] if the packet handling is finished.
+    fn poll_and_handle_next_tc(&mut self, time_stamp: &[u8]) -> HandlingStatus {
+        match self.service.poll_and_handle_next_tc(time_stamp) {
+            Ok(result) => match result {
+                PusPacketHandlerResult::RequestHandled => {}
+                PusPacketHandlerResult::RequestHandledPartialSuccess(e) => {
+                    warn!("PUS 8 partial packet handling success: {e:?}")
+                }
+                PusPacketHandlerResult::CustomSubservice(invalid, _) => {
+                    warn!("PUS 8 invalid subservice {invalid}");
+                }
+                PusPacketHandlerResult::SubserviceNotImplemented(subservice, _) => {
+                    warn!("PUS 8 subservice {subservice} not implemented");
+                }
+                PusPacketHandlerResult::Empty => return HandlingStatus::Empty,
+            },
+            Err(error) => {
+                error!("PUS packet handling error: {error:?}");
+                // To avoid permanent loops on error cases.
+                return HandlingStatus::Empty;
+            }
         }
+        HandlingStatus::HandledOne
+    }
+
+    fn poll_and_handle_next_reply(&mut self, time_stamp: &[u8]) -> HandlingStatus {
+        // This only fails if all senders disconnected. Treat it like an empty queue.
+        self.service
+            .poll_and_check_next_reply(time_stamp)
+            .unwrap_or_else(|e| {
+                warn!("PUS 8: Handling reply failed with error {e:?}");
+                HandlingStatus::Empty
+            })
+    }
+
+    fn check_for_request_timeouts(&mut self) {
+        self.service.check_for_request_timeouts();
     }
 }
 
@@ -409,7 +417,7 @@ mod tests {
             }
             let result = result.unwrap();
             match result {
-                HandlingStatus::HandledOne => (),
+                PusPacketHandlerResult::RequestHandled => (),
                 _ => panic!("unexpected result {result:?}"),
             }
         }
@@ -421,19 +429,19 @@ mod tests {
             }
             let result = result.unwrap();
             match result {
-                HandlingStatus::Empty => (),
+                PusPacketHandlerResult::Empty => (),
                 _ => panic!("unexpected result {result:?}"),
             }
         }
 
         pub fn verify_next_reply_is_handled_properly(&mut self, time_stamp: &[u8]) {
-            let result = self.service.poll_and_handle_next_reply(time_stamp);
+            let result = self.service.poll_and_check_next_reply(time_stamp);
             assert!(result.is_ok());
             assert_eq!(result.unwrap(), HandlingStatus::HandledOne);
         }
 
         pub fn verify_all_replies_handled(&mut self, time_stamp: &[u8]) {
-            let result = self.service.poll_and_handle_next_reply(time_stamp);
+            let result = self.service.poll_and_check_next_reply(time_stamp);
             assert!(result.is_ok());
             assert_eq!(result.unwrap(), HandlingStatus::Empty);
         }
@@ -457,10 +465,7 @@ mod tests {
                 .verif_reporter()
                 .check_next_is_acceptance_success(id, accepted_token.request_id());
             self.pus_packet_tx
-                .send(EcssTcAndToken::new(
-                    PacketAsVec::new(self.service.service_helper.id(), tc.to_vec().unwrap()),
-                    accepted_token,
-                ))
+                .send(EcssTcAndToken::new(tc.to_vec().unwrap(), accepted_token))
                 .unwrap();
         }
     }

satrs-example/src/pus/event.rs

@@ -1,20 +1,20 @@
 use std::sync::mpsc;
 
 use crate::pus::create_verification_reporter;
+use log::{error, warn};
 use satrs::pool::SharedStaticMemoryPool;
 use satrs::pus::event_man::EventRequestWithToken;
 use satrs::pus::event_srv::PusEventServiceHandler;
 use satrs::pus::verification::VerificationReporter;
 use satrs::pus::{
-    DirectPusPacketHandlerResult, EcssTcAndToken, EcssTcInMemConverter,
-    EcssTcInSharedStoreConverter, EcssTcInVecConverter, EcssTmSender, MpscTcReceiver,
-    MpscTmAsVecSender, PartialPusHandlingError, PusServiceHelper,
+    EcssTcAndToken, EcssTcInMemConverter, EcssTcInSharedStoreConverter, EcssTcInVecConverter,
+    EcssTmSender, MpscTcReceiver, MpscTmAsVecSender, PacketAsVec, PusPacketHandlerResult,
+    PusServiceHelper,
 };
-use satrs::spacepackets::ecss::PusServiceId;
-use satrs::tmtc::{PacketAsVec, PacketSenderWithSharedPool};
+use satrs::tmtc::PacketSenderWithSharedPool;
 use satrs_example::config::components::PUS_EVENT_MANAGEMENT;
 
-use super::{DirectPusService, HandlingStatus};
+use super::HandlingStatus;
 
 pub fn create_event_service_static(
     tm_sender: PacketSenderWithSharedPool,
@@ -62,52 +62,26 @@ pub struct EventServiceWrapper<TmSender: EcssTmSender, TcInMemConverter: EcssTcI
         PusEventServiceHandler<MpscTcReceiver, TmSender, TcInMemConverter, VerificationReporter>,
 }
 
-impl<TmSender: EcssTmSender, TcInMemConverter: EcssTcInMemConverter> DirectPusService
-    for EventServiceWrapper<TmSender, TcInMemConverter>
+impl<TmSender: EcssTmSender, TcInMemConverter: EcssTcInMemConverter>
+    EventServiceWrapper<TmSender, TcInMemConverter>
 {
-    const SERVICE_ID: u8 = PusServiceId::Event as u8;
-
-    const SERVICE_STR: &'static str = "events";
-
-    fn poll_and_handle_next_tc(&mut self, time_stamp: &[u8]) -> HandlingStatus {
-        let error_handler = |partial_error: &PartialPusHandlingError| {
-            log::warn!(
-                "PUS {}({}) partial error: {:?}",
-                Self::SERVICE_ID,
-                Self::SERVICE_STR,
-                partial_error
-            );
-        };
-        let result = self
-            .handler
-            .poll_and_handle_next_tc(error_handler, time_stamp);
-        if let Err(e) = result {
-            log::warn!(
-                "PUS {}({}) error: {:?}",
-                Self::SERVICE_ID,
-                Self::SERVICE_STR,
-                e
-            );
-            // To avoid permanent loops on continuous errors.
-            return HandlingStatus::Empty;
-        }
-        match result.unwrap() {
-            DirectPusPacketHandlerResult::Handled(handling_status) => return handling_status,
-            DirectPusPacketHandlerResult::CustomSubservice(subservice, _) => {
-                log::warn!(
-                    "PUS {}({}) subservice {} not implemented",
-                    Self::SERVICE_ID,
-                    Self::SERVICE_STR,
-                    subservice
-                );
-            }
-            DirectPusPacketHandlerResult::SubserviceNotImplemented(subservice, _) => {
-                log::warn!(
-                    "PUS {}({}) subservice {} not implemented",
-                    Self::SERVICE_ID,
-                    Self::SERVICE_STR,
-                    subservice
-                );
+    pub fn poll_and_handle_next_tc(&mut self, time_stamp: &[u8]) -> HandlingStatus {
+        match self.handler.poll_and_handle_next_tc(time_stamp) {
+            Ok(result) => match result {
+                PusPacketHandlerResult::RequestHandled => {}
+                PusPacketHandlerResult::RequestHandledPartialSuccess(e) => {
+                    warn!("PUS 5 partial packet handling success: {e:?}")
+                }
+                PusPacketHandlerResult::CustomSubservice(invalid, _) => {
+                    warn!("PUS 5 invalid subservice {invalid}");
+                }
+                PusPacketHandlerResult::SubserviceNotImplemented(subservice, _) => {
+                    warn!("PUS 5 subservice {subservice} not implemented");
+                }
+                PusPacketHandlerResult::Empty => return HandlingStatus::Empty,
+            },
+            Err(error) => {
+                error!("PUS packet handling error: {error:?}")
             }
         }
         HandlingStatus::HandledOne

satrs-example/src/pus/hk.rs

@@ -1,4 +1,5 @@
 use derive_new::new;
+use log::{error, warn};
 use satrs::hk::{CollectionIntervalFactor, HkRequest, HkRequestVariant, UniqueId};
 use satrs::pool::SharedStaticMemoryPool;
 use satrs::pus::verification::{
@@ -8,13 +9,13 @@ use satrs::pus::verification::{
 use satrs::pus::{
     ActivePusRequestStd, ActiveRequestProvider, DefaultActiveRequestMap, EcssTcAndToken,
     EcssTcInMemConverter, EcssTcInSharedStoreConverter, EcssTcInVecConverter, EcssTmSender,
-    EcssTmtcError, GenericConversionError, MpscTcReceiver, MpscTmAsVecSender,
-    PusPacketHandlingError, PusReplyHandler, PusServiceHelper, PusTcToRequestConverter,
+    EcssTmtcError, GenericConversionError, MpscTcReceiver, MpscTmAsVecSender, PacketAsVec,
+    PusPacketHandlerResult, PusReplyHandler, PusServiceHelper, PusTcToRequestConverter,
 };
 use satrs::request::{GenericMessage, UniqueApidTargetId};
 use satrs::spacepackets::ecss::tc::PusTcReader;
-use satrs::spacepackets::ecss::{hk, PusPacket, PusServiceId};
-use satrs::tmtc::{PacketAsVec, PacketSenderWithSharedPool};
+use satrs::spacepackets::ecss::{hk, PusPacket};
+use satrs::tmtc::PacketSenderWithSharedPool;
 use satrs_example::config::components::PUS_HK_SERVICE;
 use satrs_example::config::{hk_err, tmtc_err};
 use std::sync::mpsc;
@@ -23,7 +24,7 @@ use std::time::Duration;
 use crate::pus::{create_verification_reporter, generic_pus_request_timeout_handler};
 use crate::requests::GenericRequestRouter;
 
-use super::{HandlingStatus, PusTargetedRequestService, TargetedPusService};
+use super::{HandlingStatus, PusTargetedRequestService};
 
 #[derive(Clone, PartialEq, Debug, new)]
 pub struct HkReply {
@@ -296,26 +297,45 @@ pub struct HkServiceWrapper<TmSender: EcssTmSender, TcInMemConverter: EcssTcInMe
     >,
 }
 
-impl<TmSender: EcssTmSender, TcInMemConverter: EcssTcInMemConverter> TargetedPusService
-    for HkServiceWrapper<TmSender, TcInMemConverter>
+impl<TmSender: EcssTmSender, TcInMemConverter: EcssTcInMemConverter>
+    HkServiceWrapper<TmSender, TcInMemConverter>
 {
-    const SERVICE_ID: u8 = PusServiceId::Housekeeping as u8;
-    const SERVICE_STR: &'static str = "housekeeping";
-
-    delegate::delegate! {
-        to self.service {
-            fn poll_and_handle_next_tc(
-                &mut self,
-                time_stamp: &[u8],
-            ) -> Result<HandlingStatus, PusPacketHandlingError>;
-
-            fn poll_and_handle_next_reply(
-                &mut self,
-                time_stamp: &[u8],
-            ) -> Result<HandlingStatus, EcssTmtcError>;
-
-            fn check_for_request_timeouts(&mut self);
+    pub fn poll_and_handle_next_tc(&mut self, time_stamp: &[u8]) -> HandlingStatus {
+        match self.service.poll_and_handle_next_tc(time_stamp) {
+            Ok(result) => match result {
+                PusPacketHandlerResult::RequestHandled => {}
+                PusPacketHandlerResult::RequestHandledPartialSuccess(e) => {
+                    warn!("PUS 3 partial packet handling success: {e:?}")
+                }
+                PusPacketHandlerResult::CustomSubservice(invalid, _) => {
+                    warn!("PUS 3 invalid subservice {invalid}");
+                }
+                PusPacketHandlerResult::SubserviceNotImplemented(subservice, _) => {
+                    warn!("PUS 3 subservice {subservice} not implemented");
+                }
+                PusPacketHandlerResult::Empty => return HandlingStatus::Empty,
+            },
+            Err(error) => {
+                error!("PUS packet handling error: {error:?}");
+                // To avoid permanent loops on error cases.
+                return HandlingStatus::Empty;
+            }
         }
+        HandlingStatus::HandledOne
+    }
+
+    pub fn poll_and_handle_next_reply(&mut self, time_stamp: &[u8]) -> HandlingStatus {
+        // This only fails if all senders disconnected. Treat it like an empty queue.
+        self.service
+            .poll_and_check_next_reply(time_stamp)
+            .unwrap_or_else(|e| {
+                warn!("PUS 3: Handling reply failed with error {e:?}");
+                HandlingStatus::Empty
+            })
+    }
+
+    pub fn check_for_request_timeouts(&mut self) {
+        self.service.check_for_request_timeouts();
     }
 }
 

satrs-example/src/pus/mod.rs

@@ -1,6 +1,5 @@
 use crate::requests::GenericRequestRouter;
 use log::warn;
-use satrs::pool::PoolAddr;
 use satrs::pus::verification::{
     self, FailParams, TcStateAccepted, TcStateStarted, VerificationReporter,
     VerificationReporterCfg, VerificationReportingProvider, VerificationToken,
@@ -8,14 +7,13 @@ use satrs::pus::verification::{
 use satrs::pus::{
     ActiveRequestMapProvider, ActiveRequestProvider, EcssTcAndToken, EcssTcInMemConverter,
     EcssTcReceiver, EcssTmSender, EcssTmtcError, GenericConversionError, GenericRoutingError,
-    HandlingStatus, PusPacketHandlingError, PusReplyHandler, PusRequestRouter, PusServiceHelper,
-    PusTcToRequestConverter, TcInMemory,
+    PusPacketHandlerResult, PusPacketHandlingError, PusReplyHandler, PusRequestRouter,
+    PusServiceHelper, PusTcToRequestConverter, TcInMemory,
 };
 use satrs::queue::{GenericReceiveError, GenericSendError};
 use satrs::request::{Apid, GenericMessage, MessageMetadata};
 use satrs::spacepackets::ecss::tc::PusTcReader;
-use satrs::spacepackets::ecss::{PusPacket, PusServiceId};
-use satrs::tmtc::{PacketAsVec, PacketInPool};
+use satrs::spacepackets::ecss::PusServiceId;
 use satrs::ComponentId;
 use satrs_example::config::components::PUS_ROUTING_SERVICE;
 use satrs_example::config::{tmtc_err, CustomPusServiceId};
@@ -31,6 +29,12 @@ pub mod scheduler;
 pub mod stack;
 pub mod test;
 
+#[derive(Debug, PartialEq, Eq, Copy, Clone)]
+pub enum HandlingStatus {
+    Empty,
+    HandledOne,
+}
+
 pub fn create_verification_reporter(owner_id: ComponentId, apid: Apid) -> VerificationReporter {
     let verif_cfg = VerificationReporterCfg::new(apid, 1, 2, 8).unwrap();
     // Every software component which needs to generate verification telemetry, gets a cloned
@@ -70,55 +74,19 @@ impl<TmSender: EcssTmSender> PusTcDistributor<TmSender> {
         }
     }
 
-    pub fn handle_tc_packet_vec(
+    pub fn handle_tc_packet(
         &mut self,
-        packet_as_vec: PacketAsVec,
-    ) -> Result<HandlingStatus, GenericSendError> {
-        self.handle_tc_generic(packet_as_vec.sender_id, None, &packet_as_vec.packet)
-    }
-
-    pub fn handle_tc_packet_in_store(
-        &mut self,
-        packet_in_pool: PacketInPool,
-        pus_tc_copy: &[u8],
-    ) -> Result<HandlingStatus, GenericSendError> {
-        self.handle_tc_generic(
-            packet_in_pool.sender_id,
-            Some(packet_in_pool.store_addr),
-            pus_tc_copy,
-        )
-    }
-
-    pub fn handle_tc_generic(
-        &mut self,
-        sender_id: ComponentId,
-        addr_opt: Option<PoolAddr>,
-        raw_tc: &[u8],
-    ) -> Result<HandlingStatus, GenericSendError> {
-        let pus_tc_result = PusTcReader::new(raw_tc);
-        if pus_tc_result.is_err() {
-            log::warn!(
-                "error creating PUS TC from raw data received from {}: {}",
-                sender_id,
-                pus_tc_result.unwrap_err()
-            );
-            log::warn!("raw data: {:x?}", raw_tc);
-            // TODO: Shouldn't this be an error?
-            return Ok(HandlingStatus::HandledOne);
-        }
-        let pus_tc = pus_tc_result.unwrap().0;
-        let init_token = self.verif_reporter.add_tc(&pus_tc);
+        tc_in_memory: TcInMemory,
+        service: u8,
+        pus_tc: &PusTcReader,
+    ) -> Result<PusPacketHandlerResult, GenericSendError> {
+        let init_token = self.verif_reporter.add_tc(pus_tc);
         self.stamp_helper.update_from_now();
         let accepted_token = self
             .verif_reporter
             .acceptance_success(&self.tm_sender, init_token, self.stamp_helper.stamp())
             .expect("Acceptance success failure");
-        let service = PusServiceId::try_from(pus_tc.service());
-        let tc_in_memory: TcInMemory = if let Some(store_addr) = addr_opt {
-            PacketInPool::new(sender_id, store_addr).into()
-        } else {
-            PacketAsVec::new(sender_id, Vec::from(raw_tc)).into()
-        };
+        let service = PusServiceId::try_from(service);
         match service {
             Ok(standard_service) => match standard_service {
                 PusServiceId::Test => self.pus_router.test_tc_sender.send(EcssTcAndToken {
@@ -184,65 +152,17 @@ impl<TmSender: EcssTmSender> PusTcDistributor<TmSender> {
                 }
             }
         }
-        Ok(HandlingStatus::HandledOne)
+        Ok(PusPacketHandlerResult::RequestHandled)
     }
 }
 
 pub trait TargetedPusService {
-    const SERVICE_ID: u8;
-    const SERVICE_STR: &'static str;
-
-    fn poll_and_handle_next_tc_default_handler(&mut self, time_stamp: &[u8]) -> HandlingStatus {
-        let result = self.poll_and_handle_next_tc(time_stamp);
-        if let Err(e) = result {
-            log::error!(
-                "PUS service {}({})packet handling error: {:?}",
-                Self::SERVICE_ID,
-                Self::SERVICE_STR,
-                e
-            );
-            // To avoid permanent loops on error cases.
-            return HandlingStatus::Empty;
-        }
-        result.unwrap()
-    }
-
-    fn poll_and_handle_next_reply_default_handler(&mut self, time_stamp: &[u8]) -> HandlingStatus {
-        // This only fails if all senders disconnected. Treat it like an empty queue.
-        self.poll_and_handle_next_reply(time_stamp)
-            .unwrap_or_else(|e| {
-                warn!(
-                    "PUS servce {}({}): Handling reply failed with error {:?}",
-                    Self::SERVICE_ID,
-                    Self::SERVICE_STR,
-                    e
-                );
-                HandlingStatus::Empty
-            })
-    }
-
-    fn poll_and_handle_next_tc(
-        &mut self,
-        time_stamp: &[u8],
-    ) -> Result<HandlingStatus, PusPacketHandlingError>;
-
-    fn poll_and_handle_next_reply(
-        &mut self,
-        time_stamp: &[u8],
-    ) -> Result<HandlingStatus, EcssTmtcError>;
-
+    /// Returns [true] if the packet handling is finished.
+    fn poll_and_handle_next_tc(&mut self, time_stamp: &[u8]) -> HandlingStatus;
+    fn poll_and_handle_next_reply(&mut self, time_stamp: &[u8]) -> HandlingStatus;
     fn check_for_request_timeouts(&mut self);
 }
 
-/// Generic trait for services which handle packets directly. Kept minimal right now because
-/// of the difficulty to allow flexible user code for these services..
-pub trait DirectPusService {
-    const SERVICE_ID: u8;
-    const SERVICE_STR: &'static str;
-
-    fn poll_and_handle_next_tc(&mut self, timestamp: &[u8]) -> HandlingStatus;
-}
-
 /// This is a generic handler class for all PUS services where a PUS telecommand is converted
 /// to a targeted request.
 ///
@@ -340,10 +260,10 @@ where
     pub fn poll_and_handle_next_tc(
         &mut self,
         time_stamp: &[u8],
-    ) -> Result<HandlingStatus, PusPacketHandlingError> {
+    ) -> Result<PusPacketHandlerResult, PusPacketHandlingError> {
         let possible_packet = self.service_helper.retrieve_and_accept_next_packet()?;
         if possible_packet.is_none() {
-            return Ok(HandlingStatus::Empty);
+            return Ok(PusPacketHandlerResult::Empty);
         }
         let ecss_tc_and_token = possible_packet.unwrap();
         self.service_helper
@@ -399,7 +319,7 @@ where
                 return Err(e.into());
             }
         }
-        Ok(HandlingStatus::HandledOne)
+        Ok(PusPacketHandlerResult::RequestHandled)
     }
 
     fn handle_conversion_to_request_error(
@@ -452,7 +372,7 @@ where
         }
     }
 
-    pub fn poll_and_handle_next_reply(
+    pub fn poll_and_check_next_reply(
         &mut self,
         time_stamp: &[u8],
     ) -> Result<HandlingStatus, EcssTmtcError> {
@@ -482,17 +402,20 @@ where
             return Ok(());
         }
         let active_request = active_req_opt.unwrap();
-        let result = self.reply_handler.handle_reply(
-            reply,
-            active_request,
-            &self.service_helper.common.tm_sender,
-            &self.service_helper.common.verif_reporter,
-            time_stamp,
-        );
-        if result.is_err() || (result.is_ok() && *result.as_ref().unwrap()) {
+        let request_finished = self
+            .reply_handler
+            .handle_reply(
+                reply,
+                active_request,
+                &self.service_helper.common.tm_sender,
+                &self.service_helper.common.verif_reporter,
+                time_stamp,
+            )
+            .unwrap_or(false);
+        if request_finished {
             self.active_request_map.remove(reply.request_id());
         }
-        result.map(|_| ())
+        Ok(())
     }
 
     pub fn check_for_request_timeouts(&mut self) {
@@ -538,7 +461,7 @@ pub(crate) mod tests {
     use std::time::Duration;
 
     use satrs::pus::test_util::TEST_COMPONENT_ID_0;
-    use satrs::pus::{MpscTmAsVecSender, PusTmVariant};
+    use satrs::pus::{MpscTmAsVecSender, PacketAsVec, PusTmVariant};
     use satrs::request::RequestId;
     use satrs::{
         pus::{

satrs-example/src/pus/mode.rs

@@ -1,5 +1,6 @@
 use derive_new::new;
-use satrs::tmtc::{PacketAsVec, PacketSenderWithSharedPool};
+use log::{error, warn};
+use satrs::tmtc::PacketSenderWithSharedPool;
 use std::sync::mpsc;
 use std::time::Duration;
 
@@ -8,7 +9,7 @@ use satrs::pool::SharedStaticMemoryPool;
 use satrs::pus::verification::VerificationReporter;
 use satrs::pus::{
     DefaultActiveRequestMap, EcssTcAndToken, EcssTcInMemConverter, EcssTcInSharedStoreConverter,
-    EcssTcInVecConverter, MpscTcReceiver, MpscTmAsVecSender, PusPacketHandlingError,
+    EcssTcInVecConverter, MpscTcReceiver, MpscTmAsVecSender, PacketAsVec, PusPacketHandlerResult,
     PusServiceHelper,
 };
 use satrs::request::GenericMessage;
@@ -35,7 +36,7 @@ use satrs::{
     ComponentId,
 };
 use satrs_example::config::components::PUS_MODE_SERVICE;
-use satrs_example::config::{mode_err, tmtc_err, CustomPusServiceId};
+use satrs_example::config::{mode_err, tmtc_err};
 
 use super::{
     create_verification_reporter, generic_pus_request_timeout_handler, HandlingStatus,
@@ -271,26 +272,44 @@ pub struct ModeServiceWrapper<TmSender: EcssTmSender, TcInMemConverter: EcssTcIn
 impl<TmSender: EcssTmSender, TcInMemConverter: EcssTcInMemConverter> TargetedPusService
     for ModeServiceWrapper<TmSender, TcInMemConverter>
 {
-    const SERVICE_ID: u8 = CustomPusServiceId::Mode as u8;
-    const SERVICE_STR: &'static str = "mode";
-
-    delegate::delegate! {
-        to self.service {
-            fn poll_and_handle_next_tc(
-                &mut self,
-                time_stamp: &[u8],
-            ) -> Result<HandlingStatus, PusPacketHandlingError>;
-
-            fn poll_and_handle_next_reply(
-                &mut self,
-                time_stamp: &[u8],
-            ) -> Result<HandlingStatus, EcssTmtcError>;
-
-            fn check_for_request_timeouts(&mut self);
+    /// Returns [true] if the packet handling is finished.
+    fn poll_and_handle_next_tc(&mut self, time_stamp: &[u8]) -> HandlingStatus {
+        match self.service.poll_and_handle_next_tc(time_stamp) {
+            Ok(result) => match result {
+                PusPacketHandlerResult::RequestHandled => {}
+                PusPacketHandlerResult::RequestHandledPartialSuccess(e) => {
+                    warn!("PUS mode service: partial packet handling success: {e:?}")
+                }
+                PusPacketHandlerResult::CustomSubservice(invalid, _) => {
+                    warn!("PUS mode service: invalid subservice {invalid}");
+                }
+                PusPacketHandlerResult::SubserviceNotImplemented(subservice, _) => {
+                    warn!("PUS mode service: {subservice} not implemented");
+                }
+                PusPacketHandlerResult::Empty => return HandlingStatus::Empty,
+            },
+            Err(error) => {
+                error!("PUS mode service: packet handling error: {error:?}");
+                // To avoid permanent loops on error cases.
+                return HandlingStatus::Empty;
+            }
         }
+        HandlingStatus::HandledOne
+    }
+
+    fn poll_and_handle_next_reply(&mut self, time_stamp: &[u8]) -> HandlingStatus {
+        self.service
+            .poll_and_check_next_reply(time_stamp)
+            .unwrap_or_else(|e| {
+                warn!("PUS action service: Handling reply failed with error {e:?}");
+                HandlingStatus::HandledOne
+            })
+    }
+
+    fn check_for_request_timeouts(&mut self) {
+        self.service.check_for_request_timeouts();
     }
 }
-
 #[cfg(test)]
 mod tests {
     use satrs::pus::test_util::{TEST_APID, TEST_COMPONENT_ID_0, TEST_UNIQUE_ID_0};

satrs-example/src/pus/scheduler.rs

@@ -2,22 +2,21 @@ use std::sync::mpsc;
 use std::time::Duration;
 
 use crate::pus::create_verification_reporter;
-use log::info;
+use log::{error, info, warn};
 use satrs::pool::{PoolProvider, StaticMemoryPool};
 use satrs::pus::scheduler::{PusScheduler, TcInfo};
 use satrs::pus::scheduler_srv::PusSchedServiceHandler;
 use satrs::pus::verification::VerificationReporter;
 use satrs::pus::{
-    DirectPusPacketHandlerResult, EcssTcAndToken, EcssTcInMemConverter,
-    EcssTcInSharedStoreConverter, EcssTcInVecConverter, EcssTmSender, MpscTcReceiver,
-    MpscTmAsVecSender, PartialPusHandlingError, PusServiceHelper,
+    EcssTcAndToken, EcssTcInMemConverter, EcssTcInSharedStoreConverter, EcssTcInVecConverter,
+    EcssTmSender, MpscTcReceiver, MpscTmAsVecSender, PacketAsVec, PacketInPool,
+    PusPacketHandlerResult, PusServiceHelper,
 };
-use satrs::spacepackets::ecss::PusServiceId;
-use satrs::tmtc::{PacketAsVec, PacketInPool, PacketSenderWithSharedPool};
+use satrs::tmtc::PacketSenderWithSharedPool;
 use satrs::ComponentId;
 use satrs_example::config::components::PUS_SCHED_SERVICE;
 
-use super::{DirectPusService, HandlingStatus};
+use super::HandlingStatus;
 
 pub trait TcReleaser {
     fn release(&mut self, sender_id: ComponentId, enabled: bool, info: &TcInfo, tc: &[u8]) -> bool;
@@ -79,61 +78,6 @@ pub struct SchedulingServiceWrapper<TmSender: EcssTmSender, TcInMemConverter: Ec
     pub tc_releaser: Box<dyn TcReleaser + Send>,
 }
 
-impl<TmSender: EcssTmSender, TcInMemConverter: EcssTcInMemConverter> DirectPusService
-    for SchedulingServiceWrapper<TmSender, TcInMemConverter>
-{
-    const SERVICE_ID: u8 = PusServiceId::Verification as u8;
-
-    const SERVICE_STR: &'static str = "verification";
-
-    fn poll_and_handle_next_tc(&mut self, time_stamp: &[u8]) -> HandlingStatus {
-        let error_handler = |partial_error: &PartialPusHandlingError| {
-            log::warn!(
-                "PUS {}({}) partial error: {:?}",
-                Self::SERVICE_ID,
-                Self::SERVICE_STR,
-                partial_error
-            );
-        };
-
-        let result = self.pus_11_handler.poll_and_handle_next_tc(
-            error_handler,
-            time_stamp,
-            &mut self.sched_tc_pool,
-        );
-        if let Err(e) = result {
-            log::warn!(
-                "PUS {}({}) error: {:?}",
-                Self::SERVICE_ID,
-                Self::SERVICE_STR,
-                e
-            );
-            // To avoid permanent loops on continuous errors.
-            return HandlingStatus::Empty;
-        }
-        match result.unwrap() {
-            DirectPusPacketHandlerResult::Handled(handling_status) => return handling_status,
-            DirectPusPacketHandlerResult::CustomSubservice(subservice, _) => {
-                log::warn!(
-                    "PUS {}({}) subservice {} not implemented",
-                    Self::SERVICE_ID,
-                    Self::SERVICE_STR,
-                    subservice
-                );
-            }
-            DirectPusPacketHandlerResult::SubserviceNotImplemented(subservice, _) => {
-                log::warn!(
-                    "PUS {}({}) subservice {} not implemented",
-                    Self::SERVICE_ID,
-                    Self::SERVICE_STR,
-                    subservice
-                );
-            }
-        }
-        HandlingStatus::HandledOne
-    }
-}
-
 impl<TmSender: EcssTmSender, TcInMemConverter: EcssTcInMemConverter>
     SchedulingServiceWrapper<TmSender, TcInMemConverter>
 {
@@ -160,6 +104,31 @@ impl<TmSender: EcssTmSender, TcInMemConverter: EcssTcInMemConverter>
             info!("{released_tcs} TC(s) released from scheduler");
         }
     }
+
+    pub fn poll_and_handle_next_tc(&mut self, time_stamp: &[u8]) -> HandlingStatus {
+        match self
+            .pus_11_handler
+            .poll_and_handle_next_tc(time_stamp, &mut self.sched_tc_pool)
+        {
+            Ok(result) => match result {
+                PusPacketHandlerResult::RequestHandled => {}
+                PusPacketHandlerResult::RequestHandledPartialSuccess(e) => {
+                    warn!("PUS11 partial packet handling success: {e:?}")
+                }
+                PusPacketHandlerResult::CustomSubservice(invalid, _) => {
+                    warn!("PUS11 invalid subservice {invalid}");
+                }
+                PusPacketHandlerResult::SubserviceNotImplemented(subservice, _) => {
+                    warn!("PUS11: Subservice {subservice} not implemented");
+                }
+                PusPacketHandlerResult::Empty => return HandlingStatus::Empty,
+            },
+            Err(error) => {
+                error!("PUS packet handling error: {error:?}")
+            }
+        }
+        HandlingStatus::HandledOne
+    }
 }
 
 pub fn create_scheduler_service_static(

satrs-example/src/pus/stack.rs

@@ -7,12 +7,10 @@ use satrs::{
 
 use super::{
     action::ActionServiceWrapper, event::EventServiceWrapper, hk::HkServiceWrapper,
-    scheduler::SchedulingServiceWrapper, test::TestCustomServiceWrapper, DirectPusService,
-    HandlingStatus, TargetedPusService,
+    scheduler::SchedulingServiceWrapper, test::TestCustomServiceWrapper, HandlingStatus,
+    TargetedPusService,
 };
 
-// TODO: For better extensibility, we could create 2 vectors: One for direct PUS services and one
-// for targeted services..
 #[derive(new)]
 pub struct PusStack<TmSender: EcssTmSender, TcInMemConverter: EcssTcInMemConverter> {
     test_srv: TestCustomServiceWrapper<TmSender, TcInMemConverter>,
@@ -30,28 +28,52 @@ impl<TmSender: EcssTmSender, TcInMemConverter: EcssTcInMemConverter>
         // Release all telecommands which reached their release time before calling the service
         // handlers.
         self.schedule_srv.release_tcs();
-        let timestamp = cds::CdsTime::now_with_u16_days()
+        let time_stamp = cds::CdsTime::now_with_u16_days()
             .expect("time stamp generation error")
             .to_vec()
             .unwrap();
-        let mut loop_count = 0_u32;
-        // Hot loop which will run continuously until all request and reply handling is done.
         loop {
             let mut nothing_to_do = true;
-            Self::direct_service_checker(&mut self.test_srv, &timestamp, &mut nothing_to_do);
-            Self::direct_service_checker(&mut self.schedule_srv, &timestamp, &mut nothing_to_do);
-            Self::direct_service_checker(&mut self.event_srv, &timestamp, &mut nothing_to_do);
-            Self::targeted_service_checker(
-                &mut self.action_srv_wrapper,
-                &timestamp,
-                &mut nothing_to_do,
+            let mut is_srv_finished =
+                |_srv_id: u8,
+                 tc_handling_status: HandlingStatus,
+                 reply_handling_status: Option<HandlingStatus>| {
+                    if tc_handling_status == HandlingStatus::HandledOne
+                        || (reply_handling_status.is_some()
+                            && reply_handling_status.unwrap() == HandlingStatus::HandledOne)
+                    {
+                        nothing_to_do = false;
+                    }
+                };
+            is_srv_finished(
+                17,
+                self.test_srv.poll_and_handle_next_packet(&time_stamp),
+                None,
             );
-            Self::targeted_service_checker(
-                &mut self.hk_srv_wrapper,
-                &timestamp,
-                &mut nothing_to_do,
+            is_srv_finished(
+                11,
+                self.schedule_srv.poll_and_handle_next_tc(&time_stamp),
+                None,
+            );
+            is_srv_finished(5, self.event_srv.poll_and_handle_next_tc(&time_stamp), None);
+            is_srv_finished(
+                8,
+                self.action_srv_wrapper.poll_and_handle_next_tc(&time_stamp),
+                Some(
+                    self.action_srv_wrapper
+                        .poll_and_handle_next_reply(&time_stamp),
+                ),
+            );
+            is_srv_finished(
+                3,
+                self.hk_srv_wrapper.poll_and_handle_next_tc(&time_stamp),
+                Some(self.hk_srv_wrapper.poll_and_handle_next_reply(&time_stamp)),
+            );
+            is_srv_finished(
+                200,
+                self.mode_srv.poll_and_handle_next_tc(&time_stamp),
+                Some(self.mode_srv.poll_and_handle_next_reply(&time_stamp)),
             );
-            Self::targeted_service_checker(&mut self.mode_srv, &timestamp, &mut nothing_to_do);
             if nothing_to_do {
                 // Timeout checking is only done once.
                 self.action_srv_wrapper.check_for_request_timeouts();
@@ -59,37 +81,6 @@ impl<TmSender: EcssTmSender, TcInMemConverter: EcssTcInMemConverter>
                 self.mode_srv.check_for_request_timeouts();
                 break;
             }
-            // Safety mechanism to avoid infinite loops.
-            loop_count += 1;
-            if loop_count >= 500 {
-                log::warn!("reached PUS stack loop count 500, breaking");
-                break;
-            }
-        }
-    }
-
-    pub fn direct_service_checker<S: DirectPusService>(
-        service: &mut S,
-        timestamp: &[u8],
-        nothing_to_do: &mut bool,
-    ) {
-        let handling_status = service.poll_and_handle_next_tc(timestamp);
-        if handling_status == HandlingStatus::HandledOne {
-            *nothing_to_do = false;
-        }
-    }
-
-    pub fn targeted_service_checker<S: TargetedPusService>(
-        service: &mut S,
-        timestamp: &[u8],
-        nothing_to_do: &mut bool,
-    ) {
-        let request_handling = service.poll_and_handle_next_tc_default_handler(timestamp);
-        let reply_handling = service.poll_and_handle_next_reply_default_handler(timestamp);
-        if request_handling == HandlingStatus::HandledOne
-            || reply_handling == HandlingStatus::HandledOne
-        {
-            *nothing_to_do = false;
         }
     }
 }

satrs-example/src/pus/test.rs

@@ -1,27 +1,29 @@
 use crate::pus::create_verification_reporter;
-use log::info;
+use log::{info, warn};
 use satrs::event_man::{EventMessage, EventMessageU32};
 use satrs::pool::SharedStaticMemoryPool;
 use satrs::pus::test::PusService17TestHandler;
 use satrs::pus::verification::{FailParams, VerificationReporter, VerificationReportingProvider};
+use satrs::pus::EcssTcInSharedStoreConverter;
 use satrs::pus::{
-    DirectPusPacketHandlerResult, EcssTcAndToken, EcssTcInMemConverter, EcssTcInVecConverter,
-    EcssTmSender, MpscTcReceiver, MpscTmAsVecSender, PusServiceHelper,
+    EcssTcAndToken, EcssTcInMemConverter, EcssTcInVecConverter, EcssTmSender, MpscTcReceiver,
+    MpscTmAsVecSender, PacketAsVec, PusPacketHandlerResult, PusServiceHelper,
 };
-use satrs::pus::{EcssTcInSharedStoreConverter, PartialPusHandlingError};
 use satrs::spacepackets::ecss::tc::PusTcReader;
-use satrs::spacepackets::ecss::{PusPacket, PusServiceId};
-use satrs::tmtc::{PacketAsVec, PacketSenderWithSharedPool};
+use satrs::spacepackets::ecss::PusPacket;
+use satrs::spacepackets::time::cds::CdsTime;
+use satrs::spacepackets::time::TimeWriter;
+use satrs::tmtc::PacketSenderWithSharedPool;
 use satrs_example::config::components::PUS_TEST_SERVICE;
 use satrs_example::config::{tmtc_err, TEST_EVENT};
 use std::sync::mpsc;
 
-use super::{DirectPusService, HandlingStatus};
+use super::HandlingStatus;
 
 pub fn create_test_service_static(
     tm_sender: PacketSenderWithSharedPool,
     tc_pool: SharedStaticMemoryPool,
-    event_sender: mpsc::SyncSender<EventMessageU32>,
+    event_sender: mpsc::Sender<EventMessageU32>,
     pus_test_rx: mpsc::Receiver<EcssTcAndToken>,
 ) -> TestCustomServiceWrapper<PacketSenderWithSharedPool, EcssTcInSharedStoreConverter> {
     let pus17_handler = PusService17TestHandler::new(PusServiceHelper::new(
@@ -33,13 +35,13 @@ pub fn create_test_service_static(
     ));
     TestCustomServiceWrapper {
         handler: pus17_handler,
-        event_tx: event_sender,
+        test_srv_event_sender: event_sender,
     }
 }
 
 pub fn create_test_service_dynamic(
     tm_funnel_tx: mpsc::Sender<PacketAsVec>,
-    event_sender: mpsc::SyncSender<EventMessageU32>,
+    event_sender: mpsc::Sender<EventMessageU32>,
     pus_test_rx: mpsc::Receiver<EcssTcAndToken>,
 ) -> TestCustomServiceWrapper<MpscTmAsVecSender, EcssTcInVecConverter> {
     let pus17_handler = PusService17TestHandler::new(PusServiceHelper::new(
@@ -51,7 +53,7 @@ pub fn create_test_service_dynamic(
     ));
     TestCustomServiceWrapper {
         handler: pus17_handler,
-        event_tx: event_sender,
+        test_srv_event_sender: event_sender,
     }
 }
 
@@ -59,55 +61,33 @@ pub struct TestCustomServiceWrapper<TmSender: EcssTmSender, TcInMemConverter: Ec
 {
     pub handler:
         PusService17TestHandler<MpscTcReceiver, TmSender, TcInMemConverter, VerificationReporter>,
-    pub event_tx: mpsc::SyncSender<EventMessageU32>,
+    pub test_srv_event_sender: mpsc::Sender<EventMessageU32>,
 }
 
-impl<TmSender: EcssTmSender, TcInMemConverter: EcssTcInMemConverter> DirectPusService
-    for TestCustomServiceWrapper<TmSender, TcInMemConverter>
+impl<TmSender: EcssTmSender, TcInMemConverter: EcssTcInMemConverter>
+    TestCustomServiceWrapper<TmSender, TcInMemConverter>
 {
-    const SERVICE_ID: u8 = PusServiceId::Test as u8;
-
-    const SERVICE_STR: &'static str = "test";
-
-    fn poll_and_handle_next_tc(&mut self, timestamp: &[u8]) -> HandlingStatus {
-        let error_handler = |partial_error: &PartialPusHandlingError| {
-            log::warn!(
-                "PUS {}({}) partial error: {:?}",
-                Self::SERVICE_ID,
-                Self::SERVICE_STR,
-                partial_error
-            );
-        };
-        let res = self
-            .handler
-            .poll_and_handle_next_tc(error_handler, timestamp);
-        if let Err(e) = res {
-            log::warn!(
-                "PUS {}({}) error: {:?}",
-                Self::SERVICE_ID,
-                Self::SERVICE_STR,
-                e
-            );
-            // To avoid permanent loops on continuous errors.
-            return HandlingStatus::Empty;
+    pub fn poll_and_handle_next_packet(&mut self, time_stamp: &[u8]) -> HandlingStatus {
+        let res = self.handler.poll_and_handle_next_tc(time_stamp);
+        if res.is_err() {
+            warn!("PUS17 handler failed with error {:?}", res.unwrap_err());
+            return HandlingStatus::HandledOne;
         }
         match res.unwrap() {
-            DirectPusPacketHandlerResult::Handled(handling_status) => {
-                if handling_status == HandlingStatus::HandledOne {
-                    info!("Received PUS ping command TC[17,1]");
-                    info!("Sent ping reply PUS TM[17,2]");
-                }
-                return handling_status;
+            PusPacketHandlerResult::RequestHandled => {
+                info!("Received PUS ping command TC[17,1]");
+                info!("Sent ping reply PUS TM[17,2]");
             }
-            DirectPusPacketHandlerResult::SubserviceNotImplemented(subservice, _) => {
-                log::warn!(
-                    "PUS {}({}) subservice {} not implemented",
-                    Self::SERVICE_ID,
-                    Self::SERVICE_STR,
-                    subservice
+            PusPacketHandlerResult::RequestHandledPartialSuccess(partial_err) => {
+                warn!(
+                    "Handled PUS ping command with partial success: {:?}",
+                    partial_err
                 );
             }
-            DirectPusPacketHandlerResult::CustomSubservice(subservice, token) => {
+            PusPacketHandlerResult::SubserviceNotImplemented(subservice, _) => {
+                warn!("PUS17: Subservice {subservice} not implemented")
+            }
+            PusPacketHandlerResult::CustomSubservice(subservice, token) => {
                 let (tc, _) = PusTcReader::new(
                     self.handler
                         .service_helper
@@ -115,34 +95,29 @@ impl<TmSender: EcssTmSender, TcInMemConverter: EcssTcInMemConverter> DirectPusSe
                         .tc_slice_raw(),
                 )
                 .unwrap();
+                let time_stamper = CdsTime::now_with_u16_days().unwrap();
+                let mut stamp_buf: [u8; 7] = [0; 7];
+                time_stamper.write_to_bytes(&mut stamp_buf).unwrap();
                 if subservice == 128 {
-                    info!("generating test event");
-                    self.event_tx
+                    info!("Generating test event");
+                    self.test_srv_event_sender
                         .send(EventMessage::new(PUS_TEST_SERVICE.id(), TEST_EVENT.into()))
                         .expect("Sending test event failed");
-                    match self.handler.service_helper.verif_reporter().start_success(
-                        self.handler.service_helper.tm_sender(),
-                        token,
-                        timestamp,
-                    ) {
-                        Ok(started_token) => {
-                            if let Err(e) = self
-                                .handler
-                                .service_helper
-                                .verif_reporter()
-                                .completion_success(
-                                    self.handler.service_helper.tm_sender(),
-                                    started_token,
-                                    timestamp,
-                                )
-                            {
-                                error_handler(&PartialPusHandlingError::Verification(e));
-                            }
-                        }
-                        Err(e) => {
-                            error_handler(&PartialPusHandlingError::Verification(e));
-                        }
-                    }
+                    let start_token = self
+                        .handler
+                        .service_helper
+                        .verif_reporter()
+                        .start_success(self.handler.service_helper.tm_sender(), token, &stamp_buf)
+                        .expect("Error sending start success");
+                    self.handler
+                        .service_helper
+                        .verif_reporter()
+                        .completion_success(
+                            self.handler.service_helper.tm_sender(),
+                            start_token,
+                            &stamp_buf,
+                        )
+                        .expect("Error sending completion success");
                 } else {
                     let fail_data = [tc.subservice()];
                     self.handler
@@ -152,7 +127,7 @@ impl<TmSender: EcssTmSender, TcInMemConverter: EcssTcInMemConverter> DirectPusSe
                             self.handler.service_helper.tm_sender(),
                             token,
                             FailParams::new(
-                                timestamp,
+                                &stamp_buf,
                                 &tmtc_err::INVALID_PUS_SUBSERVICE,
                                 &fail_data,
                             ),
@@ -160,6 +135,7 @@ impl<TmSender: EcssTmSender, TcInMemConverter: EcssTcInMemConverter> DirectPusSe
                         .expect("Sending start failure verification failed");
                 }
             }
+            PusPacketHandlerResult::Empty => return HandlingStatus::Empty,
         }
         HandlingStatus::HandledOne
     }

satrs-example/src/tmtc/tc_source.rs

@@ -1,11 +1,14 @@
 use satrs::{
     pool::PoolProvider,
-    pus::HandlingStatus,
-    tmtc::{PacketAsVec, PacketInPool, PacketSenderWithSharedPool, SharedPacketPool},
+    pus::{PacketAsVec, PacketInPool},
+    tmtc::{PacketSenderWithSharedPool, SharedPacketPool},
 };
 use std::sync::mpsc::{self, TryRecvError};
 
-use satrs::pus::MpscTmAsVecSender;
+use satrs::{
+    pus::MpscTmAsVecSender,
+    spacepackets::ecss::{tc::PusTcReader, PusPacket},
+};
 
 use crate::pus::PusTcDistributor;
 
@@ -14,7 +17,7 @@ pub struct TcSourceTaskStatic {
     shared_tc_pool: SharedPacketPool,
     tc_receiver: mpsc::Receiver<PacketInPool>,
     tc_buf: [u8; 4096],
-    pus_distributor: PusTcDistributor<PacketSenderWithSharedPool>,
+    pus_receiver: PusTcDistributor<PacketSenderWithSharedPool>,
 }
 
 impl TcSourceTaskStatic {
@@ -27,7 +30,7 @@ impl TcSourceTaskStatic {
             shared_tc_pool,
             tc_receiver,
             tc_buf: [0; 4096],
-            pus_distributor: pus_receiver,
+            pus_receiver,
         }
     }
 
@@ -35,9 +38,7 @@ impl TcSourceTaskStatic {
         self.poll_tc();
     }
 
-    pub fn poll_tc(&mut self) -> HandlingStatus {
-        // Right now, we only expect ECSS PUS packets.
-        // If packets like CFDP are expected, we might have to check the APID first.
+    pub fn poll_tc(&mut self) -> bool {
         match self.tc_receiver.try_recv() {
             Ok(packet_in_pool) => {
                 let pool = self
@@ -48,16 +49,29 @@ impl TcSourceTaskStatic {
                 pool.read(&packet_in_pool.store_addr, &mut self.tc_buf)
                     .expect("reading pool failed");
                 drop(pool);
-                self.pus_distributor
-                    .handle_tc_packet_in_store(packet_in_pool, &self.tc_buf)
-                    .ok();
-                HandlingStatus::HandledOne
+                match PusTcReader::new(&self.tc_buf) {
+                    Ok((pus_tc, _)) => {
+                        self.pus_receiver
+                            .handle_tc_packet(
+                                satrs::pus::TcInMemory::StoreAddr(packet_in_pool.store_addr),
+                                pus_tc.service(),
+                                &pus_tc,
+                            )
+                            .ok();
+                        true
+                    }
+                    Err(e) => {
+                        log::warn!("error creating PUS TC from raw data: {e}");
+                        log::warn!("raw data: {:x?}", self.tc_buf);
+                        true
+                    }
+                }
             }
             Err(e) => match e {
-                TryRecvError::Empty => HandlingStatus::Empty,
+                TryRecvError::Empty => false,
                 TryRecvError::Disconnected => {
                     log::warn!("tmtc thread: sender disconnected");
-                    HandlingStatus::Empty
+                    false
                 }
             },
         }
@@ -67,7 +81,7 @@ impl TcSourceTaskStatic {
 // TC source components where the heap is the backing memory of the received telecommands.
 pub struct TcSourceTaskDynamic {
     pub tc_receiver: mpsc::Receiver<PacketAsVec>,
-    pus_distributor: PusTcDistributor<MpscTmAsVecSender>,
+    pus_receiver: PusTcDistributor<MpscTmAsVecSender>,
 }
 
 impl TcSourceTaskDynamic {
@@ -77,7 +91,7 @@ impl TcSourceTaskDynamic {
     ) -> Self {
         Self {
             tc_receiver,
-            pus_distributor: pus_receiver,
+            pus_receiver,
         }
     }
 
@@ -85,21 +99,31 @@ impl TcSourceTaskDynamic {
         self.poll_tc();
     }
 
-    pub fn poll_tc(&mut self) -> HandlingStatus {
-        // Right now, we only expect ECSS PUS packets.
-        // If packets like CFDP are expected, we might have to check the APID first.
+    pub fn poll_tc(&mut self) -> bool {
+        // Right now, we only expect PUS packets.
         match self.tc_receiver.try_recv() {
-            Ok(packet_as_vec) => {
-                self.pus_distributor
-                    .handle_tc_packet_vec(packet_as_vec)
-                    .ok();
-                HandlingStatus::HandledOne
-            }
+            Ok(packet_as_vec) => match PusTcReader::new(&packet_as_vec.packet) {
+                Ok((pus_tc, _)) => {
+                    self.pus_receiver
+                        .handle_tc_packet(
+                            satrs::pus::TcInMemory::Vec(packet_as_vec.packet.clone()),
+                            pus_tc.service(),
+                            &pus_tc,
+                        )
+                        .ok();
+                    true
+                }
+                Err(e) => {
+                    log::warn!("error creating PUS TC from raw data: {e}");
+                    log::warn!("raw data: {:x?}", packet_as_vec.packet);
+                    true
+                }
+            },
             Err(e) => match e {
-                TryRecvError::Empty => HandlingStatus::Empty,
+                TryRecvError::Empty => false,
                 TryRecvError::Disconnected => {
                     log::warn!("tmtc thread: sender disconnected");
-                    HandlingStatus::Empty
+                    false
                 }
             },
         }

satrs-example/src/tmtc/tm_sink.rs

@@ -4,7 +4,6 @@ use std::{
 };
 
 use log::info;
-use satrs::tmtc::{PacketAsVec, PacketInPool, SharedPacketPool};
 use satrs::{
     pool::PoolProvider,
     seq_count::{CcsdsSimpleSeqCountProvider, SequenceCountProviderCore},
@@ -14,6 +13,10 @@ use satrs::{
         CcsdsPacket,
     },
 };
+use satrs::{
+    pus::{PacketAsVec, PacketInPool},
+    tmtc::SharedPacketPool,
+};
 
 use crate::interface::tcp::SyncTcpTmSource;
 
@@ -70,23 +73,18 @@ impl TmFunnelCommon {
     }
 
     fn packet_printout(tm: &PusTmZeroCopyWriter) {
-        info!(
-            "Sending PUS TM[{},{}] with APID {}",
-            tm.service(),
-            tm.subservice(),
-            tm.apid()
-        );
+        info!("Sending PUS TM[{},{}]", tm.service(), tm.subservice());
     }
 }
 
-pub struct TmSinkStatic {
+pub struct TmFunnelStatic {
     common: TmFunnelCommon,
     shared_tm_store: SharedPacketPool,
     tm_funnel_rx: mpsc::Receiver<PacketInPool>,
     tm_server_tx: mpsc::SyncSender<PacketInPool>,
 }
 
-impl TmSinkStatic {
+impl TmFunnelStatic {
     pub fn new(
         shared_tm_store: SharedPacketPool,
         sync_tm_tcp_source: SyncTcpTmSource,
@@ -126,13 +124,13 @@ impl TmSinkStatic {
     }
 }
 
-pub struct TmSinkDynamic {
+pub struct TmFunnelDynamic {
     common: TmFunnelCommon,
     tm_funnel_rx: mpsc::Receiver<PacketAsVec>,
     tm_server_tx: mpsc::Sender<PacketAsVec>,
 }
 
-impl TmSinkDynamic {
+impl TmFunnelDynamic {
     pub fn new(
         sync_tm_tcp_source: SyncTcpTmSource,
         tm_funnel_rx: mpsc::Receiver<PacketAsVec>,

satrs-mib/CHANGELOG.md

@@ -8,10 +8,6 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 
 # [unreleased]
 
-# [v0.1.2] 2024-04-17
-
-Allow `satrs-shared` from `v0.1.3` to `<v0.2`.
-
 # [v0.1.1] 2024-02-17
 
 - Bumped `spacepackets` to v0.10.0

satrs-mib/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "satrs-mib"
-version = "0.1.2"
+version = "0.1.1"
 edition = "2021"
 rust-version = "1.61"
 authors = ["Robin Mueller <muellerr@irs.uni-stuttgart.de>"]
@@ -23,12 +23,13 @@ version = "1"
 optional = true
 
 [dependencies.satrs-shared]
-version = ">=0.1.3, <0.2"
+path = "../satrs-shared"
+version = "0.1.3"
 features = ["serde"]
 
 [dependencies.satrs-mib-codegen]
 path = "codegen"
-version = "0.1.2"
+version = "0.1.1"
 
 [dependencies.serde]
 version = "1"

satrs-mib/codegen/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "satrs-mib-codegen"
-version = "0.1.2"
+version = "0.1.1"
 edition = "2021"
 description = "satrs-mib proc macro implementation"
 homepage = "https://egit.irs.uni-stuttgart.de/rust/sat-rs"
@@ -28,7 +28,8 @@ features = ["full"]
 trybuild = { version = "1", features = ["diff"] }
 
 [dev-dependencies.satrs-shared]
-version = ">=0.1.3, <0.2"
+version = "0.1.3"
+path = "../../satrs-shared"
 
 [dev-dependencies.satrs-mib]
 path = ".."

satrs-shared/CHANGELOG.md

@@ -8,19 +8,6 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 
 # [unreleased]
 
-# [v0.1.4] 2024-04-24
-
-## Added
-
-- `ResultU16::from_be_bytes`
-- `From<u16>` impl for `ResultU16`.
-- Optional `defmt` support: `defmt::Format` impl on `ResultU16` if the `defmt` feature is
-  activated.
-
-# [v0.1.3] 2024-04-16
-
-Allow `spacepackets` range starting with v0.10 and v0.11.
-
 # [v0.1.2] 2024-02-17
 
 - Bumped `spacepackets` to v0.10.0 for `UnsignedEnum` trait change.

satrs-shared/Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "satrs-shared"
 description = "Components shared by multiple sat-rs crates"
-version = "0.1.4"
+version = "0.1.3"
 edition = "2021"
 authors = ["Robin Mueller <muellerr@irs.uni-stuttgart.de>"]
 homepage = "https://absatsw.irs.uni-stuttgart.de/projects/sat-rs/"
@@ -17,17 +17,12 @@ version = "1"
 default-features = false
 optional = true
 
-[dependencies.defmt]
-version = "0.3"
-optional = true
-
 [dependencies.spacepackets]
-version = ">0.9, <=0.11"
+version = "0.11.0-rc.2"
 default-features = false
 
 [features]
 serde = ["dep:serde", "spacepackets/serde"]
-spacepackets = ["dep:defmt", "spacepackets/defmt"]
 
 [package.metadata.docs.rs]
-rustdoc-args = ["--cfg", "docs_rs", "--generate-link-to-definition"]
+rustdoc-args = ["--cfg", "doc_cfg", "--generate-link-to-definition"]

satrs-shared/src/lib.rs

@@ -1,4 +1,3 @@
 //! This crates contains modules shared among other sat-rs framework crates.
 #![no_std]
-#![cfg_attr(docs_rs, feature(doc_auto_cfg))]
 pub mod res_code;

satrs-shared/src/res_code.rs

@@ -7,7 +7,6 @@ use spacepackets::ByteConversionError;
 /// Simple [u16] based result code type which also allows to group related resultcodes.
 #[derive(Debug, Copy, Clone, PartialEq, Eq)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
-#[cfg_attr(feature = "defmt", derive(defmt::Format))]
 pub struct ResultU16 {
     group_id: u8,
     unique_id: u8,
@@ -20,28 +19,15 @@ impl ResultU16 {
             unique_id,
         }
     }
-
     pub fn raw(&self) -> u16 {
         ((self.group_id as u16) << 8) | self.unique_id as u16
     }
-
     pub fn group_id(&self) -> u8 {
         self.group_id
     }
-
     pub fn unique_id(&self) -> u8 {
         self.unique_id
     }
-
-    pub fn from_be_bytes(bytes: [u8; 2]) -> Self {
-        Self::from(u16::from_be_bytes(bytes))
-    }
-}
-
-impl From<u16> for ResultU16 {
-    fn from(value: u16) -> Self {
-        Self::new(((value >> 8) & 0xff) as u8, (value & 0xff) as u8)
-    }
 }
 
 impl From<ResultU16> for EcssEnumU16 {
@@ -98,14 +84,5 @@ mod tests {
         assert_eq!(written, 2);
         assert_eq!(buf[0], 1);
         assert_eq!(buf[1], 1);
-        let read_back = ResultU16::from_be_bytes(buf);
-        assert_eq!(read_back, result_code);
-    }
-
-    #[test]
-    fn test_from_u16() {
-        let result_code = ResultU16::new(1, 1);
-        let result_code_2 = ResultU16::from(result_code.raw());
-        assert_eq!(result_code, result_code_2);
     }
 }

satrs/CHANGELOG.md

@@ -8,59 +8,7 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 
 # [unreleased]
 
-# [v0.2.0] 2024-05-02
-
-## Changed
-
-- Various improvements for the PUS stack components.
-
-## Added
-
-- Added `HandlingStatus` enumeration.
-
-# [v0.2.0-rc.5] 2024-04-24
-
-## Added
-
-- Optional `defmt::Format` support for the event types, if the `defmt` feature is activated.
-
-## Changed
-
-- Removed `MpscEventReceiver`, the `EventReceiveProvider` trait is implemented directly
-  on `mpsc::Receiver<EventMessage<Event>>`
-- Renamed `PusEventDispatcher` to `PusEventTmCreatorWithMap`.
-- Renamed `DefaultPusEventU32Dispatcher` to `DefaultPusEventU32EventCreator`.
-- Renamed `PusEventMgmtBackendProvider` renamed to `PusEventReportingMap`.
-- Reanmed Event `const_new` methods to `new` and the former `new` methods to `new_checked`
-
-# [v0.2.0-rc.4] 2024-04-23
-
-## Changed
-
-- The `parse_for_ccsds_space_packets` method now expects a non-mutable slice and does not copy
-  broken tail packets anymore. It also does not expect a mutable `next_write_idx` argument anymore.
-  Instead, a `ParseResult` structure is returned which contains the `packets_found` and an
-  optional `incomplete_tail_start` value.
-
-## Fixed
-
-- `parse_for_ccsds_space_packets` did not detect CCSDS space packets at the buffer end with the
-  smallest possible size of 7 bytes.
-- TCP server component now re-registers the internal `mio::Poll` object if the client reset
-  the connection unexpectedly. Not doing so prevented the server from functioning properly
-  after a re-connect.
-
-# [v0.2.0-rc.3] 2024-04-17
-
-docs-rs hotfix 2
-
-# [v0.2.0-rc.2] 2024-04-17
-
-docs-rs hotfix
-
-# [v0.2.0-rc.1] 2024-04-17
-
-- `spacepackets` v0.11
+- `spacepackets` v0.11.0
 
 ## Added
 
@@ -83,9 +31,6 @@ docs-rs hotfix
 - Renamed `ReceivesTcCore` to `PacketSenderRaw` to better show its primary purpose. It now contains
   a `send_raw_tc` method which is not mutable anymore.
 - Renamed `TmPacketSourceCore` to `TmPacketSource`.
-- Renamed `EcssTmSenderCore` to `EcssTmSender`.
-- Renamed `StoreAddr` to `PoolAddr`.
-- Reanmed `StoreError` to `PoolError`.
 - TCP server generics order. The error generics come last now.
 - `encoding::ccsds::PacketIdValidator` renamed to `ValidatorU16Id`, which lives in the crate root.
   It can be used for both CCSDS packet ID and CCSDS APID validation.

satrs/Cargo.toml

@@ -1,8 +1,8 @@
 [package]
 name = "satrs"
-version = "0.2.0"
+version = "0.2.0-rc.0"
 edition = "2021"
-rust-version = "1.71.1"
+rust-version = "1.61"
 authors = ["Robin Mueller <muellerr@irs.uni-stuttgart.de>"]
 description = "A framework to build software for remote systems"
 homepage = "https://absatsw.irs.uni-stuttgart.de/projects/sat-rs/"
@@ -15,31 +15,17 @@ categories = ["aerospace", "aerospace::space-protocols", "no-std", "hardware-sup
 [dependencies]
 delegate = ">0.7, <=0.10"
 paste = "1"
-derive-new = "0.6"
 smallvec = "1"
 crc = "3"
 
 [dependencies.satrs-shared]
-version = ">=0.1.3, <0.2"
+version = "0.1.3"
+path = "../satrs-shared"
 
 [dependencies.num_enum]
 version = ">0.5, <=0.7"
 default-features = false
 
-[dependencies.spacepackets]
-version = "0.11"
-default-features = false
-
-[dependencies.cobs]
-git = "https://github.com/robamu/cobs.rs.git"
-version = "0.2.3"
-branch = "all_features"
-default-features = false
-
-[dependencies.num-traits]
-version = "0.2"
-default-features = false
-
 [dependencies.dyn-clone]
 version = "1"
 optional = true
@@ -52,6 +38,10 @@ optional = true
 version = "0.7"
 optional = true
 
+[dependencies.num-traits]
+version = "0.2"
+default-features = false
+
 [dependencies.downcast-rs]
 version = "1.2"
 default-features = false
@@ -85,14 +75,21 @@ version = "0.8"
 features = ["os-poll", "net"]
 optional = true
 
-[dependencies.defmt]
-version = "0.3"
-optional = true
+[dependencies.spacepackets]
+# git = "https://egit.irs.uni-stuttgart.de/rust/spacepackets.git"
+version = "0.11.0-rc.2"
+default-features = false
+
+[dependencies.cobs]
+git = "https://github.com/robamu/cobs.rs.git"
+version = "0.2.3"
+branch = "all_features"
+default-features = false
 
 [dev-dependencies]
 serde = "1"
 zerocopy = "0.7"
-once_cell = "1"
+once_cell = "1.13"
 serde_json = "1"
 rand = "0.8"
 tempfile = "3"
@@ -125,10 +122,10 @@ alloc = [
 serde = ["dep:serde", "spacepackets/serde", "satrs-shared/serde"]
 crossbeam = ["crossbeam-channel"]
 heapless = ["dep:heapless"]
-defmt = ["dep:defmt", "spacepackets/defmt"]
+defmt = ["spacepackets/defmt"]
 test_util = []
 doc-images = []
 
 [package.metadata.docs.rs]
 all-features = true
-rustdoc-args = ["--cfg", "docs_rs", "--generate-link-to-definition"]
+rustdoc-args = ["--cfg", "doc_cfg", "--generate-link-to-definition"]

satrs/src/action.rs

@@ -1,4 +1,4 @@
-use crate::{params::Params, pool::PoolAddr};
+use crate::{params::Params, pool::StoreAddr};
 
 #[cfg(feature = "alloc")]
 pub use alloc_mod::*;
@@ -21,7 +21,7 @@ impl ActionRequest {
 #[derive(Clone, Eq, PartialEq, Debug)]
 pub enum ActionRequestVariant {
     NoData,
-    StoreData(PoolAddr),
+    StoreData(StoreAddr),
     #[cfg(feature = "alloc")]
     VecData(alloc::vec::Vec<u8>),
 }

satrs/src/encoding/ccsds.rs

@@ -1,102 +1,68 @@
-use spacepackets::{CcsdsPacket, SpHeader};
-
-use crate::{tmtc::PacketSenderRaw, ComponentId};
-
-#[derive(Debug, Copy, Clone, PartialEq, Eq)]
-pub enum SpValidity {
-    Valid,
-    /// The space packet can be assumed to have a valid format, but the packet should
-    /// be skipped.
-    Skip,
-    /// The space packet or space packet header has an invalid format, for example a CRC check
-    /// failed. In that case, the parser loses the packet synchronization and needs to check for
-    /// the start of a new space packet header start again. The space packet header
-    /// [spacepackets::PacketId] can be used as a synchronization marker to detect the start
-    /// of a possible valid packet again.
-    Invalid,
-}
-
-/// Simple trait to allow user code to check the validity of a space packet.
-pub trait SpacePacketValidator {
-    fn validate(&self, sp_header: &SpHeader, raw_buf: &[u8]) -> SpValidity;
-}
-
-#[derive(Default, Debug, PartialEq, Eq)]
-pub struct ParseResult {
-    pub packets_found: u32,
-    /// If an incomplete space packet was found, its start index is indicated by this value.
-    pub incomplete_tail_start: Option<usize>,
-}
+use crate::{tmtc::PacketSenderRaw, ComponentId, ValidatorU16Id};
 
 /// This function parses a given buffer for tightly packed CCSDS space packets. It uses the
-/// [spacepackets::SpHeader] of the CCSDS packets and a user provided [SpacePacketValidator]
-/// to check whether a received space packet is relevant for processing.
+/// [spacepackets::PacketId] field of the CCSDS packets to detect the start of a CCSDS space packet
+/// and then uses the length field of the packet to extract CCSDS packets.
 ///
 /// This function is also able to deal with broken tail packets at the end as long a the parser
 /// can read the full 7 bytes which constitue a space packet header plus one byte minimal size.
 /// If broken tail packets are detected, they are moved to the front of the buffer, and the write
 /// index for future write operations will be written to the `next_write_idx` argument.
 ///
-/// The parses will behave differently based on the [SpValidity] returned from the user provided
-/// [SpacePacketValidator]:
-///
-///  1. [SpValidity::Valid]: The parser will forward all packets to the given `packet_sender` and
-///     return the number of packets found.If the [PacketSenderRaw::send_packet] calls fails, the
-///     error will be returned.
-///  2. [SpValidity::Invalid]: The parser assumes that the synchronization is lost and tries to
-///     find the start of a new space packet header by scanning all the following bytes.
-///  3. [SpValidity::Skip]: The parser skips the packet using the packet length determined from the
-///     space packet header.
+/// The parser will forward all packets which were decoded successfully to the given
+/// `packet_sender` and return the number of packets found. If the [PacketSenderRaw::send_packet]
+/// calls fails, the error will be returned.
 pub fn parse_buffer_for_ccsds_space_packets<SendError>(
-    buf: &[u8],
-    packet_validator: &(impl SpacePacketValidator + ?Sized),
+    buf: &mut [u8],
+    packet_id_validator: &(impl ValidatorU16Id + ?Sized),
     sender_id: ComponentId,
     packet_sender: &(impl PacketSenderRaw<Error = SendError> + ?Sized),
-) -> Result<ParseResult, SendError> {
-    let mut parse_result = ParseResult::default();
+    next_write_idx: &mut usize,
+) -> Result<u32, SendError> {
+    *next_write_idx = 0;
+    let mut packets_found = 0;
     let mut current_idx = 0;
     let buf_len = buf.len();
     loop {
-        if current_idx + 7 > buf.len() {
+        if current_idx + 7 >= buf.len() {
             break;
         }
-        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();
-                if (current_idx + packet_size) <= buf_len {
-                    packet_sender
-                        .send_packet(sender_id, &buf[current_idx..current_idx + packet_size])?;
-                    parse_result.packets_found += 1;
-                } else {
-                    // Move packet to start of buffer if applicable.
-                    parse_result.incomplete_tail_start = Some(current_idx);
+        let packet_id = u16::from_be_bytes(buf[current_idx..current_idx + 2].try_into().unwrap());
+        if packet_id_validator.validate(packet_id) {
+            let length_field =
+                u16::from_be_bytes(buf[current_idx + 4..current_idx + 6].try_into().unwrap());
+            let packet_size = length_field + 7;
+            if (current_idx + packet_size as usize) <= buf_len {
+                packet_sender.send_packet(
+                    sender_id,
+                    &buf[current_idx..current_idx + packet_size as usize],
+                )?;
+                packets_found += 1;
+            } else {
+                // Move packet to start of buffer if applicable.
+                if current_idx > 0 {
+                    buf.copy_within(current_idx.., 0);
+                    *next_write_idx = buf.len() - current_idx;
                 }
-                current_idx += packet_size;
-                continue;
-            }
-            SpValidity::Skip => {
-                current_idx += sp_header.total_len();
-            }
-            // We might have lost sync. Try to find the start of a new space packet header.
-            SpValidity::Invalid => {
-                current_idx += 1;
             }
+            current_idx += packet_size as usize;
+            continue;
         }
+        current_idx += 1;
     }
-    Ok(parse_result)
+    Ok(packets_found)
 }
 
 #[cfg(test)]
 mod tests {
     use spacepackets::{
         ecss::{tc::PusTcCreator, WritablePusPacket},
-        CcsdsPacket, PacketId, PacketSequenceCtrl, PacketType, SequenceFlags, SpHeader,
+        PacketId, SpHeader,
     };
 
     use crate::{encoding::tests::TcCacher, ComponentId};
 
-    use super::{parse_buffer_for_ccsds_space_packets, SpValidity, SpacePacketValidator};
+    use super::parse_buffer_for_ccsds_space_packets;
 
     const PARSER_ID: ComponentId = 0x05;
     const TEST_APID_0: u16 = 0x02;
@@ -104,30 +70,6 @@ mod tests {
     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);
 
-    #[derive(Default)]
-    struct SimpleVerificator {
-        pub enable_second_id: bool,
-    }
-
-    impl SimpleVerificator {
-        pub fn new_with_second_id() -> Self {
-            Self {
-                enable_second_id: true,
-            }
-        }
-    }
-
-    impl SpacePacketValidator for SimpleVerificator {
-        fn validate(&self, sp_header: &SpHeader, _raw_buf: &[u8]) -> super::SpValidity {
-            if sp_header.packet_id() == TEST_PACKET_ID_0
-                || (self.enable_second_id && sp_header.packet_id() == TEST_PACKET_ID_1)
-            {
-                return SpValidity::Valid;
-            }
-            SpValidity::Skip
-        }
-    }
-
     #[test]
     fn test_basic() {
         let sph = SpHeader::new_from_apid(TEST_APID_0);
@@ -136,16 +78,19 @@ mod tests {
         let packet_len = ping_tc
             .write_to_bytes(&mut buffer)
             .expect("writing packet failed");
+        let valid_packet_ids = [TEST_PACKET_ID_0];
         let tc_cacher = TcCacher::default();
+        let mut next_write_idx = 0;
         let parse_result = parse_buffer_for_ccsds_space_packets(
-            &buffer,
-            &SimpleVerificator::default(),
+            &mut buffer,
+            valid_packet_ids.as_slice(),
             PARSER_ID,
             &tc_cacher,
+            &mut next_write_idx,
         );
         assert!(parse_result.is_ok());
-        let parse_result = parse_result.unwrap();
-        assert_eq!(parse_result.packets_found, 1);
+        let parsed_packets = parse_result.unwrap();
+        assert_eq!(parsed_packets, 1);
         let mut queue = tc_cacher.tc_queue.borrow_mut();
         assert_eq!(queue.len(), 1);
         let packet_with_sender = queue.pop_front().unwrap();
@@ -165,16 +110,19 @@ mod tests {
         let packet_len_action = action_tc
             .write_to_bytes(&mut buffer[packet_len_ping..])
             .expect("writing packet failed");
+        let valid_packet_ids = [TEST_PACKET_ID_0];
         let tc_cacher = TcCacher::default();
+        let mut next_write_idx = 0;
         let parse_result = parse_buffer_for_ccsds_space_packets(
-            &buffer,
-            &SimpleVerificator::default(),
+            &mut buffer,
+            valid_packet_ids.as_slice(),
             PARSER_ID,
             &tc_cacher,
+            &mut next_write_idx,
         );
         assert!(parse_result.is_ok());
-        let parse_result = parse_result.unwrap();
-        assert_eq!(parse_result.packets_found, 2);
+        let parsed_packets = parse_result.unwrap();
+        assert_eq!(parsed_packets, 2);
         let mut queue = tc_cacher.tc_queue.borrow_mut();
         assert_eq!(queue.len(), 2);
         let packet_with_addr = queue.pop_front().unwrap();
@@ -201,13 +149,19 @@ mod tests {
         let packet_len_action = action_tc
             .write_to_bytes(&mut buffer[packet_len_ping..])
             .expect("writing packet failed");
+        let valid_packet_ids = [TEST_PACKET_ID_0, TEST_PACKET_ID_1];
         let tc_cacher = TcCacher::default();
-        let verificator = SimpleVerificator::new_with_second_id();
-        let parse_result =
-            parse_buffer_for_ccsds_space_packets(&buffer, &verificator, PARSER_ID, &tc_cacher);
+        let mut next_write_idx = 0;
+        let parse_result = parse_buffer_for_ccsds_space_packets(
+            &mut buffer,
+            valid_packet_ids.as_slice(),
+            PARSER_ID,
+            &tc_cacher,
+            &mut next_write_idx,
+        );
         assert!(parse_result.is_ok());
-        let parse_result = parse_result.unwrap();
-        assert_eq!(parse_result.packets_found, 2);
+        let parsed_packets = parse_result.unwrap();
+        assert_eq!(parsed_packets, 2);
         let mut queue = tc_cacher.tc_queue.borrow_mut();
         assert_eq!(queue.len(), 2);
         let packet_with_addr = queue.pop_front().unwrap();
@@ -232,25 +186,25 @@ mod tests {
         let packet_len_action = action_tc
             .write_to_bytes(&mut buffer[packet_len_ping..])
             .expect("writing packet failed");
+        let valid_packet_ids = [TEST_PACKET_ID_0, TEST_PACKET_ID_1];
         let tc_cacher = TcCacher::default();
-        let verificator = SimpleVerificator::new_with_second_id();
+        let mut next_write_idx = 0;
         let parse_result = parse_buffer_for_ccsds_space_packets(
-            &buffer[..packet_len_ping + packet_len_action - 4],
-            &verificator,
+            &mut buffer[..packet_len_ping + packet_len_action - 4],
+            valid_packet_ids.as_slice(),
             PARSER_ID,
             &tc_cacher,
+            &mut next_write_idx,
         );
         assert!(parse_result.is_ok());
-        let parse_result = parse_result.unwrap();
-        assert_eq!(parse_result.packets_found, 1);
-        assert!(parse_result.incomplete_tail_start.is_some());
-        let incomplete_tail_idx = parse_result.incomplete_tail_start.unwrap();
-        assert_eq!(incomplete_tail_idx, packet_len_ping);
+        let parsed_packets = parse_result.unwrap();
+        assert_eq!(parsed_packets, 1);
 
         let queue = tc_cacher.tc_queue.borrow();
         assert_eq!(queue.len(), 1);
         // The broken packet was moved to the start, so the next write index should be after the
         // last segment missing 4 bytes.
+        assert_eq!(next_write_idx, packet_len_action - 4);
     }
 
     #[test]
@@ -261,39 +215,21 @@ mod tests {
         let packet_len_ping = ping_tc
             .write_to_bytes(&mut buffer)
             .expect("writing packet failed");
+        let valid_packet_ids = [TEST_PACKET_ID_0, TEST_PACKET_ID_1];
         let tc_cacher = TcCacher::default();
-
-        let verificator = SimpleVerificator::new_with_second_id();
+        let mut next_write_idx = 0;
         let parse_result = parse_buffer_for_ccsds_space_packets(
-            &buffer[..packet_len_ping - 4],
-            &verificator,
+            &mut buffer[..packet_len_ping - 4],
+            valid_packet_ids.as_slice(),
             PARSER_ID,
             &tc_cacher,
+            &mut next_write_idx,
         );
+        assert_eq!(next_write_idx, 0);
         assert!(parse_result.is_ok());
-        let parse_result = parse_result.unwrap();
-        assert_eq!(parse_result.packets_found, 0);
+        let parsed_packets = parse_result.unwrap();
+        assert_eq!(parsed_packets, 0);
         let queue = tc_cacher.tc_queue.borrow();
         assert_eq!(queue.len(), 0);
     }
-
-    #[test]
-    fn test_smallest_packet() {
-        let ccsds_header_only = SpHeader::new(
-            PacketId::new(PacketType::Tc, true, TEST_APID_0),
-            PacketSequenceCtrl::new(SequenceFlags::Unsegmented, 0),
-            0,
-        );
-        let mut buf: [u8; 7] = [0; 7];
-        ccsds_header_only
-            .write_to_be_bytes(&mut buf)
-            .expect("writing failed");
-        let verificator = SimpleVerificator::default();
-        let tc_cacher = TcCacher::default();
-        let parse_result =
-            parse_buffer_for_ccsds_space_packets(&buf, &verificator, PARSER_ID, &tc_cacher);
-        assert!(parse_result.is_ok());
-        let parse_result = parse_result.unwrap();
-        assert_eq!(parse_result.packets_found, 1);
-    }
 }

satrs/src/encoding/mod.rs

@@ -10,10 +10,7 @@ pub(crate) mod tests {
 
     use alloc::collections::VecDeque;
 
-    use crate::{
-        tmtc::{PacketAsVec, PacketSenderRaw},
-        ComponentId,
-    };
+    use crate::{pus::PacketAsVec, tmtc::PacketSenderRaw, ComponentId};
 
     use super::cobs::encode_packet_with_cobs;
 

satrs/src/event_man.rs

@@ -1,12 +1,14 @@
 //! Event management and forwarding
 //!
-//! It is recommended to read the
-//! [sat-rs book chapter](https://absatsw.irs.uni-stuttgart.de/projects/sat-rs/book/events.html)
-//! about events first.
-//!
 //! This module provides components to perform event routing. The most important component for this
 //! task is the [EventManager]. It receives all events and then routes them to event subscribers
-//! where appropriate.
+//! where appropriate. One common use case for satellite systems is to offer a light-weight
+//! publish-subscribe mechanism and IPC mechanism for software and hardware events which are also
+//! packaged as telemetry (TM) or can trigger a system response.
+//!
+//! It is recommended to read the
+//! [sat-rs book chapter](https://absatsw.irs.uni-stuttgart.de/projects/sat-rs/book/events.html)
+//! about events first:
 //!
 //! The event manager has a listener table abstracted by the [ListenerMapProvider], which maps
 //! listener groups identified by [ListenerKey]s to a [listener ID][ComponentId].
@@ -19,8 +21,8 @@
 //!
 //!  1. Provide a concrete [EventReceiveProvider] implementation. This abstraction allow to use different
 //!     message queue backends. A straightforward implementation where dynamic memory allocation is
-//!     not a big concern would be to use the [std::sync::mpsc::Receiver] handle. The trait is
-//!     already implemented for this type.
+//!     not a big concern could use [std::sync::mpsc::channel] to do this and is provided in
+//!     form of the [MpscEventReceiver].
 //!  2. To set up event creators, create channel pairs using some message queue implementation.
 //!     Each event creator gets a (cloned) sender component which allows it to send events to the
 //!     manager.
@@ -42,12 +44,6 @@
 //! You can check [integration test](https://egit.irs.uni-stuttgart.de/rust/sat-rs/src/branch/main/satrs/tests/pus_events.rs)
 //! for a concrete example using multi-threading where events are routed to
 //! different threads.
-//!
-//! The [satrs-example](https://egit.irs.uni-stuttgart.de/rust/sat-rs/src/branch/main/satrs-example)
-//! also contains a full event manager instance and exposes a test event via the PUS test service.
-//! The [PUS event](https://egit.irs.uni-stuttgart.de/rust/sat-rs/src/branch/main/satrs-example/src/pus/event.rs)
-//! module and the generic [events module](https://egit.irs.uni-stuttgart.de/rust/sat-rs/src/branch/main/satrs-example/src/events.rs)
-//! show how the event management modules can be integrated into a more complex software.
 use crate::events::{EventU16, EventU32, GenericEvent, LargestEventRaw, LargestGroupIdRaw};
 use crate::params::Params;
 use crate::queue::GenericSendError;
@@ -161,10 +157,9 @@ pub trait SenderMapProvider<
 ///  * `SenderMap`: [SenderMapProvider]  which maps channel IDs to send providers.
 ///  * `ListenerMap`: [ListenerMapProvider] which maps listener keys to channel IDs.
 ///  * `EventSender`: [EventSendProvider] contained within the sender map which sends the events.
-///  * `Event`: The event type. This type must implement the [GenericEvent]. Currently only [EventU32]
+///  * `Ev`: The event type. This type must implement the [GenericEvent]. Currently only [EventU32]
 ///     and [EventU16] are supported.
-///  * `ParamProvider`: Auxiliary data which is sent with the event to provide optional context
-///    information
+///  * `Data`: Auxiliary data which is sent with the event to provide optional context information
 pub struct EventManager<
     EventReceiver: EventReceiveProvider<Event, ParamProvider>,
     SenderMap: SenderMapProvider<EventSender, Event, ParamProvider>,
@@ -295,7 +290,7 @@ impl<
                         for id in ids {
                             if let Some(sender) = self.sender_map.get_send_event_provider(id) {
                                 if let Err(e) = sender.send(EventMessage::new_generic(
-                                    event_msg.sender_id,
+                                    *id,
                                     event_msg.event,
                                     event_msg.params.as_ref(),
                                 )) {
@@ -336,11 +331,11 @@ pub mod alloc_mod {
 
     /// Helper type which constrains the sender map and listener map generics to the [DefaultSenderMap]
     /// and the [DefaultListenerMap]. It uses regular mpsc channels as the message queue backend.
-    pub type EventManagerWithMpsc<Event = EventU32, ParamProvider = Params> = EventManager<
-        EventU32ReceiverMpsc<ParamProvider>,
-        DefaultSenderMap<EventSenderMpsc<Event>, Event, ParamProvider>,
+    pub type EventManagerWithMpsc<EV = EventU32, AUX = Params> = EventManager<
+        MpscEventReceiver,
+        DefaultSenderMap<EventSenderMpsc<EV>, EV, AUX>,
         DefaultListenerMap,
-        EventSenderMpsc<Event>,
+        EventSenderMpsc<EV>,
     >;
 
     /// Helper type which constrains the sender map and listener map generics to the [DefaultSenderMap]
@@ -348,7 +343,7 @@ pub mod alloc_mod {
     /// [bounded mpsc senders](https://doc.rust-lang.org/std/sync/mpsc/struct.SyncSender.html) as the
     /// message queue backend.
     pub type EventManagerWithBoundedMpsc<Event = EventU32, ParamProvider = Params> = EventManager<
-        EventU32ReceiverMpsc<ParamProvider>,
+        MpscEventReceiver,
         DefaultSenderMap<EventSenderMpscBounded<Event>, Event, ParamProvider>,
         DefaultListenerMap,
         EventSenderMpscBounded<Event>,
@@ -484,16 +479,20 @@ pub mod std_mod {
     use super::*;
     use std::sync::mpsc;
 
-    impl<Event: GenericEvent + Send, ParamProvider: Debug>
-        EventReceiveProvider<Event, ParamProvider>
-        for mpsc::Receiver<EventMessage<Event, ParamProvider>>
-    {
+    pub struct MpscEventReceiver<Event: GenericEvent + Send = EventU32> {
+        receiver: mpsc::Receiver<EventMessage<Event>>,
+    }
+
+    impl<Event: GenericEvent + Send> MpscEventReceiver<Event> {
+        pub fn new(receiver: mpsc::Receiver<EventMessage<Event>>) -> Self {
+            Self { receiver }
+        }
+    }
+    impl<Event: GenericEvent + Send> EventReceiveProvider<Event> for MpscEventReceiver<Event> {
         type Error = GenericReceiveError;
 
-        fn try_recv_event(
-            &self,
-        ) -> Result<Option<EventMessage<Event, ParamProvider>>, Self::Error> {
-            match self.try_recv() {
+        fn try_recv_event(&self) -> Result<Option<EventMessage<Event>>, Self::Error> {
+            match self.receiver.try_recv() {
                 Ok(msg) => Ok(Some(msg)),
                 Err(e) => match e {
                     mpsc::TryRecvError::Empty => Ok(None),
@@ -505,10 +504,8 @@ pub mod std_mod {
         }
     }
 
-    pub type EventU32ReceiverMpsc<ParamProvider = Params> =
-        mpsc::Receiver<EventMessage<EventU32, ParamProvider>>;
-    pub type EventU16ReceiverMpsc<ParamProvider = Params> =
-        mpsc::Receiver<EventMessage<EventU16, ParamProvider>>;
+    pub type MpscEventU32Receiver = MpscEventReceiver<EventU32>;
+    pub type MpscEventU16Receiver = MpscEventReceiver<EventU16>;
 
     /// Generic event sender which uses a regular [mpsc::Sender] as the messaging backend to
     /// send events.
@@ -597,7 +594,7 @@ mod tests {
     use std::format;
     use std::sync::mpsc::{self};
 
-    const TEST_EVENT: EventU32 = EventU32::new(Severity::Info, 0, 5);
+    const TEST_EVENT: EventU32 = EventU32::const_new(Severity::INFO, 0, 5);
 
     fn check_next_event(
         expected: EventU32,
@@ -614,7 +611,6 @@ mod tests {
         res: EventRoutingResult<EventU32, Params>,
         expected: EventU32,
         expected_num_sent: u32,
-        expected_sender_id: ComponentId,
     ) {
         assert!(matches!(res, EventRoutingResult::Handled { .. }));
         if let EventRoutingResult::Handled {
@@ -623,21 +619,21 @@ mod tests {
         } = res
         {
             assert_eq!(event_msg.event, expected);
-            assert_eq!(event_msg.sender_id, expected_sender_id);
             assert_eq!(num_recipients, expected_num_sent);
         }
     }
 
     fn generic_event_man() -> (mpsc::Sender<EventMessageU32>, EventManagerWithMpsc) {
-        let (event_sender, event_receiver) = mpsc::channel();
-        (event_sender, EventManager::new(event_receiver))
+        let (event_sender, manager_queue) = mpsc::channel();
+        let event_man_receiver = MpscEventReceiver::new(manager_queue);
+        (event_sender, EventManager::new(event_man_receiver))
     }
 
     #[test]
     fn test_basic() {
         let (event_sender, mut event_man) = generic_event_man();
-        let event_grp_0 = EventU32::new(Severity::Info, 0, 0);
-        let event_grp_1_0 = EventU32::new(Severity::High, 1, 0);
+        let event_grp_0 = EventU32::new(Severity::INFO, 0, 0).unwrap();
+        let event_grp_1_0 = EventU32::new(Severity::HIGH, 1, 0).unwrap();
         let (single_event_sender, single_event_receiver) = mpsc::channel();
         let single_event_listener = EventSenderMpsc::new(0, single_event_sender);
         event_man.subscribe_single(&event_grp_0, single_event_listener.target_id());
@@ -655,7 +651,8 @@ mod tests {
             .send(EventMessage::new(TEST_COMPONENT_ID_0.id(), event_grp_0))
             .expect("Sending single error failed");
         let res = event_man.try_event_handling(&error_handler);
-        check_handled_event(res, event_grp_0, 1, TEST_COMPONENT_ID_0.id());
+        // assert!(res.is_ok());
+        check_handled_event(res, event_grp_0, 1);
         check_next_event(event_grp_0, &single_event_receiver);
 
         // Test event which is sent to all group listeners
@@ -663,7 +660,7 @@ mod tests {
             .send(EventMessage::new(TEST_COMPONENT_ID_1.id(), event_grp_1_0))
             .expect("Sending group error failed");
         let res = event_man.try_event_handling(&error_handler);
-        check_handled_event(res, event_grp_1_0, 1, TEST_COMPONENT_ID_1.id());
+        check_handled_event(res, event_grp_1_0, 1);
         check_next_event(event_grp_1_0, &group_event_receiver_0);
     }
 
@@ -673,7 +670,7 @@ mod tests {
             panic!("routing error occurred for event {:?}: {:?}", event_msg, e);
         };
         let (event_sender, mut event_man) = generic_event_man();
-        let event_grp_0 = EventU32::new(Severity::Info, 0, 0);
+        let event_grp_0 = EventU32::new(Severity::INFO, 0, 0).unwrap();
         let (single_event_sender, single_event_receiver) = mpsc::channel();
         let single_event_listener = EventSenderMpsc::new(0, single_event_sender);
         event_man.subscribe_single(&event_grp_0, single_event_listener.target_id());
@@ -686,7 +683,7 @@ mod tests {
             ))
             .expect("Sending group error failed");
         let res = event_man.try_event_handling(&error_handler);
-        check_handled_event(res, event_grp_0, 1, TEST_COMPONENT_ID_0.id());
+        check_handled_event(res, event_grp_0, 1);
         let aux = check_next_event(event_grp_0, &single_event_receiver);
         assert!(aux.is_some());
         let aux = aux.unwrap();
@@ -708,8 +705,8 @@ mod tests {
         let res = event_man.try_event_handling(error_handler);
         assert!(matches!(res, EventRoutingResult::Empty));
 
-        let event_grp_0 = EventU32::new(Severity::Info, 0, 0);
-        let event_grp_1_0 = EventU32::new(Severity::High, 1, 0);
+        let event_grp_0 = EventU32::new(Severity::INFO, 0, 0).unwrap();
+        let event_grp_1_0 = EventU32::new(Severity::HIGH, 1, 0).unwrap();
         let (event_grp_0_sender, event_grp_0_receiver) = mpsc::channel();
         let event_grp_0_and_1_listener = EventU32SenderMpsc::new(0, event_grp_0_sender);
         event_man.subscribe_group(
@@ -729,9 +726,9 @@ mod tests {
             .send(EventMessage::new(TEST_COMPONENT_ID_1.id(), event_grp_1_0))
             .expect("Sendign Event Group 1 failed");
         let res = event_man.try_event_handling(error_handler);
-        check_handled_event(res, event_grp_0, 1, TEST_COMPONENT_ID_0.id());
+        check_handled_event(res, event_grp_0, 1);
         let res = event_man.try_event_handling(error_handler);
-        check_handled_event(res, event_grp_1_0, 1, TEST_COMPONENT_ID_1.id());
+        check_handled_event(res, event_grp_1_0, 1);
 
         check_next_event(event_grp_0, &event_grp_0_receiver);
         check_next_event(event_grp_1_0, &event_grp_0_receiver);
@@ -745,8 +742,8 @@ mod tests {
             panic!("routing error occurred for event {:?}: {:?}", event_msg, e);
         };
         let (event_sender, mut event_man) = generic_event_man();
-        let event_0 = EventU32::new(Severity::Info, 0, 5);
-        let event_1 = EventU32::new(Severity::High, 1, 0);
+        let event_0 = EventU32::new(Severity::INFO, 0, 5).unwrap();
+        let event_1 = EventU32::new(Severity::HIGH, 1, 0).unwrap();
         let (event_0_tx_0, event_0_rx_0) = mpsc::channel();
         let (event_0_tx_1, event_0_rx_1) = mpsc::channel();
         let event_listener_0 = EventU32SenderMpsc::new(0, event_0_tx_0);
@@ -761,7 +758,7 @@ mod tests {
             .send(EventMessage::new(TEST_COMPONENT_ID_0.id(), event_0))
             .expect("Triggering Event 0 failed");
         let res = event_man.try_event_handling(error_handler);
-        check_handled_event(res, event_0, 2, TEST_COMPONENT_ID_0.id());
+        check_handled_event(res, event_0, 2);
         check_next_event(event_0, &event_0_rx_0);
         check_next_event(event_0, &event_0_rx_1);
         event_man.subscribe_group(event_1.group_id(), event_listener_0_sender_id);
@@ -774,9 +771,9 @@ mod tests {
 
         // 3 Events messages will be sent now
         let res = event_man.try_event_handling(error_handler);
-        check_handled_event(res, event_0, 2, TEST_COMPONENT_ID_0.id());
+        check_handled_event(res, event_0, 2);
         let res = event_man.try_event_handling(error_handler);
-        check_handled_event(res, event_1, 1, TEST_COMPONENT_ID_1.id());
+        check_handled_event(res, event_1, 1);
         // Both the single event and the group event should arrive now
         check_next_event(event_0, &event_0_rx_0);
         check_next_event(event_1, &event_0_rx_0);
@@ -788,7 +785,7 @@ mod tests {
             .send(EventMessage::new(TEST_COMPONENT_ID_0.id(), event_1))
             .expect("Triggering Event 1 failed");
         let res = event_man.try_event_handling(error_handler);
-        check_handled_event(res, event_1, 1, TEST_COMPONENT_ID_0.id());
+        check_handled_event(res, event_1, 1);
     }
 
     #[test]
@@ -796,10 +793,11 @@ mod tests {
         let error_handler = |event_msg: &EventMessageU32, e: EventRoutingError| {
             panic!("routing error occurred for event {:?}: {:?}", event_msg, e);
         };
-        let (event_sender, event_receiver) = mpsc::channel();
-        let mut event_man = EventManagerWithMpsc::new(event_receiver);
-        let event_0 = EventU32::new(Severity::Info, 0, 5);
-        let event_1 = EventU32::new(Severity::High, 1, 0);
+        let (event_sender, manager_queue) = mpsc::channel();
+        let event_man_receiver = MpscEventReceiver::new(manager_queue);
+        let mut event_man = EventManagerWithMpsc::new(event_man_receiver);
+        let event_0 = EventU32::new(Severity::INFO, 0, 5).unwrap();
+        let event_1 = EventU32::new(Severity::HIGH, 1, 0).unwrap();
         let (event_0_tx_0, all_events_rx) = mpsc::channel();
         let all_events_listener = EventU32SenderMpsc::new(0, event_0_tx_0);
         event_man.subscribe_all(all_events_listener.target_id());
@@ -811,9 +809,9 @@ mod tests {
             .send(EventMessage::new(TEST_COMPONENT_ID_1.id(), event_1))
             .expect("Triggering event 1 failed");
         let res = event_man.try_event_handling(error_handler);
-        check_handled_event(res, event_0, 1, TEST_COMPONENT_ID_0.id());
+        check_handled_event(res, event_0, 1);
         let res = event_man.try_event_handling(error_handler);
-        check_handled_event(res, event_1, 1, TEST_COMPONENT_ID_1.id());
+        check_handled_event(res, event_1, 1);
         check_next_event(event_0, &all_events_rx);
         check_next_event(event_1, &all_events_rx);
     }

satrs/src/events.rs

@@ -20,12 +20,12 @@
 //! ```
 //! use satrs::events::{EventU16, EventU32, EventU32TypedSev, Severity, SeverityHigh, SeverityInfo};
 //!
-//! const MSG_RECVD: EventU32TypedSev<SeverityInfo> = EventU32TypedSev::new(1, 0);
-//! const MSG_FAILED: EventU32 = EventU32::new(Severity::Low, 1, 1);
+//! const MSG_RECVD: EventU32TypedSev<SeverityInfo> = EventU32TypedSev::const_new(1, 0);
+//! const MSG_FAILED: EventU32 = EventU32::const_new(Severity::LOW, 1, 1);
 //!
-//! const TEMPERATURE_HIGH: EventU32TypedSev<SeverityHigh> = EventU32TypedSev::new(2, 0);
+//! const TEMPERATURE_HIGH: EventU32TypedSev<SeverityHigh> = EventU32TypedSev::const_new(2, 0);
 //!
-//! let small_event = EventU16::new(Severity::Info, 3, 0);
+//! let small_event = EventU16::new(Severity::INFO, 3, 0);
 //! ```
 use core::fmt::Debug;
 use core::hash::Hash;
@@ -40,17 +40,12 @@ pub type LargestEventRaw = u32;
 /// Using a type definition allows to change this to u32 in the future more easily
 pub type LargestGroupIdRaw = u16;
 
-pub const MAX_GROUP_ID_U32_EVENT: u16 = 2_u16.pow(14) - 1;
-pub const MAX_GROUP_ID_U16_EVENT: u16 = 2_u16.pow(6) - 1;
-
 #[derive(Copy, Clone, PartialEq, Eq, Debug, Hash)]
-#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
-#[cfg_attr(feature = "defmt", derive(defmt::Format))]
 pub enum Severity {
-    Info = 0,
-    Low = 1,
-    Medium = 2,
-    High = 3,
+    INFO = 0,
+    LOW = 1,
+    MEDIUM = 2,
+    HIGH = 3,
 }
 
 pub trait HasSeverity: Debug + PartialEq + Eq + Copy + Clone {
@@ -61,28 +56,28 @@ pub trait HasSeverity: Debug + PartialEq + Eq + Copy + Clone {
 #[derive(Debug, PartialEq, Eq, Copy, Clone)]
 pub struct SeverityInfo {}
 impl HasSeverity for SeverityInfo {
-    const SEVERITY: Severity = Severity::Info;
+    const SEVERITY: Severity = Severity::INFO;
 }
 
 /// Type level support struct
 #[derive(Debug, PartialEq, Eq, Copy, Clone)]
 pub struct SeverityLow {}
 impl HasSeverity for SeverityLow {
-    const SEVERITY: Severity = Severity::Low;
+    const SEVERITY: Severity = Severity::LOW;
 }
 
 /// Type level support struct
 #[derive(Debug, PartialEq, Eq, Copy, Clone)]
 pub struct SeverityMedium {}
 impl HasSeverity for SeverityMedium {
-    const SEVERITY: Severity = Severity::Medium;
+    const SEVERITY: Severity = Severity::MEDIUM;
 }
 
 /// Type level support struct
 #[derive(Debug, PartialEq, Eq, Copy, Clone)]
 pub struct SeverityHigh {}
 impl HasSeverity for SeverityHigh {
-    const SEVERITY: Severity = Severity::High;
+    const SEVERITY: Severity = Severity::HIGH;
 }
 
 pub trait GenericEvent: EcssEnumeration + Copy + Clone {
@@ -104,29 +99,27 @@ impl TryFrom<u8> for Severity {
 
     fn try_from(value: u8) -> Result<Self, Self::Error> {
         match value {
-            x if x == Severity::Info as u8 => Ok(Severity::Info),
-            x if x == Severity::Low as u8 => Ok(Severity::Low),
-            x if x == Severity::Medium as u8 => Ok(Severity::Medium),
-            x if x == Severity::High as u8 => Ok(Severity::High),
+            x if x == Severity::INFO as u8 => Ok(Severity::INFO),
+            x if x == Severity::LOW as u8 => Ok(Severity::LOW),
+            x if x == Severity::MEDIUM as u8 => Ok(Severity::MEDIUM),
+            x if x == Severity::HIGH as u8 => Ok(Severity::HIGH),
             _ => Err(()),
         }
     }
 }
 
 #[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
-#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
-#[cfg_attr(feature = "defmt", derive(defmt::Format))]
-struct EventBase<Raw, GroupId, UniqueId> {
+struct EventBase<RAW, GID, UID> {
     severity: Severity,
-    group_id: GroupId,
-    unique_id: UniqueId,
-    phantom: PhantomData<Raw>,
+    group_id: GID,
+    unique_id: UID,
+    phantom: PhantomData<RAW>,
 }
 
-impl<Raw: ToBeBytes, GroupId, UniqueId> EventBase<Raw, GroupId, UniqueId> {
+impl<RAW: ToBeBytes, GID, UID> EventBase<RAW, GID, UID> {
     fn write_to_bytes(
         &self,
-        raw: Raw,
+        raw: RAW,
         buf: &mut [u8],
         width: usize,
     ) -> Result<usize, ByteConversionError> {
@@ -274,7 +267,6 @@ macro_rules! const_from_fn {
 }
 
 #[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
-#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct EventU32 {
     base: EventBase<u32, u16, u16>,
 }
@@ -317,12 +309,12 @@ impl EventU32 {
     ///        next 14 bits after the severity. Therefore, the size is limited by dec 16383 hex 0x3FFF.
     /// * `unique_id`: Each event has a unique 16 bit ID occupying the last 16 bits of the
     ///       raw event ID
-    pub fn new_checked(
+    pub fn new(
         severity: Severity,
         group_id: <Self as GenericEvent>::GroupId,
         unique_id: <Self as GenericEvent>::UniqueId,
     ) -> Option<Self> {
-        if group_id > MAX_GROUP_ID_U32_EVENT {
+        if group_id > (2u16.pow(14) - 1) {
             return None;
         }
         Some(Self {
@@ -334,14 +326,12 @@ impl EventU32 {
             },
         })
     }
-
-    /// This constructor will panic if the passed group is is larger than [MAX_GROUP_ID_U32_EVENT].
-    pub const fn new(
+    pub const fn const_new(
         severity: Severity,
         group_id: <Self as GenericEvent>::GroupId,
         unique_id: <Self as GenericEvent>::UniqueId,
     ) -> Self {
-        if group_id > MAX_GROUP_ID_U32_EVENT {
+        if group_id > (2u16.pow(14) - 1) {
             panic!("Group ID too large");
         }
         Self {
@@ -354,16 +344,50 @@ impl EventU32 {
         }
     }
 
-    pub fn from_be_bytes(bytes: [u8; 4]) -> Self {
-        Self::from(u32::from_be_bytes(bytes))
-    }
-
     const_from_fn!(const_from_info, EventU32TypedSev, SeverityInfo);
     const_from_fn!(const_from_low, EventU32TypedSev, SeverityLow);
     const_from_fn!(const_from_medium, EventU32TypedSev, SeverityMedium);
     const_from_fn!(const_from_high, EventU32TypedSev, SeverityHigh);
 }
 
+impl<SEVERITY: HasSeverity> EventU32TypedSev<SEVERITY> {
+    /// This is similar to [EventU32::new] but the severity is a type generic, which allows to
+    /// have distinct types for events with different severities
+    pub fn new(
+        group_id: <Self as GenericEvent>::GroupId,
+        unique_id: <Self as GenericEvent>::UniqueId,
+    ) -> Option<Self> {
+        let event = EventU32::new(SEVERITY::SEVERITY, group_id, unique_id)?;
+        Some(Self {
+            event,
+            phantom: PhantomData,
+        })
+    }
+
+    /// Const version of [Self::new], but panics on invalid group ID input values.
+    pub const fn const_new(
+        group_id: <Self as GenericEvent>::GroupId,
+        unique_id: <Self as GenericEvent>::UniqueId,
+    ) -> Self {
+        let event = EventU32::const_new(SEVERITY::SEVERITY, group_id, unique_id);
+        Self {
+            event,
+            phantom: PhantomData,
+        }
+    }
+
+    fn try_from_generic(expected: Severity, raw: u32) -> Result<Self, Severity> {
+        let severity = Severity::try_from(((raw >> 30) & 0b11) as u8).unwrap();
+        if severity != expected {
+            return Err(severity);
+        }
+        Ok(Self::const_new(
+            ((raw >> 16) & 0x3FFF) as u16,
+            (raw & 0xFFFF) as u16,
+        ))
+    }
+}
+
 impl From<u32> for EventU32 {
     fn from(raw: u32) -> Self {
         // Severity conversion from u8 should never fail
@@ -371,10 +395,15 @@ impl From<u32> for EventU32 {
         let group_id = ((raw >> 16) & 0x3FFF) as u16;
         let unique_id = (raw & 0xFFFF) as u16;
         // Sanitized input, should never fail
-        Self::new(severity, group_id, unique_id)
+        Self::const_new(severity, group_id, unique_id)
     }
 }
 
+try_from_impls!(SeverityInfo, Severity::INFO, u32, EventU32TypedSev);
+try_from_impls!(SeverityLow, Severity::LOW, u32, EventU32TypedSev);
+try_from_impls!(SeverityMedium, Severity::MEDIUM, u32, EventU32TypedSev);
+try_from_impls!(SeverityHigh, Severity::HIGH, u32, EventU32TypedSev);
+
 impl UnsignedEnum for EventU32 {
     fn size(&self) -> usize {
         core::mem::size_of::<u32>()
@@ -395,49 +424,6 @@ impl EcssEnumeration for EventU32 {
     }
 }
 
-impl<SEVERITY: HasSeverity> EventU32TypedSev<SEVERITY> {
-    /// This is similar to [EventU32::new] but the severity is a type generic, which allows to
-    /// have distinct types for events with different severities
-    pub fn new_checked(
-        group_id: <Self as GenericEvent>::GroupId,
-        unique_id: <Self as GenericEvent>::UniqueId,
-    ) -> Option<Self> {
-        let event = EventU32::new_checked(SEVERITY::SEVERITY, group_id, unique_id)?;
-        Some(Self {
-            event,
-            phantom: PhantomData,
-        })
-    }
-
-    /// This constructor will panic if the `group_id` is larger than [MAX_GROUP_ID_U32_EVENT].
-    pub const fn new(
-        group_id: <Self as GenericEvent>::GroupId,
-        unique_id: <Self as GenericEvent>::UniqueId,
-    ) -> Self {
-        let event = EventU32::new(SEVERITY::SEVERITY, group_id, unique_id);
-        Self {
-            event,
-            phantom: PhantomData,
-        }
-    }
-
-    fn try_from_generic(expected: Severity, raw: u32) -> Result<Self, Severity> {
-        let severity = Severity::try_from(((raw >> 30) & 0b11) as u8).unwrap();
-        if severity != expected {
-            return Err(severity);
-        }
-        Ok(Self::new(
-            ((raw >> 16) & 0x3FFF) as u16,
-            (raw & 0xFFFF) as u16,
-        ))
-    }
-}
-
-try_from_impls!(SeverityInfo, Severity::Info, u32, EventU32TypedSev);
-try_from_impls!(SeverityLow, Severity::Low, u32, EventU32TypedSev);
-try_from_impls!(SeverityMedium, Severity::Medium, u32, EventU32TypedSev);
-try_from_impls!(SeverityHigh, Severity::High, u32, EventU32TypedSev);
-
 //noinspection RsTraitImplementation
 impl<SEVERITY: HasSeverity> UnsignedEnum for EventU32TypedSev<SEVERITY> {
     delegate!(to self.event {
@@ -455,8 +441,6 @@ impl<SEVERITY: HasSeverity> EcssEnumeration for EventU32TypedSev<SEVERITY> {
 }
 
 #[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
-#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
-#[cfg_attr(feature = "defmt", derive(defmt::Format))]
 pub struct EventU16 {
     base: EventBase<u16, u8, u8>,
 }
@@ -491,7 +475,7 @@ impl EventU16 {
     ///        next 6 bits after the severity. Therefore, the size is limited by dec 63 hex 0x3F.
     /// * `unique_id`: Each event has a unique 8 bit ID occupying the last 8 bits of the
     ///       raw event ID
-    pub fn new_checked(
+    pub fn new(
         severity: Severity,
         group_id: <Self as GenericEvent>::GroupId,
         unique_id: <Self as GenericEvent>::UniqueId,
@@ -509,8 +493,8 @@ impl EventU16 {
         })
     }
 
-    /// This constructor will panic if the `group_id` is larger than [MAX_GROUP_ID_U16_EVENT].
-    pub const fn new(
+    /// Const version of [Self::new], but panics on invalid group ID input values.
+    pub const fn const_new(
         severity: Severity,
         group_id: <Self as GenericEvent>::GroupId,
         unique_id: <Self as GenericEvent>::UniqueId,
@@ -527,26 +511,52 @@ impl EventU16 {
             },
         }
     }
-    pub fn from_be_bytes(bytes: [u8; 2]) -> Self {
-        Self::from(u16::from_be_bytes(bytes))
-    }
-
     const_from_fn!(const_from_info, EventU16TypedSev, SeverityInfo);
     const_from_fn!(const_from_low, EventU16TypedSev, SeverityLow);
     const_from_fn!(const_from_medium, EventU16TypedSev, SeverityMedium);
     const_from_fn!(const_from_high, EventU16TypedSev, SeverityHigh);
 }
 
-impl From<u16> for EventU16 {
-    fn from(raw: <Self as GenericEvent>::Raw) -> Self {
+impl<SEVERITY: HasSeverity> EventU16TypedSev<SEVERITY> {
+    /// This is similar to [EventU16::new] but the severity is a type generic, which allows to
+    /// have distinct types for events with different severities
+    pub fn new(
+        group_id: <Self as GenericEvent>::GroupId,
+        unique_id: <Self as GenericEvent>::UniqueId,
+    ) -> Option<Self> {
+        let event = EventU16::new(SEVERITY::SEVERITY, group_id, unique_id)?;
+        Some(Self {
+            event,
+            phantom: PhantomData,
+        })
+    }
+
+    /// Const version of [Self::new], but panics on invalid group ID input values.
+    pub const fn const_new(
+        group_id: <Self as GenericEvent>::GroupId,
+        unique_id: <Self as GenericEvent>::UniqueId,
+    ) -> Self {
+        let event = EventU16::const_new(SEVERITY::SEVERITY, group_id, unique_id);
+        Self {
+            event,
+            phantom: PhantomData,
+        }
+    }
+
+    fn try_from_generic(expected: Severity, raw: u16) -> Result<Self, Severity> {
         let severity = Severity::try_from(((raw >> 14) & 0b11) as u8).unwrap();
-        let group_id = ((raw >> 8) & 0x3F) as u8;
-        let unique_id = (raw & 0xFF) as u8;
-        // Sanitized input, new call should never fail
-        Self::new(severity, group_id, unique_id)
+        if severity != expected {
+            return Err(severity);
+        }
+        Ok(Self::const_new(
+            ((raw >> 8) & 0x3F) as u8,
+            (raw & 0xFF) as u8,
+        ))
     }
 }
 
+impl_event_provider!(EventU16, EventU16TypedSev, u16, u8, u8);
+
 impl UnsignedEnum for EventU16 {
     fn size(&self) -> usize {
         core::mem::size_of::<u16>()
@@ -567,43 +577,6 @@ impl EcssEnumeration for EventU16 {
     }
 }
 
-impl<SEVERITY: HasSeverity> EventU16TypedSev<SEVERITY> {
-    /// This is similar to [EventU16::new] but the severity is a type generic, which allows to
-    /// have distinct types for events with different severities
-    pub fn new_checked(
-        group_id: <Self as GenericEvent>::GroupId,
-        unique_id: <Self as GenericEvent>::UniqueId,
-    ) -> Option<Self> {
-        let event = EventU16::new_checked(SEVERITY::SEVERITY, group_id, unique_id)?;
-        Some(Self {
-            event,
-            phantom: PhantomData,
-        })
-    }
-
-    /// This constructor will panic if the `group_id` is larger than [MAX_GROUP_ID_U16_EVENT].
-    pub const fn new(
-        group_id: <Self as GenericEvent>::GroupId,
-        unique_id: <Self as GenericEvent>::UniqueId,
-    ) -> Self {
-        let event = EventU16::new(SEVERITY::SEVERITY, group_id, unique_id);
-        Self {
-            event,
-            phantom: PhantomData,
-        }
-    }
-
-    fn try_from_generic(expected: Severity, raw: u16) -> Result<Self, Severity> {
-        let severity = Severity::try_from(((raw >> 14) & 0b11) as u8).unwrap();
-        if severity != expected {
-            return Err(severity);
-        }
-        Ok(Self::new(((raw >> 8) & 0x3F) as u8, (raw & 0xFF) as u8))
-    }
-}
-
-impl_event_provider!(EventU16, EventU16TypedSev, u16, u8, u8);
-
 //noinspection RsTraitImplementation
 impl<SEVERITY: HasSeverity> UnsignedEnum for EventU16TypedSev<SEVERITY> {
     delegate!(to self.event {
@@ -620,10 +593,20 @@ impl<SEVERITY: HasSeverity> EcssEnumeration for EventU16TypedSev<SEVERITY> {
     });
 }
 
-try_from_impls!(SeverityInfo, Severity::Info, u16, EventU16TypedSev);
-try_from_impls!(SeverityLow, Severity::Low, u16, EventU16TypedSev);
-try_from_impls!(SeverityMedium, Severity::Medium, u16, EventU16TypedSev);
-try_from_impls!(SeverityHigh, Severity::High, u16, EventU16TypedSev);
+impl From<u16> for EventU16 {
+    fn from(raw: <Self as GenericEvent>::Raw) -> Self {
+        let severity = Severity::try_from(((raw >> 14) & 0b11) as u8).unwrap();
+        let group_id = ((raw >> 8) & 0x3F) as u8;
+        let unique_id = (raw & 0xFF) as u8;
+        // Sanitized input, new call should never fail
+        Self::const_new(severity, group_id, unique_id)
+    }
+}
+
+try_from_impls!(SeverityInfo, Severity::INFO, u16, EventU16TypedSev);
+try_from_impls!(SeverityLow, Severity::LOW, u16, EventU16TypedSev);
+try_from_impls!(SeverityMedium, Severity::MEDIUM, u16, EventU16TypedSev);
+try_from_impls!(SeverityHigh, Severity::HIGH, u16, EventU16TypedSev);
 
 impl<Severity: HasSeverity> PartialEq<EventU32> for EventU32TypedSev<Severity> {
     #[inline]
@@ -664,10 +647,12 @@ mod tests {
         assert_eq!(size_of::<T>(), val);
     }
 
-    const INFO_EVENT: EventU32TypedSev<SeverityInfo> = EventU32TypedSev::new(0, 0);
-    const INFO_EVENT_SMALL: EventU16TypedSev<SeverityInfo> = EventU16TypedSev::new(0, 0);
-    const HIGH_SEV_EVENT: EventU32TypedSev<SeverityHigh> = EventU32TypedSev::new(0x3FFF, 0xFFFF);
-    const HIGH_SEV_EVENT_SMALL: EventU16TypedSev<SeverityHigh> = EventU16TypedSev::new(0x3F, 0xff);
+    const INFO_EVENT: EventU32TypedSev<SeverityInfo> = EventU32TypedSev::const_new(0, 0);
+    const INFO_EVENT_SMALL: EventU16TypedSev<SeverityInfo> = EventU16TypedSev::const_new(0, 0);
+    const HIGH_SEV_EVENT: EventU32TypedSev<SeverityHigh> =
+        EventU32TypedSev::const_new(0x3FFF, 0xFFFF);
+    const HIGH_SEV_EVENT_SMALL: EventU16TypedSev<SeverityHigh> =
+        EventU16TypedSev::const_new(0x3F, 0xff);
 
     /// This working is a test in itself.
     const INFO_REDUCED: EventU32 = EventU32::const_from_info(INFO_EVENT);
@@ -698,7 +683,7 @@ mod tests {
 
     #[test]
     fn test_normal_event_getters() {
-        assert_eq!(INFO_EVENT.severity(), Severity::Info);
+        assert_eq!(INFO_EVENT.severity(), Severity::INFO);
         assert_eq!(INFO_EVENT.unique_id(), 0);
         assert_eq!(INFO_EVENT.group_id(), 0);
         let raw_event = INFO_EVENT.raw();
@@ -707,7 +692,7 @@ mod tests {
 
     #[test]
     fn test_small_event_getters() {
-        assert_eq!(INFO_EVENT_SMALL.severity(), Severity::Info);
+        assert_eq!(INFO_EVENT_SMALL.severity(), Severity::INFO);
         assert_eq!(INFO_EVENT_SMALL.unique_id(), 0);
         assert_eq!(INFO_EVENT_SMALL.group_id(), 0);
         let raw_event = INFO_EVENT_SMALL.raw();
@@ -716,7 +701,7 @@ mod tests {
 
     #[test]
     fn all_ones_event_regular() {
-        assert_eq!(HIGH_SEV_EVENT.severity(), Severity::High);
+        assert_eq!(HIGH_SEV_EVENT.severity(), Severity::HIGH);
         assert_eq!(HIGH_SEV_EVENT.group_id(), 0x3FFF);
         assert_eq!(HIGH_SEV_EVENT.unique_id(), 0xFFFF);
         let raw_event = HIGH_SEV_EVENT.raw();
@@ -725,7 +710,7 @@ mod tests {
 
     #[test]
     fn all_ones_event_small() {
-        assert_eq!(HIGH_SEV_EVENT_SMALL.severity(), Severity::High);
+        assert_eq!(HIGH_SEV_EVENT_SMALL.severity(), Severity::HIGH);
         assert_eq!(HIGH_SEV_EVENT_SMALL.group_id(), 0x3F);
         assert_eq!(HIGH_SEV_EVENT_SMALL.unique_id(), 0xFF);
         let raw_event = HIGH_SEV_EVENT_SMALL.raw();
@@ -734,19 +719,18 @@ mod tests {
 
     #[test]
     fn invalid_group_id_normal() {
-        assert!(EventU32TypedSev::<SeverityMedium>::new_checked(2_u16.pow(14), 0).is_none());
+        assert!(EventU32TypedSev::<SeverityMedium>::new(2_u16.pow(14), 0).is_none());
     }
 
     #[test]
     fn invalid_group_id_small() {
-        assert!(EventU16TypedSev::<SeverityMedium>::new_checked(2_u8.pow(6), 0).is_none());
+        assert!(EventU16TypedSev::<SeverityMedium>::new(2_u8.pow(6), 0).is_none());
     }
 
     #[test]
     fn regular_new() {
         assert_eq!(
-            EventU32TypedSev::<SeverityInfo>::new_checked(0, 0)
-                .expect("Creating regular event failed"),
+            EventU32TypedSev::<SeverityInfo>::new(0, 0).expect("Creating regular event failed"),
             INFO_EVENT
         );
     }
@@ -754,8 +738,7 @@ mod tests {
     #[test]
     fn small_new() {
         assert_eq!(
-            EventU16TypedSev::<SeverityInfo>::new_checked(0, 0)
-                .expect("Creating regular event failed"),
+            EventU16TypedSev::<SeverityInfo>::new(0, 0).expect("Creating regular event failed"),
             INFO_EVENT_SMALL
         );
     }
@@ -794,8 +777,6 @@ mod tests {
         assert!(HIGH_SEV_EVENT.write_to_be_bytes(&mut buf).is_ok());
         let val_from_raw = u32::from_be_bytes(buf);
         assert_eq!(val_from_raw, 0xFFFFFFFF);
-        let event_read_back = EventU32::from_be_bytes(buf);
-        assert_eq!(event_read_back, HIGH_SEV_EVENT);
     }
 
     #[test]
@@ -804,8 +785,6 @@ mod tests {
         assert!(HIGH_SEV_EVENT_SMALL.write_to_be_bytes(&mut buf).is_ok());
         let val_from_raw = u16::from_be_bytes(buf);
         assert_eq!(val_from_raw, 0xFFFF);
-        let event_read_back = EventU16::from_be_bytes(buf);
-        assert_eq!(event_read_back, HIGH_SEV_EVENT_SMALL);
     }
 
     #[test]
@@ -836,13 +815,13 @@ mod tests {
     fn severity_from_invalid_raw_val() {
         let invalid = 0xFF;
         assert!(Severity::try_from(invalid).is_err());
-        let invalid = Severity::High as u8 + 1;
+        let invalid = Severity::HIGH as u8 + 1;
         assert!(Severity::try_from(invalid).is_err());
     }
 
     #[test]
     fn reduction() {
-        let event = EventU32TypedSev::<SeverityInfo>::new(1, 1);
+        let event = EventU32TypedSev::<SeverityInfo>::const_new(1, 1);
         let raw = event.raw();
         let reduced: EventU32 = event.into();
         assert_eq!(reduced.group_id(), 1);

satrs/src/hal/std/tcp_cobs_server.rs

@@ -181,8 +181,8 @@ impl<
             /// useful if using the port number 0 for OS auto-assignment.
             pub fn local_addr(&self) -> std::io::Result<SocketAddr>;
 
-            /// Delegation to the [TcpTmtcGenericServer::handle_all_connections] call.
-            pub fn handle_all_connections(
+            /// Delegation to the [TcpTmtcGenericServer::handle_next_connection] call.
+            pub fn handle_next_connection(
                 &mut self,
                 poll_duration: Option<Duration>,
             ) -> Result<ConnectionResult, TcpTmtcError<TmError, TcError>>;
@@ -211,8 +211,8 @@ mod tests {
             tests::{ConnectionFinishedHandler, SyncTmSource},
             ConnectionResult, ServerConfig,
         },
+        pus::PacketAsVec,
         queue::GenericSendError,
-        tmtc::PacketAsVec,
         ComponentId,
     };
     use alloc::sync::Arc;
@@ -274,7 +274,7 @@ mod tests {
         let set_if_done = conn_handled.clone();
         // Call the connection handler in separate thread, does block.
         thread::spawn(move || {
-            let result = tcp_server.handle_all_connections(Some(Duration::from_millis(100)));
+            let result = tcp_server.handle_next_connection(Some(Duration::from_millis(100)));
             if result.is_err() {
                 panic!("handling connection failed: {:?}", result.unwrap_err());
             }
@@ -330,7 +330,7 @@ mod tests {
         let set_if_done = conn_handled.clone();
         // Call the connection handler in separate thread, does block.
         thread::spawn(move || {
-            let result = tcp_server.handle_all_connections(Some(Duration::from_millis(100)));
+            let result = tcp_server.handle_next_connection(Some(Duration::from_millis(100)));
             if result.is_err() {
                 panic!("handling connection failed: {:?}", result.unwrap_err());
             }
@@ -436,7 +436,7 @@ mod tests {
         let start = Instant::now();
         // Call the connection handler in separate thread, does block.
         let thread_jh = thread::spawn(move || loop {
-            let result = tcp_server.handle_all_connections(Some(Duration::from_millis(20)));
+            let result = tcp_server.handle_next_connection(Some(Duration::from_millis(20)));
             if result.is_err() {
                 panic!("handling connection failed: {:?}", result.unwrap_err());
             }
@@ -470,7 +470,7 @@ mod tests {
         let start = Instant::now();
         // Call the connection handler in separate thread, does block.
         let thread_jh = thread::spawn(move || loop {
-            let result = tcp_server.handle_all_connections(Some(Duration::from_millis(20)));
+            let result = tcp_server.handle_next_connection(Some(Duration::from_millis(20)));
             if result.is_err() {
                 panic!("handling connection failed: {:?}", result.unwrap_err());
             }

satrs/src/hal/std/tcp_server.rs

@@ -9,6 +9,8 @@ use mio::{Events, Interest, Poll, Token};
 use socket2::{Domain, Socket, Type};
 use std::io::{self, Read};
 use std::net::SocketAddr;
+// use std::net::TcpListener;
+// use std::net::{SocketAddr, TcpStream};
 use std::thread;
 
 use crate::tmtc::{PacketSenderRaw, PacketSource};
@@ -17,7 +19,9 @@ use thiserror::Error;
 
 // Re-export the TMTC in COBS server.
 pub use crate::hal::std::tcp_cobs_server::{CobsTcParser, CobsTmSender, TcpTmtcInCobsServer};
-pub use crate::hal::std::tcp_spacepackets_server::{SpacepacketsTmSender, TcpSpacepacketsServer};
+pub use crate::hal::std::tcp_spacepackets_server::{
+    SpacepacketsTcParser, SpacepacketsTmSender, TcpSpacepacketsServer,
+};
 
 /// Configuration struct for the generic TCP TMTC server
 ///
@@ -161,7 +165,6 @@ pub trait TcpTmSender<TmError, TcError> {
 /// Currently, this framework offers the following concrete implementations:
 ///
 /// 1. [TcpTmtcInCobsServer] to exchange TMTC wrapped inside the COBS framing protocol.
-/// 2. [TcpSpacepacketsServer] to exchange space packets via TCP.
 pub struct TcpTmtcGenericServer<
     TmSource: PacketSource<Error = TmError>,
     TcSender: PacketSenderRaw<Error = TcSendError>,
@@ -242,16 +245,13 @@ impl<
         // Create a poll instance.
         let poll = Poll::new()?;
         // Create storage for events.
-        let events = Events::with_capacity(32);
+        let events = Events::with_capacity(10);
         let listener: std::net::TcpListener = socket.into();
         let mut mio_listener = TcpListener::from_std(listener);
 
         // Start listening for incoming connections.
-        poll.registry().register(
-            &mut mio_listener,
-            Token(0),
-            Interest::READABLE | Interest::WRITABLE,
-        )?;
+        poll.registry()
+            .register(&mut mio_listener, Token(0), Interest::READABLE)?;
 
         Ok(Self {
             id: cfg.id,
@@ -281,11 +281,11 @@ impl<
         self.listener.local_addr()
     }
 
-    /// This call is used to handle all connection from clients. Right now, it performs
+    /// This call is used to handle the next connection to a client. Right now, it performs
     /// the following steps:
     ///
-    /// 1. It calls the [std::net::TcpListener::accept] method until a client connects. An optional
-    ///    timeout can be specified for non-blocking acceptance.
+    /// 1. It calls the [std::net::TcpListener::accept] method internally using the blocking API
+    ///    until a client connects.
     /// 2. It reads all the telecommands from the client and parses all received data using the
     ///    user specified [TcpTcParser].
     /// 3. After reading and parsing all telecommands, it sends back all telemetry using the
@@ -294,7 +294,7 @@ impl<
     /// The server will delay for a user-specified period if the client connects to the server
     /// for prolonged periods and there is no traffic for the server. This is the case if the
     /// client does not send any telecommands and no telemetry needs to be sent back to the client.
-    pub fn handle_all_connections(
+    pub fn handle_next_connection(
         &mut self,
         poll_timeout: Option<Duration>,
     ) -> Result<ConnectionResult, TcpTmtcError<TmError, TcSendError>> {
@@ -318,17 +318,11 @@ impl<
             loop {
                 match self.listener.accept() {
                     Ok((stream, addr)) => {
-                        if let Err(e) = self.handle_accepted_connection(stream, addr) {
-                            self.reregister_poll_interest()?;
-                            return Err(e);
-                        }
+                        self.handle_accepted_connection(stream, addr)?;
                         handled_connections += 1;
                     }
                     Err(ref err) if err.kind() == io::ErrorKind::WouldBlock => break,
-                    Err(err) => {
-                        self.reregister_poll_interest()?;
-                        return Err(TcpTmtcError::Io(err));
-                    }
+                    Err(err) => return Err(TcpTmtcError::Io(err)),
                 }
             }
         }
@@ -338,14 +332,6 @@ impl<
         Ok(ConnectionResult::AcceptTimeout)
     }
 
-    fn reregister_poll_interest(&mut self) -> io::Result<()> {
-        self.poll.registry().reregister(
-            &mut self.listener,
-            Token(0),
-            Interest::READABLE | Interest::WRITABLE,
-        )
-    }
-
     fn handle_accepted_connection(
         &mut self,
         mut stream: TcpStream,

satrs/src/hal/std/tcp_spacepackets_server.rs

@@ -5,9 +5,9 @@ use mio::net::{TcpListener, TcpStream};
 use std::{io::Write, net::SocketAddr};
 
 use crate::{
-    encoding::{ccsds::SpacePacketValidator, parse_buffer_for_ccsds_space_packets},
+    encoding::parse_buffer_for_ccsds_space_packets,
     tmtc::{PacketSenderRaw, PacketSource},
-    ComponentId,
+    ComponentId, ValidatorU16Id,
 };
 
 use super::tcp_server::{
@@ -15,7 +15,20 @@ use super::tcp_server::{
     TcpTmSender, TcpTmtcError, TcpTmtcGenericServer,
 };
 
-impl<T: SpacePacketValidator, TmError, TcError: 'static> TcpTcParser<TmError, TcError> for T {
+/// Concrete [TcpTcParser] implementation for the [TcpSpacepacketsServer].
+pub struct SpacepacketsTcParser<PacketIdChecker: ValidatorU16Id> {
+    packet_id_lookup: PacketIdChecker,
+}
+
+impl<PacketIdChecker: ValidatorU16Id> SpacepacketsTcParser<PacketIdChecker> {
+    pub fn new(packet_id_lookup: PacketIdChecker) -> Self {
+        Self { packet_id_lookup }
+    }
+}
+
+impl<PacketIdChecker: ValidatorU16Id, TmError, TcError: 'static> TcpTcParser<TmError, TcError>
+    for SpacepacketsTcParser<PacketIdChecker>
+{
     fn handle_tc_parsing(
         &mut self,
         tc_buffer: &mut [u8],
@@ -26,19 +39,14 @@ impl<T: SpacePacketValidator, TmError, TcError: 'static> TcpTcParser<TmError, Tc
         next_write_idx: &mut usize,
     ) -> Result<(), TcpTmtcError<TmError, TcError>> {
         // Reader vec full, need to parse for packets.
-        let parse_result = parse_buffer_for_ccsds_space_packets(
-            &tc_buffer[..current_write_idx],
-            self,
+        conn_result.num_received_tcs += parse_buffer_for_ccsds_space_packets(
+            &mut tc_buffer[..current_write_idx],
+            &self.packet_id_lookup,
             sender_id,
             tc_sender,
+            next_write_idx,
         )
         .map_err(|e| TcpTmtcError::TcError(e))?;
-        if let Some(broken_tail_start) = parse_result.incomplete_tail_start {
-            // Copy broken tail to front of buffer.
-            tc_buffer.copy_within(broken_tail_start..current_write_idx, 0);
-            *next_write_idx = current_write_idx - broken_tail_start;
-        }
-        conn_result.num_received_tcs += parse_result.packets_found;
         Ok(())
     }
 }
@@ -79,18 +87,17 @@ impl<TmError, TcError> TcpTmSender<TmError, TcError> for SpacepacketsTmSender {
 ///
 /// This serves only works if
 /// [CCSDS 133.0-B-2 space packets](https://public.ccsds.org/Pubs/133x0b2e1.pdf) are the only
-/// packet type being exchanged. It uses the CCSDS space packet header [spacepackets::SpHeader] and
-/// a user specified [SpacePacketValidator] to determine the space packets relevant for further
-/// processing.
+/// packet type being exchanged. It uses the CCSDS [spacepackets::PacketId] as the packet delimiter
+/// and start marker when parsing for packets. The user specifies a set of expected
+/// [spacepackets::PacketId]s as part of the server configuration for that purpose.
 ///
 /// ## Example
-///
 /// The [TCP server integration tests](https://egit.irs.uni-stuttgart.de/rust/sat-rs/src/branch/main/satrs/tests/tcp_servers.rs)
 /// also serves as the example application for this module.
 pub struct TcpSpacepacketsServer<
     TmSource: PacketSource<Error = TmError>,
     TcSender: PacketSenderRaw<Error = SendError>,
-    Validator: SpacePacketValidator,
+    PacketIdChecker: ValidatorU16Id,
     HandledConnection: HandledConnectionHandler,
     TmError,
     SendError: 'static,
@@ -99,7 +106,7 @@ pub struct TcpSpacepacketsServer<
         TmSource,
         TcSender,
         SpacepacketsTmSender,
-        Validator,
+        SpacepacketsTcParser<PacketIdChecker>,
         HandledConnection,
         TmError,
         SendError,
@@ -108,12 +115,20 @@ pub struct TcpSpacepacketsServer<
 
 impl<
         TmSource: PacketSource<Error = TmError>,
-        TcSender: PacketSenderRaw<Error = TcError>,
-        Validator: SpacePacketValidator,
+        TcReceiver: PacketSenderRaw<Error = TcError>,
+        PacketIdChecker: ValidatorU16Id,
         HandledConnection: HandledConnectionHandler,
         TmError: 'static,
         TcError: 'static,
-    > TcpSpacepacketsServer<TmSource, TcSender, Validator, HandledConnection, TmError, TcError>
+    >
+    TcpSpacepacketsServer<
+        TmSource,
+        TcReceiver,
+        PacketIdChecker,
+        HandledConnection,
+        TmError,
+        TcError,
+    >
 {
     ///
     /// ## Parameter
@@ -121,30 +136,26 @@ impl<
     /// * `cfg` - Configuration of the server.
     /// * `tm_source` - Generic TM source used by the server to pull telemetry packets which are
     ///     then sent back to the client.
-    /// * `tc_sender` - Any received telecommands which were decoded successfully will be
-    ///     forwarded using this [PacketSenderRaw].
-    /// * `validator` - Used to determine the space packets relevant for further processing and
-    ///    to detect broken space packets.
-    /// * `handled_connection_hook` - Called to notify the user about a succesfully handled
-    ///    connection.
-    /// * `stop_signal` - Can be used to shut down the TCP server even for longer running
-    ///    connections.
+    /// * `tc_receiver` - Any received telecommands which were decoded successfully will be
+    ///     forwarded to this TC receiver.
+    /// * `packet_id_lookup` - This lookup table contains the relevant packets IDs for packet
+    ///     parsing. This mechanism is used to have a start marker for finding CCSDS packets.
     pub fn new(
         cfg: ServerConfig,
         tm_source: TmSource,
-        tc_sender: TcSender,
-        validator: Validator,
-        handled_connection_hook: HandledConnection,
+        tc_receiver: TcReceiver,
+        packet_id_checker: PacketIdChecker,
+        handled_connection: HandledConnection,
         stop_signal: Option<Arc<AtomicBool>>,
     ) -> Result<Self, std::io::Error> {
         Ok(Self {
             generic_server: TcpTmtcGenericServer::new(
                 cfg,
-                validator,
+                SpacepacketsTcParser::new(packet_id_checker),
                 SpacepacketsTmSender::default(),
                 tm_source,
-                tc_sender,
-                handled_connection_hook,
+                tc_receiver,
+                handled_connection,
                 stop_signal,
             )?,
         })
@@ -158,8 +169,8 @@ impl<
             /// useful if using the port number 0 for OS auto-assignment.
             pub fn local_addr(&self) -> std::io::Result<SocketAddr>;
 
-            /// Delegation to the [TcpTmtcGenericServer::handle_all_connections] call.
-            pub fn handle_all_connections(
+            /// Delegation to the [TcpTmtcGenericServer::handle_next_connection] call.
+            pub fn handle_next_connection(
                 &mut self,
                 poll_timeout: Option<Duration>
             ) -> Result<ConnectionResult, TcpTmtcError<TmError, TcError>>;
@@ -186,17 +197,16 @@ mod tests {
     use hashbrown::HashSet;
     use spacepackets::{
         ecss::{tc::PusTcCreator, WritablePusPacket},
-        CcsdsPacket, PacketId, SpHeader,
+        PacketId, SpHeader,
     };
 
     use crate::{
-        encoding::ccsds::{SpValidity, SpacePacketValidator},
         hal::std::tcp_server::{
             tests::{ConnectionFinishedHandler, SyncTmSource},
             ConnectionResult, ServerConfig,
         },
+        pus::PacketAsVec,
         queue::GenericSendError,
-        tmtc::PacketAsVec,
         ComponentId,
     };
 
@@ -208,29 +218,16 @@ mod tests {
     const TEST_APID_1: u16 = 0x10;
     const TEST_PACKET_ID_1: PacketId = PacketId::new_for_tc(true, TEST_APID_1);
 
-    #[derive(Default)]
-    pub struct SimpleValidator(pub HashSet<PacketId>);
-
-    impl SpacePacketValidator for SimpleValidator {
-        fn validate(&self, sp_header: &SpHeader, _raw_buf: &[u8]) -> SpValidity {
-            if self.0.contains(&sp_header.packet_id()) {
-                return SpValidity::Valid;
-            }
-            // Simple case: Assume that the interface always contains valid space packets.
-            SpValidity::Skip
-        }
-    }
-
     fn generic_tmtc_server(
         addr: &SocketAddr,
         tc_sender: mpsc::Sender<PacketAsVec>,
         tm_source: SyncTmSource,
-        validator: SimpleValidator,
+        packet_id_lookup: HashSet<PacketId>,
         stop_signal: Option<Arc<AtomicBool>>,
     ) -> TcpSpacepacketsServer<
         SyncTmSource,
         mpsc::Sender<PacketAsVec>,
-        SimpleValidator,
+        HashSet<PacketId>,
         ConnectionFinishedHandler,
         (),
         GenericSendError,
@@ -239,7 +236,7 @@ mod tests {
             ServerConfig::new(TCP_SERVER_ID, *addr, Duration::from_millis(2), 1024, 1024),
             tm_source,
             tc_sender,
-            validator,
+            packet_id_lookup,
             ConnectionFinishedHandler::default(),
             stop_signal,
         )
@@ -251,13 +248,13 @@ mod tests {
         let auto_port_addr = SocketAddr::new(IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1)), 0);
         let (tc_sender, tc_receiver) = mpsc::channel();
         let tm_source = SyncTmSource::default();
-        let mut validator = SimpleValidator::default();
-        validator.0.insert(TEST_PACKET_ID_0);
+        let mut packet_id_lookup = HashSet::new();
+        packet_id_lookup.insert(TEST_PACKET_ID_0);
         let mut tcp_server = generic_tmtc_server(
             &auto_port_addr,
             tc_sender.clone(),
             tm_source,
-            validator,
+            packet_id_lookup,
             None,
         );
         let dest_addr = tcp_server
@@ -267,7 +264,7 @@ mod tests {
         let set_if_done = conn_handled.clone();
         // Call the connection handler in separate thread, does block.
         thread::spawn(move || {
-            let result = tcp_server.handle_all_connections(Some(Duration::from_millis(100)));
+            let result = tcp_server.handle_next_connection(Some(Duration::from_millis(100)));
             if result.is_err() {
                 panic!("handling connection failed: {:?}", result.unwrap_err());
             }
@@ -326,14 +323,14 @@ mod tests {
         tm_source.add_tm(&tm_1);
 
         // Set up server
-        let mut validator = SimpleValidator::default();
-        validator.0.insert(TEST_PACKET_ID_0);
-        validator.0.insert(TEST_PACKET_ID_1);
+        let mut packet_id_lookup = HashSet::new();
+        packet_id_lookup.insert(TEST_PACKET_ID_0);
+        packet_id_lookup.insert(TEST_PACKET_ID_1);
         let mut tcp_server = generic_tmtc_server(
             &auto_port_addr,
             tc_sender.clone(),
             tm_source,
-            validator,
+            packet_id_lookup,
             None,
         );
         let dest_addr = tcp_server
@@ -344,7 +341,7 @@ mod tests {
 
         // Call the connection handler in separate thread, does block.
         thread::spawn(move || {
-            let result = tcp_server.handle_all_connections(Some(Duration::from_millis(100)));
+            let result = tcp_server.handle_next_connection(Some(Duration::from_millis(100)));
             if result.is_err() {
                 panic!("handling connection failed: {:?}", result.unwrap_err());
             }

satrs/src/params.rs

@@ -43,7 +43,7 @@
 //! This includes the [ParamsHeapless] enumeration for contained values which do not require heap
 //! allocation, and the [Params] which enumerates [ParamsHeapless] and some additional types which
 //! require [alloc] support but allow for more flexbility.
-use crate::pool::PoolAddr;
+use crate::pool::StoreAddr;
 use core::fmt::Debug;
 use core::mem::size_of;
 use paste::paste;
@@ -588,15 +588,15 @@ from_conversions_for_raw!(
 #[non_exhaustive]
 pub enum Params {
     Heapless(ParamsHeapless),
-    Store(PoolAddr),
+    Store(StoreAddr),
     #[cfg(feature = "alloc")]
     Vec(Vec<u8>),
     #[cfg(feature = "alloc")]
     String(String),
 }
 
-impl From<PoolAddr> for Params {
-    fn from(x: PoolAddr) -> Self {
+impl From<StoreAddr> for Params {
+    fn from(x: StoreAddr) -> Self {
         Self::Store(x)
     }
 }
@@ -643,18 +643,52 @@ impl From<&str> for Params {
     }
 }
 
-impl WritableToBeBytes for ParamsHeapless {
+/// Please note while [WritableToBeBytes] is implemented for [Params], the default implementation
+/// will not be able to process the [Params::Store] parameter variant.
+impl WritableToBeBytes for Params {
     fn written_len(&self) -> usize {
         match self {
-            ParamsHeapless::Raw(raw) => raw.written_len(),
-            ParamsHeapless::EcssEnum(ecss_enum) => ecss_enum.written_len(),
+            Params::Heapless(p) => match p {
+                ParamsHeapless::Raw(raw) => raw.written_len(),
+                ParamsHeapless::EcssEnum(enumeration) => enumeration.written_len(),
+            },
+            Params::Store(_) => 0,
+            #[cfg(feature = "alloc")]
+            Params::Vec(vec) => vec.len(),
+            #[cfg(feature = "alloc")]
+            Params::String(string) => string.len(),
         }
     }
 
     fn write_to_be_bytes(&self, buf: &mut [u8]) -> Result<usize, ByteConversionError> {
         match self {
-            ParamsHeapless::Raw(raw) => raw.write_to_be_bytes(buf),
-            ParamsHeapless::EcssEnum(ecss_enum) => ecss_enum.write_to_be_bytes(buf),
+            Params::Heapless(p) => match p {
+                ParamsHeapless::Raw(raw) => raw.write_to_be_bytes(buf),
+                ParamsHeapless::EcssEnum(enumeration) => enumeration.write_to_be_bytes(buf),
+            },
+            Params::Store(_) => Ok(0),
+            #[cfg(feature = "alloc")]
+            Params::Vec(vec) => {
+                if buf.len() < vec.len() {
+                    return Err(ByteConversionError::ToSliceTooSmall {
+                        found: buf.len(),
+                        expected: vec.len(),
+                    });
+                }
+                buf[0..vec.len()].copy_from_slice(vec);
+                Ok(vec.len())
+            }
+            #[cfg(feature = "alloc")]
+            Params::String(string) => {
+                if buf.len() < string.len() {
+                    return Err(ByteConversionError::ToSliceTooSmall {
+                        found: buf.len(),
+                        expected: string.len(),
+                    });
+                }
+                buf[0..string.len()].copy_from_slice(string.as_bytes());
+                Ok(string.len())
+            }
         }
     }
 }
@@ -803,9 +837,10 @@ mod tests {
     #[test]
     fn test_params_written_len_raw() {
         let param_raw = ParamsRaw::from((500_u32, 1000_u32));
-        assert_eq!(param_raw.written_len(), 8);
+        let param: Params = Params::Heapless(param_raw.into());
+        assert_eq!(param.written_len(), 8);
         let mut buf: [u8; 8] = [0; 8];
-        param_raw
+        param
             .write_to_be_bytes(&mut buf)
             .expect("writing to buffer failed");
         assert_eq!(u32::from_be_bytes(buf[0..4].try_into().unwrap()), 500);
@@ -813,28 +848,21 @@ mod tests {
     }
 
     #[test]
-    fn test_heapless_param_writable_trait_raw() {
-        let param_heapless = ParamsHeapless::Raw(ParamsRaw::from((500_u32, 1000_u32)));
-        assert_eq!(param_heapless.written_len(), 8);
-        let mut buf: [u8; 8] = [0; 8];
-        let size = param_heapless
-            .write_to_be_bytes(&mut buf)
-            .expect("writing failed");
-        assert_eq!(size, 8);
-        assert_eq!(u32::from_be_bytes(buf[0..4].try_into().unwrap()), 500);
-        assert_eq!(u32::from_be_bytes(buf[4..8].try_into().unwrap()), 1000);
+    fn test_params_written_string() {
+        let string = "Test String".to_string();
+        let param = Params::String(string.clone());
+        assert_eq!(param.written_len(), string.len());
+        let vec = param.to_vec().unwrap();
+        let string_conv_back = String::from_utf8(vec).expect("conversion to string failed");
+        assert_eq!(string_conv_back, string);
     }
 
     #[test]
-    fn test_heapless_param_writable_trait_ecss_enum() {
-        let param_heapless = ParamsHeapless::EcssEnum(ParamsEcssEnum::U16(5.into()));
-        assert_eq!(param_heapless.written_len(), 2);
-        let mut buf: [u8; 2] = [0; 2];
-        let size = param_heapless
-            .write_to_be_bytes(&mut buf)
-            .expect("writing failed");
-        assert_eq!(size, 2);
-        assert_eq!(u16::from_be_bytes(buf[0..2].try_into().unwrap()), 5);
+    fn test_params_written_vec() {
+        let vec: Vec<u8> = alloc::vec![1, 2, 3, 4, 5];
+        let param = Params::Vec(vec.clone());
+        assert_eq!(param.written_len(), vec.len());
+        assert_eq!(param.to_vec().expect("writing vec params failed"), vec);
     }
 
     #[test]

satrs/src/pool.rs

@@ -82,7 +82,7 @@ use spacepackets::ByteConversionError;
 use std::error::Error;
 
 type NumBlocks = u16;
-pub type PoolAddr = u64;
+pub type StoreAddr = u64;
 
 /// Simple address type used for transactions with the local pool.
 #[derive(Debug, Copy, Clone, PartialEq, Eq)]
@@ -100,14 +100,14 @@ impl StaticPoolAddr {
     }
 }
 
-impl From<StaticPoolAddr> for PoolAddr {
+impl From<StaticPoolAddr> for StoreAddr {
     fn from(value: StaticPoolAddr) -> Self {
         ((value.pool_idx as u64) << 16) | value.packet_idx as u64
     }
 }
 
-impl From<PoolAddr> for StaticPoolAddr {
-    fn from(value: PoolAddr) -> Self {
+impl From<StoreAddr> for StaticPoolAddr {
+    fn from(value: StoreAddr) -> Self {
         Self {
             pool_idx: ((value >> 16) & 0xff) as u16,
             packet_idx: (value & 0xff) as u16,
@@ -150,59 +150,59 @@ impl Error for StoreIdError {}
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
-pub enum PoolError {
+pub enum StoreError {
     /// Requested data block is too large
     DataTooLarge(usize),
     /// The store is full. Contains the index of the full subpool
     StoreFull(u16),
     /// Store ID is invalid. This also includes partial errors where only the subpool is invalid
-    InvalidStoreId(StoreIdError, Option<PoolAddr>),
+    InvalidStoreId(StoreIdError, Option<StoreAddr>),
     /// Valid subpool and packet index, but no data is stored at the given address
-    DataDoesNotExist(PoolAddr),
+    DataDoesNotExist(StoreAddr),
     ByteConversionError(spacepackets::ByteConversionError),
     LockError,
     /// Internal or configuration errors
     InternalError(u32),
 }
 
-impl Display for PoolError {
+impl Display for StoreError {
     fn fmt(&self, f: &mut Formatter<'_>) -> core::fmt::Result {
         match self {
-            PoolError::DataTooLarge(size) => {
+            StoreError::DataTooLarge(size) => {
                 write!(f, "data to store with size {size} is too large")
             }
-            PoolError::StoreFull(u16) => {
+            StoreError::StoreFull(u16) => {
                 write!(f, "store is too full. index for full subpool: {u16}")
             }
-            PoolError::InvalidStoreId(id_e, addr) => {
+            StoreError::InvalidStoreId(id_e, addr) => {
                 write!(f, "invalid store ID: {id_e}, address: {addr:?}")
             }
-            PoolError::DataDoesNotExist(addr) => {
+            StoreError::DataDoesNotExist(addr) => {
                 write!(f, "no data exists at address {addr:?}")
             }
-            PoolError::InternalError(e) => {
+            StoreError::InternalError(e) => {
                 write!(f, "internal error: {e}")
             }
-            PoolError::ByteConversionError(e) => {
+            StoreError::ByteConversionError(e) => {
                 write!(f, "store error: {e}")
             }
-            PoolError::LockError => {
+            StoreError::LockError => {
                 write!(f, "lock error")
             }
         }
     }
 }
 
-impl From<ByteConversionError> for PoolError {
+impl From<ByteConversionError> for StoreError {
     fn from(value: ByteConversionError) -> Self {
         Self::ByteConversionError(value)
     }
 }
 
 #[cfg(feature = "std")]
-impl Error for PoolError {
+impl Error for StoreError {
     fn source(&self) -> Option<&(dyn Error + 'static)> {
-        if let PoolError::InvalidStoreId(e, _) = self {
+        if let StoreError::InvalidStoreId(e, _) = self {
             return Some(e);
         }
         None
@@ -217,41 +217,44 @@ impl Error for PoolError {
 /// pool structure being wrapped inside a lock.
 pub trait PoolProvider {
     /// Add new data to the pool. The provider should attempt to reserve a memory block with the
-    /// appropriate size and then copy the given data to the block. Yields a [PoolAddr] which can
+    /// appropriate size and then copy the given data to the block. Yields a [StoreAddr] which can
     /// be used to access the data stored in the pool
-    fn add(&mut self, data: &[u8]) -> Result<PoolAddr, PoolError>;
+    fn add(&mut self, data: &[u8]) -> Result<StoreAddr, StoreError>;
 
     /// The provider should attempt to reserve a free memory block with the appropriate size first.
     /// It then executes a user-provided closure and passes a mutable reference to that memory
     /// block to the closure. This allows the user to write data to the memory block.
-    /// The function should yield a [PoolAddr] which can be used to access the data stored in the
+    /// The function should yield a [StoreAddr] which can be used to access the data stored in the
     /// pool.
     fn free_element<W: FnMut(&mut [u8])>(
         &mut self,
         len: usize,
         writer: W,
-    ) -> Result<PoolAddr, PoolError>;
+    ) -> Result<StoreAddr, StoreError>;
 
-    /// Modify data added previously using a given [PoolAddr]. The provider should use the store
+    /// Modify data added previously using a given [StoreAddr]. The provider should use the store
     /// address to determine if a memory block exists for that address. If it does, it should
     /// call the user-provided closure and pass a mutable reference to the memory block
     /// to the closure. This allows the user to modify the memory block.
-    fn modify<U: FnMut(&mut [u8])>(&mut self, addr: &PoolAddr, updater: U)
-        -> Result<(), PoolError>;
+    fn modify<U: FnMut(&mut [u8])>(
+        &mut self,
+        addr: &StoreAddr,
+        updater: U,
+    ) -> Result<(), StoreError>;
 
     /// The provider should copy the data from the memory block to the user-provided buffer if
     /// it exists.
-    fn read(&self, addr: &PoolAddr, buf: &mut [u8]) -> Result<usize, PoolError>;
+    fn read(&self, addr: &StoreAddr, buf: &mut [u8]) -> Result<usize, StoreError>;
 
-    /// Delete data inside the pool given a [PoolAddr].
-    fn delete(&mut self, addr: PoolAddr) -> Result<(), PoolError>;
-    fn has_element_at(&self, addr: &PoolAddr) -> Result<bool, PoolError>;
+    /// Delete data inside the pool given a [StoreAddr].
+    fn delete(&mut self, addr: StoreAddr) -> Result<(), StoreError>;
+    fn has_element_at(&self, addr: &StoreAddr) -> Result<bool, StoreError>;
 
     /// Retrieve the length of the data at the given store address.
-    fn len_of_data(&self, addr: &PoolAddr) -> Result<usize, PoolError>;
+    fn len_of_data(&self, addr: &StoreAddr) -> Result<usize, StoreError>;
 
     #[cfg(feature = "alloc")]
-    fn read_as_vec(&self, addr: &PoolAddr) -> Result<alloc::vec::Vec<u8>, PoolError> {
+    fn read_as_vec(&self, addr: &StoreAddr) -> Result<alloc::vec::Vec<u8>, StoreError> {
         let mut vec = alloc::vec![0; self.len_of_data(addr)?];
         self.read(addr, &mut vec)?;
         Ok(vec)
@@ -268,7 +271,7 @@ pub trait PoolProviderWithGuards: PoolProvider {
     /// This can prevent memory leaks. Users can read the data and release the guard
     /// if the data in the store is valid for further processing. If the data is faulty, no
     /// manual deletion is necessary when returning from a processing function prematurely.
-    fn read_with_guard(&mut self, addr: PoolAddr) -> PoolGuard<Self>;
+    fn read_with_guard(&mut self, addr: StoreAddr) -> PoolGuard<Self>;
 
     /// This function behaves like [PoolProvider::modify], but consumes the provided
     /// address and returns a RAII conformant guard object.
@@ -278,20 +281,20 @@ pub trait PoolProviderWithGuards: PoolProvider {
     /// This can prevent memory leaks. Users can read (and modify) the data and release the guard
     /// if the data in the store is valid for further processing. If the data is faulty, no
     /// manual deletion is necessary when returning from a processing function prematurely.
-    fn modify_with_guard(&mut self, addr: PoolAddr) -> PoolRwGuard<Self>;
+    fn modify_with_guard(&mut self, addr: StoreAddr) -> PoolRwGuard<Self>;
 }
 
 pub struct PoolGuard<'a, MemProvider: PoolProvider + ?Sized> {
     pool: &'a mut MemProvider,
-    pub addr: PoolAddr,
+    pub addr: StoreAddr,
     no_deletion: bool,
-    deletion_failed_error: Option<PoolError>,
+    deletion_failed_error: Option<StoreError>,
 }
 
 /// This helper object can be used to safely access pool data without worrying about memory
 /// leaks.
 impl<'a, MemProvider: PoolProvider> PoolGuard<'a, MemProvider> {
-    pub fn new(pool: &'a mut MemProvider, addr: PoolAddr) -> Self {
+    pub fn new(pool: &'a mut MemProvider, addr: StoreAddr) -> Self {
         Self {
             pool,
             addr,
@@ -300,12 +303,12 @@ impl<'a, MemProvider: PoolProvider> PoolGuard<'a, MemProvider> {
         }
     }
 
-    pub fn read(&self, buf: &mut [u8]) -> Result<usize, PoolError> {
+    pub fn read(&self, buf: &mut [u8]) -> Result<usize, StoreError> {
         self.pool.read(&self.addr, buf)
     }
 
     #[cfg(feature = "alloc")]
-    pub fn read_as_vec(&self) -> Result<alloc::vec::Vec<u8>, PoolError> {
+    pub fn read_as_vec(&self) -> Result<alloc::vec::Vec<u8>, StoreError> {
         self.pool.read_as_vec(&self.addr)
     }
 
@@ -331,19 +334,19 @@ pub struct PoolRwGuard<'a, MemProvider: PoolProvider + ?Sized> {
 }
 
 impl<'a, MemProvider: PoolProvider> PoolRwGuard<'a, MemProvider> {
-    pub fn new(pool: &'a mut MemProvider, addr: PoolAddr) -> Self {
+    pub fn new(pool: &'a mut MemProvider, addr: StoreAddr) -> Self {
         Self {
             guard: PoolGuard::new(pool, addr),
         }
     }
 
-    pub fn update<U: FnMut(&mut [u8])>(&mut self, updater: &mut U) -> Result<(), PoolError> {
+    pub fn update<U: FnMut(&mut [u8])>(&mut self, updater: &mut U) -> Result<(), StoreError> {
         self.guard.pool.modify(&self.guard.addr, updater)
     }
 
     delegate!(
         to self.guard {
-            pub fn read(&self, buf: &mut [u8]) -> Result<usize, PoolError>;
+            pub fn read(&self, buf: &mut [u8]) -> Result<usize, StoreError>;
             /// Releasing the pool guard will disable the automatic deletion of the data when the guard
             /// is dropped.
             pub fn release(&mut self);
@@ -354,7 +357,7 @@ impl<'a, MemProvider: PoolProvider> PoolRwGuard<'a, MemProvider> {
 #[cfg(feature = "alloc")]
 mod alloc_mod {
     use super::{PoolGuard, PoolProvider, PoolProviderWithGuards, PoolRwGuard, StaticPoolAddr};
-    use crate::pool::{NumBlocks, PoolAddr, PoolError, StoreIdError};
+    use crate::pool::{NumBlocks, StoreAddr, StoreError, StoreIdError};
     use alloc::vec;
     use alloc::vec::Vec;
     use spacepackets::ByteConversionError;
@@ -419,7 +422,7 @@ mod alloc_mod {
     /// fitting subpool is full. This might be added in the future.
     ///
     /// Transactions with the [pool][StaticMemoryPool] are done using a generic
-    /// [address][PoolAddr] type. Adding any data to the pool will yield a store address.
+    /// [address][StoreAddr] type. Adding any data to the pool will yield a store address.
     /// Modification and read operations are done using a reference to a store address. Deletion
     /// will consume the store address.
     pub struct StaticMemoryPool {
@@ -449,41 +452,41 @@ mod alloc_mod {
             local_pool
         }
 
-        fn addr_check(&self, addr: &StaticPoolAddr) -> Result<usize, PoolError> {
+        fn addr_check(&self, addr: &StaticPoolAddr) -> Result<usize, StoreError> {
             self.validate_addr(addr)?;
             let pool_idx = addr.pool_idx as usize;
             let size_list = self.sizes_lists.get(pool_idx).unwrap();
             let curr_size = size_list[addr.packet_idx as usize];
             if curr_size == STORE_FREE {
-                return Err(PoolError::DataDoesNotExist(PoolAddr::from(*addr)));
+                return Err(StoreError::DataDoesNotExist(StoreAddr::from(*addr)));
             }
             Ok(curr_size)
         }
 
-        fn validate_addr(&self, addr: &StaticPoolAddr) -> Result<(), PoolError> {
+        fn validate_addr(&self, addr: &StaticPoolAddr) -> Result<(), StoreError> {
             let pool_idx = addr.pool_idx as usize;
             if pool_idx >= self.pool_cfg.cfg.len() {
-                return Err(PoolError::InvalidStoreId(
+                return Err(StoreError::InvalidStoreId(
                     StoreIdError::InvalidSubpool(addr.pool_idx),
-                    Some(PoolAddr::from(*addr)),
+                    Some(StoreAddr::from(*addr)),
                 ));
             }
             if addr.packet_idx >= self.pool_cfg.cfg[addr.pool_idx as usize].0 {
-                return Err(PoolError::InvalidStoreId(
+                return Err(StoreError::InvalidStoreId(
                     StoreIdError::InvalidPacketIdx(addr.packet_idx),
-                    Some(PoolAddr::from(*addr)),
+                    Some(StoreAddr::from(*addr)),
                 ));
             }
             Ok(())
         }
 
-        fn reserve(&mut self, data_len: usize) -> Result<StaticPoolAddr, PoolError> {
+        fn reserve(&mut self, data_len: usize) -> Result<StaticPoolAddr, StoreError> {
             let mut subpool_idx = self.find_subpool(data_len, 0)?;
 
             if self.pool_cfg.spill_to_higher_subpools {
-                while let Err(PoolError::StoreFull(_)) = self.find_empty(subpool_idx) {
+                while let Err(StoreError::StoreFull(_)) = self.find_empty(subpool_idx) {
                     if (subpool_idx + 1) as usize == self.sizes_lists.len() {
-                        return Err(PoolError::StoreFull(subpool_idx));
+                        return Err(StoreError::StoreFull(subpool_idx));
                     }
                     subpool_idx += 1;
                 }
@@ -497,7 +500,7 @@ mod alloc_mod {
             })
         }
 
-        fn find_subpool(&self, req_size: usize, start_at_subpool: u16) -> Result<u16, PoolError> {
+        fn find_subpool(&self, req_size: usize, start_at_subpool: u16) -> Result<u16, StoreError> {
             for (i, &(_, elem_size)) in self.pool_cfg.cfg.iter().enumerate() {
                 if i < start_at_subpool as usize {
                     continue;
@@ -506,21 +509,21 @@ mod alloc_mod {
                     return Ok(i as u16);
                 }
             }
-            Err(PoolError::DataTooLarge(req_size))
+            Err(StoreError::DataTooLarge(req_size))
         }
 
-        fn write(&mut self, addr: &StaticPoolAddr, data: &[u8]) -> Result<(), PoolError> {
-            let packet_pos = self.raw_pos(addr).ok_or(PoolError::InternalError(0))?;
+        fn write(&mut self, addr: &StaticPoolAddr, data: &[u8]) -> Result<(), StoreError> {
+            let packet_pos = self.raw_pos(addr).ok_or(StoreError::InternalError(0))?;
             let subpool = self
                 .pool
                 .get_mut(addr.pool_idx as usize)
-                .ok_or(PoolError::InternalError(1))?;
+                .ok_or(StoreError::InternalError(1))?;
             let pool_slice = &mut subpool[packet_pos..packet_pos + data.len()];
             pool_slice.copy_from_slice(data);
             Ok(())
         }
 
-        fn find_empty(&mut self, subpool: u16) -> Result<(u16, &mut usize), PoolError> {
+        fn find_empty(&mut self, subpool: u16) -> Result<(u16, &mut usize), StoreError> {
             if let Some(size_list) = self.sizes_lists.get_mut(subpool as usize) {
                 for (i, elem_size) in size_list.iter_mut().enumerate() {
                     if *elem_size == STORE_FREE {
@@ -528,12 +531,12 @@ mod alloc_mod {
                     }
                 }
             } else {
-                return Err(PoolError::InvalidStoreId(
+                return Err(StoreError::InvalidStoreId(
                     StoreIdError::InvalidSubpool(subpool),
                     None,
                 ));
             }
-            Err(PoolError::StoreFull(subpool))
+            Err(StoreError::StoreFull(subpool))
         }
 
         fn raw_pos(&self, addr: &StaticPoolAddr) -> Option<usize> {
@@ -543,10 +546,10 @@ mod alloc_mod {
     }
 
     impl PoolProvider for StaticMemoryPool {
-        fn add(&mut self, data: &[u8]) -> Result<PoolAddr, PoolError> {
+        fn add(&mut self, data: &[u8]) -> Result<StoreAddr, StoreError> {
             let data_len = data.len();
             if data_len > POOL_MAX_SIZE {
-                return Err(PoolError::DataTooLarge(data_len));
+                return Err(StoreError::DataTooLarge(data_len));
             }
             let addr = self.reserve(data_len)?;
             self.write(&addr, data)?;
@@ -557,9 +560,9 @@ mod alloc_mod {
             &mut self,
             len: usize,
             mut writer: W,
-        ) -> Result<PoolAddr, PoolError> {
+        ) -> Result<StoreAddr, StoreError> {
             if len > POOL_MAX_SIZE {
-                return Err(PoolError::DataTooLarge(len));
+                return Err(StoreError::DataTooLarge(len));
             }
             let addr = self.reserve(len)?;
             let raw_pos = self.raw_pos(&addr).unwrap();
@@ -571,9 +574,9 @@ mod alloc_mod {
 
         fn modify<U: FnMut(&mut [u8])>(
             &mut self,
-            addr: &PoolAddr,
+            addr: &StoreAddr,
             mut updater: U,
-        ) -> Result<(), PoolError> {
+        ) -> Result<(), StoreError> {
             let addr = StaticPoolAddr::from(*addr);
             let curr_size = self.addr_check(&addr)?;
             let raw_pos = self.raw_pos(&addr).unwrap();
@@ -583,7 +586,7 @@ mod alloc_mod {
             Ok(())
         }
 
-        fn read(&self, addr: &PoolAddr, buf: &mut [u8]) -> Result<usize, PoolError> {
+        fn read(&self, addr: &StoreAddr, buf: &mut [u8]) -> Result<usize, StoreError> {
             let addr = StaticPoolAddr::from(*addr);
             let curr_size = self.addr_check(&addr)?;
             if buf.len() < curr_size {
@@ -601,7 +604,7 @@ mod alloc_mod {
             Ok(curr_size)
         }
 
-        fn delete(&mut self, addr: PoolAddr) -> Result<(), PoolError> {
+        fn delete(&mut self, addr: StoreAddr) -> Result<(), StoreError> {
             let addr = StaticPoolAddr::from(addr);
             self.addr_check(&addr)?;
             let block_size = self.pool_cfg.cfg.get(addr.pool_idx as usize).unwrap().1;
@@ -614,7 +617,7 @@ mod alloc_mod {
             Ok(())
         }
 
-        fn has_element_at(&self, addr: &PoolAddr) -> Result<bool, PoolError> {
+        fn has_element_at(&self, addr: &StoreAddr) -> Result<bool, StoreError> {
             let addr = StaticPoolAddr::from(*addr);
             self.validate_addr(&addr)?;
             let pool_idx = addr.pool_idx as usize;
@@ -626,7 +629,7 @@ mod alloc_mod {
             Ok(true)
         }
 
-        fn len_of_data(&self, addr: &PoolAddr) -> Result<usize, PoolError> {
+        fn len_of_data(&self, addr: &StoreAddr) -> Result<usize, StoreError> {
             let addr = StaticPoolAddr::from(*addr);
             self.validate_addr(&addr)?;
             let pool_idx = addr.pool_idx as usize;
@@ -640,11 +643,11 @@ mod alloc_mod {
     }
 
     impl PoolProviderWithGuards for StaticMemoryPool {
-        fn modify_with_guard(&mut self, addr: PoolAddr) -> PoolRwGuard<Self> {
+        fn modify_with_guard(&mut self, addr: StoreAddr) -> PoolRwGuard<Self> {
             PoolRwGuard::new(self, addr)
         }
 
-        fn read_with_guard(&mut self, addr: PoolAddr) -> PoolGuard<Self> {
+        fn read_with_guard(&mut self, addr: StoreAddr) -> PoolGuard<Self> {
             PoolGuard::new(self, addr)
         }
     }
@@ -653,8 +656,8 @@ mod alloc_mod {
 #[cfg(test)]
 mod tests {
     use crate::pool::{
-        PoolError, PoolGuard, PoolProvider, PoolProviderWithGuards, PoolRwGuard, StaticMemoryPool,
-        StaticPoolAddr, StaticPoolConfig, StoreIdError, POOL_MAX_SIZE,
+        PoolGuard, PoolProvider, PoolProviderWithGuards, PoolRwGuard, StaticMemoryPool,
+        StaticPoolAddr, StaticPoolConfig, StoreError, StoreIdError, POOL_MAX_SIZE,
     };
     use std::vec;
 
@@ -778,7 +781,7 @@ mod tests {
         let res = local_pool.free_element(8, |_| {});
         assert!(res.is_err());
         let err = res.unwrap_err();
-        assert_eq!(err, PoolError::StoreFull(1));
+        assert_eq!(err, StoreError::StoreFull(1));
 
         // Verify that the two deletions are successful
         assert!(local_pool.delete(addr0).is_ok());
@@ -800,7 +803,7 @@ mod tests {
         assert!(res.is_err());
         assert!(matches!(
             res.unwrap_err(),
-            PoolError::DataDoesNotExist { .. }
+            StoreError::DataDoesNotExist { .. }
         ));
     }
 
@@ -813,8 +816,8 @@ mod tests {
         let res = local_pool.add(&test_buf);
         assert!(res.is_err());
         let err = res.unwrap_err();
-        assert!(matches!(err, PoolError::StoreFull { .. }));
-        if let PoolError::StoreFull(subpool) = err {
+        assert!(matches!(err, StoreError::StoreFull { .. }));
+        if let StoreError::StoreFull(subpool) = err {
             assert_eq!(subpool, 2);
         }
     }
@@ -832,7 +835,7 @@ mod tests {
         let err = res.unwrap_err();
         assert!(matches!(
             err,
-            PoolError::InvalidStoreId(StoreIdError::InvalidSubpool(3), Some(_))
+            StoreError::InvalidStoreId(StoreIdError::InvalidSubpool(3), Some(_))
         ));
     }
 
@@ -849,7 +852,7 @@ mod tests {
         let err = res.unwrap_err();
         assert!(matches!(
             err,
-            PoolError::InvalidStoreId(StoreIdError::InvalidPacketIdx(1), Some(_))
+            StoreError::InvalidStoreId(StoreIdError::InvalidPacketIdx(1), Some(_))
         ));
     }
 
@@ -860,7 +863,7 @@ mod tests {
         let res = local_pool.add(&data_too_large);
         assert!(res.is_err());
         let err = res.unwrap_err();
-        assert_eq!(err, PoolError::DataTooLarge(20));
+        assert_eq!(err, StoreError::DataTooLarge(20));
     }
 
     #[test]
@@ -868,7 +871,10 @@ mod tests {
         let mut local_pool = basic_small_pool();
         let res = local_pool.free_element(POOL_MAX_SIZE + 1, |_| {});
         assert!(res.is_err());
-        assert_eq!(res.unwrap_err(), PoolError::DataTooLarge(POOL_MAX_SIZE + 1));
+        assert_eq!(
+            res.unwrap_err(),
+            StoreError::DataTooLarge(POOL_MAX_SIZE + 1)
+        );
     }
 
     #[test]
@@ -877,7 +883,7 @@ mod tests {
         // Try to request a slot which is too large
         let res = local_pool.free_element(20, |_| {});
         assert!(res.is_err());
-        assert_eq!(res.unwrap_err(), PoolError::DataTooLarge(20));
+        assert_eq!(res.unwrap_err(), StoreError::DataTooLarge(20));
     }
 
     #[test]
@@ -997,7 +1003,7 @@ mod tests {
         let should_fail = local_pool.free_element(8, |_| {});
         assert!(should_fail.is_err());
         if let Err(err) = should_fail {
-            assert_eq!(err, PoolError::StoreFull(1));
+            assert_eq!(err, StoreError::StoreFull(1));
         } else {
             panic!("unexpected store address");
         }
@@ -1028,7 +1034,7 @@ mod tests {
         let should_fail = local_pool.free_element(8, |_| {});
         assert!(should_fail.is_err());
         if let Err(err) = should_fail {
-            assert_eq!(err, PoolError::StoreFull(2));
+            assert_eq!(err, StoreError::StoreFull(2));
         } else {
             panic!("unexpected store address");
         }

satrs/src/pus/action.rs

@@ -7,9 +7,11 @@ use crate::{
 use satrs_shared::res_code::ResultU16;
 
 #[cfg(feature = "std")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "std")))]
 pub use std_mod::*;
 
 #[cfg(feature = "alloc")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "alloc")))]
 #[allow(unused_imports)]
 pub use alloc_mod::*;
 
@@ -54,15 +56,16 @@ pub type GenericActionReplyPus = GenericMessage<ActionReplyPus>;
 
 impl GenericActionReplyPus {
     pub fn new_action_reply(
-        replier_info: MessageMetadata,
+        requestor_info: MessageMetadata,
         action_id: ActionId,
         reply: ActionReplyVariant,
     ) -> Self {
-        Self::new(replier_info, ActionReplyPus::new(action_id, reply))
+        Self::new(requestor_info, ActionReplyPus::new(action_id, reply))
     }
 }
 
 #[cfg(feature = "alloc")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "alloc")))]
 pub mod alloc_mod {
     use crate::{
         action::ActionRequest,
@@ -124,6 +127,7 @@ pub mod alloc_mod {
 }
 
 #[cfg(feature = "std")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "std")))]
 pub mod std_mod {
     use std::sync::mpsc;
 

satrs/src/pus/event.rs

@@ -331,10 +331,10 @@ mod tests {
 
     fn severity_to_subservice(severity: Severity) -> Subservice {
         match severity {
-            Severity::Info => Subservice::TmInfoReport,
-            Severity::Low => Subservice::TmLowSeverityReport,
-            Severity::Medium => Subservice::TmMediumSeverityReport,
-            Severity::High => Subservice::TmHighSeverityReport,
+            Severity::INFO => Subservice::TmInfoReport,
+            Severity::LOW => Subservice::TmLowSeverityReport,
+            Severity::MEDIUM => Subservice::TmMediumSeverityReport,
+            Severity::HIGH => Subservice::TmHighSeverityReport,
         }
     }
 
@@ -347,22 +347,22 @@ mod tests {
         aux_data: Option<&[u8]>,
     ) {
         match severity {
-            Severity::Info => {
+            Severity::INFO => {
                 reporter
                     .event_info(sender, time_stamp, event, aux_data)
                     .expect("Error reporting info event");
             }
-            Severity::Low => {
+            Severity::LOW => {
                 reporter
                     .event_low_severity(sender, time_stamp, event, aux_data)
                     .expect("Error reporting low event");
             }
-            Severity::Medium => {
+            Severity::MEDIUM => {
                 reporter
                     .event_medium_severity(sender, time_stamp, event, aux_data)
                     .expect("Error reporting medium event");
             }
-            Severity::High => {
+            Severity::HIGH => {
                 reporter
                     .event_high_severity(sender, time_stamp, event, aux_data)
                     .expect("Error reporting high event");
@@ -389,7 +389,7 @@ mod tests {
         if let Some(err_data) = error_data {
             error_copy.extend_from_slice(err_data);
         }
-        let event = EventU32::new_checked(severity, EXAMPLE_GROUP_ID, EXAMPLE_EVENT_ID_0)
+        let event = EventU32::new(severity, EXAMPLE_GROUP_ID, EXAMPLE_EVENT_ID_0)
             .expect("Error creating example event");
         report_basic_event(
             &mut reporter,
@@ -407,7 +407,7 @@ mod tests {
             severity_to_subservice(severity) as u8
         );
         assert_eq!(tm_info.common.dest_id, 0);
-        assert_eq!(tm_info.common.timestamp, time_stamp_empty);
+        assert_eq!(tm_info.common.time_stamp, time_stamp_empty);
         assert_eq!(tm_info.common.msg_counter, 0);
         assert_eq!(tm_info.common.apid, EXAMPLE_APID);
         assert_eq!(tm_info.event, event);
@@ -417,35 +417,35 @@ mod tests {
 
     #[test]
     fn basic_info_event_generation() {
-        basic_event_test(4, Severity::Info, None);
+        basic_event_test(4, Severity::INFO, None);
     }
 
     #[test]
     fn basic_low_severity_event() {
-        basic_event_test(4, Severity::Low, None);
+        basic_event_test(4, Severity::LOW, None);
     }
 
     #[test]
     fn basic_medium_severity_event() {
-        basic_event_test(4, Severity::Medium, None);
+        basic_event_test(4, Severity::MEDIUM, None);
     }
 
     #[test]
     fn basic_high_severity_event() {
-        basic_event_test(4, Severity::High, None);
+        basic_event_test(4, Severity::HIGH, None);
     }
 
     #[test]
     fn event_with_info_string() {
         let info_string = "Test Information";
-        basic_event_test(32, Severity::Info, Some(info_string.as_bytes()));
+        basic_event_test(32, Severity::INFO, Some(info_string.as_bytes()));
     }
 
     #[test]
     fn low_severity_with_raw_err_data() {
         let raw_err_param: i32 = -1;
         let raw_err = raw_err_param.to_be_bytes();
-        basic_event_test(8, Severity::Low, Some(&raw_err))
+        basic_event_test(8, Severity::LOW, Some(&raw_err))
     }
 
     fn check_buf_too_small(
@@ -454,7 +454,7 @@ mod tests {
         expected_found_len: usize,
     ) {
         let time_stamp_empty: [u8; 7] = [0; 7];
-        let event = EventU32::new_checked(Severity::Info, EXAMPLE_GROUP_ID, EXAMPLE_EVENT_ID_0)
+        let event = EventU32::new(Severity::INFO, EXAMPLE_GROUP_ID, EXAMPLE_EVENT_ID_0)
             .expect("Error creating example event");
         let err = reporter.event_info(sender, &time_stamp_empty, event, None);
         assert!(err.is_err());

satrs/src/pus/event_man.rs

@@ -13,8 +13,10 @@ use crate::pus::verification::TcStateToken;
 use crate::pus::EcssTmSender;
 use crate::pus::EcssTmtcError;
 #[cfg(feature = "alloc")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "alloc")))]
 pub use alloc_mod::*;
 #[cfg(feature = "heapless")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "heapless")))]
 pub use heapless_mod::*;
 
 /// This trait allows the PUS event manager implementation to stay generic over various types
@@ -28,7 +30,7 @@ pub use heapless_mod::*;
 /// structure to track disabled events. A more primitive and embedded friendly
 /// solution could track this information in a static or pre-allocated list which contains
 /// the disabled events.
-pub trait PusEventReportingMapProvider<Event: GenericEvent> {
+pub trait PusEventMgmtBackendProvider<Event: GenericEvent> {
     type Error;
 
     fn event_enabled(&self, event: &Event) -> bool;
@@ -42,6 +44,7 @@ pub mod heapless_mod {
     use crate::events::LargestEventRaw;
     use core::marker::PhantomData;
 
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "heapless")))]
     // TODO: After a new version of heapless is released which uses hash32 version 0.3, try using
     //       regular Event type again.
     #[derive(Default)]
@@ -56,7 +59,7 @@ pub mod heapless_mod {
     {
     }
 
-    impl<const N: usize, Provider: GenericEvent> PusEventReportingMapProvider<Provider>
+    impl<const N: usize, Provider: GenericEvent> PusEventMgmtBackendProvider<Provider>
         for HeaplessPusMgmtBackendProvider<N, Provider>
     {
         type Error = ();
@@ -105,24 +108,20 @@ impl From<EcssTmtcError> for EventManError {
 pub mod alloc_mod {
     use core::marker::PhantomData;
 
-    use crate::{
-        events::EventU16,
-        params::{Params, WritableToBeBytes},
-        pus::event::{DummyEventHook, EventTmHookProvider},
-    };
+    use crate::events::EventU16;
 
     use super::*;
 
     /// Default backend provider which uses a hash set as the event reporting status container
-    /// like mentioned in the example of the [PusEventReportingMapProvider] documentation.
+    /// like mentioned in the example of the [PusEventMgmtBackendProvider] documentation.
     ///
     /// This provider is a good option for host systems or larger embedded systems where
     /// the expected occasional memory allocation performed by the [HashSet] is not an issue.
-    pub struct DefaultPusEventReportingMap<Event: GenericEvent = EventU32> {
+    pub struct DefaultPusEventMgmtBackend<Event: GenericEvent = EventU32> {
         disabled: HashSet<Event>,
     }
 
-    impl<Event: GenericEvent> Default for DefaultPusEventReportingMap<Event> {
+    impl<Event: GenericEvent> Default for DefaultPusEventMgmtBackend<Event> {
         fn default() -> Self {
             Self {
                 disabled: HashSet::default(),
@@ -130,60 +129,51 @@ pub mod alloc_mod {
         }
     }
 
-    impl<Event: GenericEvent + PartialEq + Eq + Hash + Copy + Clone>
-        PusEventReportingMapProvider<Event> for DefaultPusEventReportingMap<Event>
+    impl<EV: GenericEvent + PartialEq + Eq + Hash + Copy + Clone> PusEventMgmtBackendProvider<EV>
+        for DefaultPusEventMgmtBackend<EV>
     {
         type Error = ();
 
-        fn event_enabled(&self, event: &Event) -> bool {
+        fn event_enabled(&self, event: &EV) -> bool {
             !self.disabled.contains(event)
         }
 
-        fn enable_event_reporting(&mut self, event: &Event) -> Result<bool, Self::Error> {
+        fn enable_event_reporting(&mut self, event: &EV) -> Result<bool, Self::Error> {
             Ok(self.disabled.remove(event))
         }
 
-        fn disable_event_reporting(&mut self, event: &Event) -> Result<bool, Self::Error> {
+        fn disable_event_reporting(&mut self, event: &EV) -> Result<bool, Self::Error> {
             Ok(self.disabled.insert(*event))
         }
     }
 
-    #[derive(Debug, Copy, Clone, PartialEq, Eq)]
-    pub struct EventGenerationResult {
-        pub event_was_enabled: bool,
-        pub params_were_propagated: bool,
-    }
-
-    pub struct PusEventTmCreatorWithMap<
-        ReportingMap: PusEventReportingMapProvider<Event>,
-        Event: GenericEvent,
-        EventTmHook: EventTmHookProvider = DummyEventHook,
+    pub struct PusEventDispatcher<
+        B: PusEventMgmtBackendProvider<EV, Error = E>,
+        EV: GenericEvent,
+        E,
     > {
-        pub reporter: EventReporter<EventTmHook>,
-        reporting_map: ReportingMap,
-        phantom: PhantomData<Event>,
+        reporter: EventReporter,
+        backend: B,
+        phantom: PhantomData<(E, EV)>,
     }
 
-    impl<
-            ReportingMap: PusEventReportingMapProvider<Event>,
-            Event: GenericEvent,
-            EventTmHook: EventTmHookProvider,
-        > PusEventTmCreatorWithMap<ReportingMap, Event, EventTmHook>
+    impl<B: PusEventMgmtBackendProvider<Event, Error = E>, Event: GenericEvent, E>
+        PusEventDispatcher<B, Event, E>
     {
-        pub fn new(reporter: EventReporter<EventTmHook>, backend: ReportingMap) -> Self {
+        pub fn new(reporter: EventReporter, backend: B) -> Self {
             Self {
                 reporter,
-                reporting_map: backend,
+                backend,
                 phantom: PhantomData,
             }
         }
 
-        pub fn enable_tm_for_event(&mut self, event: &Event) -> Result<bool, ReportingMap::Error> {
-            self.reporting_map.enable_event_reporting(event)
+        pub fn enable_tm_for_event(&mut self, event: &Event) -> Result<bool, E> {
+            self.backend.enable_event_reporting(event)
         }
 
-        pub fn disable_tm_for_event(&mut self, event: &Event) -> Result<bool, ReportingMap::Error> {
-            self.reporting_map.disable_event_reporting(event)
+        pub fn disable_tm_for_event(&mut self, event: &Event) -> Result<bool, E> {
+            self.backend.disable_event_reporting(event)
         }
 
         pub fn generate_pus_event_tm_generic(
@@ -193,108 +183,59 @@ pub mod alloc_mod {
             event: Event,
             params: Option<&[u8]>,
         ) -> Result<bool, EventManError> {
-            if !self.reporting_map.event_enabled(&event) {
+            if !self.backend.event_enabled(&event) {
                 return Ok(false);
             }
             match event.severity() {
-                Severity::Info => self
+                Severity::INFO => self
                     .reporter
                     .event_info(sender, time_stamp, event, params)
                     .map(|_| true)
                     .map_err(|e| e.into()),
-                Severity::Low => self
+                Severity::LOW => self
                     .reporter
                     .event_low_severity(sender, time_stamp, event, params)
                     .map(|_| true)
                     .map_err(|e| e.into()),
-                Severity::Medium => self
+                Severity::MEDIUM => self
                     .reporter
                     .event_medium_severity(sender, time_stamp, event, params)
                     .map(|_| true)
                     .map_err(|e| e.into()),
-                Severity::High => self
+                Severity::HIGH => self
                     .reporter
                     .event_high_severity(sender, time_stamp, event, params)
                     .map(|_| true)
                     .map_err(|e| e.into()),
             }
         }
-
-        pub fn generate_pus_event_tm_generic_with_generic_params(
-            &self,
-            sender: &(impl EcssTmSender + ?Sized),
-            time_stamp: &[u8],
-            event: Event,
-            small_data_buf: &mut [u8],
-            params: Option<&Params>,
-        ) -> Result<EventGenerationResult, EventManError> {
-            let mut result = EventGenerationResult {
-                event_was_enabled: false,
-                params_were_propagated: true,
-            };
-            if params.is_none() {
-                result.event_was_enabled =
-                    self.generate_pus_event_tm_generic(sender, time_stamp, event, None)?;
-                return Ok(result);
-            }
-            let params = params.unwrap();
-            result.event_was_enabled = match params {
-                Params::Heapless(heapless_param) => {
-                    heapless_param
-                        .write_to_be_bytes(&mut small_data_buf[..heapless_param.written_len()])
-                        .map_err(EcssTmtcError::ByteConversion)?;
-                    self.generate_pus_event_tm_generic(
-                        sender,
-                        time_stamp,
-                        event,
-                        Some(small_data_buf),
-                    )?
-                }
-                Params::Vec(vec) => {
-                    self.generate_pus_event_tm_generic(sender, time_stamp, event, Some(vec))?
-                }
-                Params::String(string) => self.generate_pus_event_tm_generic(
-                    sender,
-                    time_stamp,
-                    event,
-                    Some(string.as_bytes()),
-                )?,
-                _ => {
-                    result.params_were_propagated = false;
-                    self.generate_pus_event_tm_generic(sender, time_stamp, event, None)?
-                }
-            };
-            Ok(result)
-        }
     }
 
-    impl<Event: GenericEvent + Copy + PartialEq + Eq + Hash, EventTmHook: EventTmHookProvider>
-        PusEventTmCreatorWithMap<DefaultPusEventReportingMap<Event>, Event, EventTmHook>
+    impl<EV: GenericEvent + Copy + PartialEq + Eq + Hash>
+        PusEventDispatcher<DefaultPusEventMgmtBackend<EV>, EV, ()>
     {
-        pub fn new_with_default_backend(reporter: EventReporter<EventTmHook>) -> Self {
+        pub fn new_with_default_backend(reporter: EventReporter) -> Self {
             Self {
                 reporter,
-                reporting_map: DefaultPusEventReportingMap::default(),
+                backend: DefaultPusEventMgmtBackend::default(),
                 phantom: PhantomData,
             }
         }
     }
 
-    impl<ReportingMap: PusEventReportingMapProvider<EventU32>>
-        PusEventTmCreatorWithMap<ReportingMap, EventU32>
-    {
+    impl<B: PusEventMgmtBackendProvider<EventU32, Error = E>, E> PusEventDispatcher<B, EventU32, E> {
         pub fn enable_tm_for_event_with_sev<Severity: HasSeverity>(
             &mut self,
             event: &EventU32TypedSev<Severity>,
-        ) -> Result<bool, ReportingMap::Error> {
-            self.reporting_map.enable_event_reporting(event.as_ref())
+        ) -> Result<bool, E> {
+            self.backend.enable_event_reporting(event.as_ref())
         }
 
         pub fn disable_tm_for_event_with_sev<Severity: HasSeverity>(
             &mut self,
             event: &EventU32TypedSev<Severity>,
-        ) -> Result<bool, ReportingMap::Error> {
-            self.reporting_map.disable_event_reporting(event.as_ref())
+        ) -> Result<bool, E> {
+            self.backend.disable_event_reporting(event.as_ref())
         }
 
         pub fn generate_pus_event_tm<Severity: HasSeverity>(
@@ -308,40 +249,36 @@ pub mod alloc_mod {
         }
     }
 
-    pub type DefaultPusEventU16TmCreator<EventTmHook = DummyEventHook> =
-        PusEventTmCreatorWithMap<DefaultPusEventReportingMap<EventU16>, EventU16, EventTmHook>;
-    pub type DefaultPusEventU32TmCreator<EventTmHook = DummyEventHook> =
-        PusEventTmCreatorWithMap<DefaultPusEventReportingMap<EventU32>, EventU32, EventTmHook>;
+    pub type DefaultPusEventU16Dispatcher<E> =
+        PusEventDispatcher<DefaultPusEventMgmtBackend<EventU16>, EventU16, E>;
+    pub type DefaultPusEventU32Dispatcher<E> =
+        PusEventDispatcher<DefaultPusEventMgmtBackend<EventU32>, EventU32, E>;
 }
 #[cfg(test)]
 mod tests {
-    use alloc::string::{String, ToString};
-    use alloc::vec;
-    use spacepackets::ecss::event::Subservice;
-    use spacepackets::ecss::tm::PusTmReader;
-    use spacepackets::ecss::PusPacket;
-
     use super::*;
+    use crate::events::SeverityInfo;
+    use crate::pus::PacketAsVec;
     use crate::request::UniqueApidTargetId;
-    use crate::{events::SeverityInfo, tmtc::PacketAsVec};
     use std::sync::mpsc::{self, TryRecvError};
 
-    const INFO_EVENT: EventU32TypedSev<SeverityInfo> = EventU32TypedSev::<SeverityInfo>::new(1, 0);
-    const LOW_SEV_EVENT: EventU32 = EventU32::new(Severity::Low, 1, 5);
+    const INFO_EVENT: EventU32TypedSev<SeverityInfo> =
+        EventU32TypedSev::<SeverityInfo>::const_new(1, 0);
+    const LOW_SEV_EVENT: EventU32 = EventU32::const_new(Severity::LOW, 1, 5);
     const EMPTY_STAMP: [u8; 7] = [0; 7];
     const TEST_APID: u16 = 0x02;
     const TEST_ID: UniqueApidTargetId = UniqueApidTargetId::new(TEST_APID, 0x05);
 
-    fn create_basic_man_1() -> DefaultPusEventU32TmCreator {
+    fn create_basic_man_1() -> DefaultPusEventU32Dispatcher<()> {
         let reporter = EventReporter::new(TEST_ID.raw(), TEST_APID, 0, 128)
             .expect("Creating event repoter failed");
-        PusEventTmCreatorWithMap::new_with_default_backend(reporter)
+        PusEventDispatcher::new_with_default_backend(reporter)
     }
-    fn create_basic_man_2() -> DefaultPusEventU32TmCreator {
+    fn create_basic_man_2() -> DefaultPusEventU32Dispatcher<()> {
         let reporter = EventReporter::new(TEST_ID.raw(), TEST_APID, 0, 128)
             .expect("Creating event repoter failed");
-        let backend = DefaultPusEventReportingMap::default();
-        PusEventTmCreatorWithMap::new(reporter, backend)
+        let backend = DefaultPusEventMgmtBackend::default();
+        PusEventDispatcher::new(reporter, backend)
     }
 
     #[test]
@@ -396,70 +333,4 @@ mod tests {
         assert!(event_sent);
         event_rx.try_recv().expect("No info event received");
     }
-
-    #[test]
-    fn test_event_with_generic_string_param() {
-        let event_man = create_basic_man_1();
-        let mut small_data_buf = [0; 128];
-        let param_data = "hello world";
-        let (event_tx, event_rx) = mpsc::channel::<PacketAsVec>();
-        let res = event_man.generate_pus_event_tm_generic_with_generic_params(
-            &event_tx,
-            &EMPTY_STAMP,
-            INFO_EVENT.into(),
-            &mut small_data_buf,
-            Some(&param_data.to_string().into()),
-        );
-        assert!(res.is_ok());
-        let res = res.unwrap();
-        assert!(res.event_was_enabled);
-        assert!(res.params_were_propagated);
-        let event_tm = event_rx.try_recv().expect("no event received");
-        let (tm, _) = PusTmReader::new(&event_tm.packet, 7).expect("reading TM failed");
-        assert_eq!(tm.service(), 5);
-        assert_eq!(tm.subservice(), Subservice::TmInfoReport as u8);
-        assert_eq!(tm.user_data().len(), 4 + param_data.len());
-        let u32_event = u32::from_be_bytes(tm.user_data()[0..4].try_into().unwrap());
-        assert_eq!(u32_event, INFO_EVENT.raw());
-        let string_data = String::from_utf8_lossy(&tm.user_data()[4..]);
-        assert_eq!(string_data, param_data);
-    }
-
-    #[test]
-    fn test_event_with_generic_vec_param() {
-        let event_man = create_basic_man_1();
-        let mut small_data_buf = [0; 128];
-        let param_data = vec![1, 2, 3, 4];
-        let (event_tx, event_rx) = mpsc::channel::<PacketAsVec>();
-        let res = event_man.generate_pus_event_tm_generic_with_generic_params(
-            &event_tx,
-            &EMPTY_STAMP,
-            INFO_EVENT.into(),
-            &mut small_data_buf,
-            Some(&param_data.clone().into()),
-        );
-        assert!(res.is_ok());
-        let res = res.unwrap();
-        assert!(res.event_was_enabled);
-        assert!(res.params_were_propagated);
-        let event_tm = event_rx.try_recv().expect("no event received");
-        let (tm, _) = PusTmReader::new(&event_tm.packet, 7).expect("reading TM failed");
-        assert_eq!(tm.service(), 5);
-        assert_eq!(tm.subservice(), Subservice::TmInfoReport as u8);
-        assert_eq!(tm.user_data().len(), 4 + param_data.len());
-        let u32_event = u32::from_be_bytes(tm.user_data()[0..4].try_into().unwrap());
-        assert_eq!(u32_event, INFO_EVENT.raw());
-        let vec_data = tm.user_data()[4..].to_vec();
-        assert_eq!(vec_data, param_data);
-    }
-
-    #[test]
-    fn test_event_with_generic_store_param_not_propagated() {
-        // TODO: Test this.
-    }
-
-    #[test]
-    fn test_event_with_generic_heapless_param() {
-        // TODO: Test this.
-    }
 }

satrs/src/pus/event_srv.rs

@@ -1,7 +1,7 @@
 use crate::events::EventU32;
 use crate::pus::event_man::{EventRequest, EventRequestWithToken};
 use crate::pus::verification::TcStateToken;
-use crate::pus::{DirectPusPacketHandlerResult, PartialPusHandlingError, PusPacketHandlingError};
+use crate::pus::{PartialPusHandlingError, PusPacketHandlerResult, PusPacketHandlingError};
 use crate::queue::GenericSendError;
 use spacepackets::ecss::event::Subservice;
 use spacepackets::ecss::PusPacket;
@@ -10,7 +10,7 @@ use std::sync::mpsc::Sender;
 use super::verification::VerificationReportingProvider;
 use super::{
     EcssTcInMemConverter, EcssTcReceiver, EcssTmSender, GenericConversionError,
-    GenericRoutingError, HandlingStatus, PusServiceHelper,
+    GenericRoutingError, PusServiceHelper,
 };
 
 pub struct PusEventServiceHandler<
@@ -46,14 +46,13 @@ impl<
         }
     }
 
-    pub fn poll_and_handle_next_tc<ErrorCb: FnMut(&PartialPusHandlingError)>(
+    pub fn poll_and_handle_next_tc(
         &mut self,
-        mut error_callback: ErrorCb,
         time_stamp: &[u8],
-    ) -> Result<DirectPusPacketHandlerResult, PusPacketHandlingError> {
+    ) -> Result<PusPacketHandlerResult, PusPacketHandlingError> {
         let possible_packet = self.service_helper.retrieve_and_accept_next_packet()?;
         if possible_packet.is_none() {
-            return Ok(HandlingStatus::Empty.into());
+            return Ok(PusPacketHandlerResult::Empty);
         }
         let ecss_tc_and_token = possible_packet.unwrap();
         self.service_helper
@@ -63,13 +62,13 @@ impl<
         let subservice = tc.subservice();
         let srv = Subservice::try_from(subservice);
         if srv.is_err() {
-            return Ok(DirectPusPacketHandlerResult::CustomSubservice(
+            return Ok(PusPacketHandlerResult::CustomSubservice(
                 tc.subservice(),
                 ecss_tc_and_token.token,
             ));
         }
-        let mut handle_enable_disable_request =
-            |enable: bool| -> Result<DirectPusPacketHandlerResult, PusPacketHandlingError> {
+        let handle_enable_disable_request =
+            |enable: bool| -> Result<PusPacketHandlerResult, PusPacketHandlingError> {
                 if tc.user_data().len() < 4 {
                     return Err(GenericConversionError::NotEnoughAppData {
                         expected: 4,
@@ -80,20 +79,21 @@ impl<
                 let user_data = tc.user_data();
                 let event_u32 =
                     EventU32::from(u32::from_be_bytes(user_data[0..4].try_into().unwrap()));
+                let start_token = self
+                    .service_helper
+                    .common
+                    .verif_reporter
+                    .start_success(
+                        &self.service_helper.common.tm_sender,
+                        ecss_tc_and_token.token,
+                        time_stamp,
+                    )
+                    .map_err(|_| PartialPusHandlingError::Verification);
+                let partial_error = start_token.clone().err();
                 let mut token: TcStateToken = ecss_tc_and_token.token.into();
-                match self.service_helper.common.verif_reporter.start_success(
-                    &self.service_helper.common.tm_sender,
-                    ecss_tc_and_token.token,
-                    time_stamp,
-                ) {
-                    Ok(start_token) => {
-                        token = start_token.into();
-                    }
-                    Err(e) => {
-                        error_callback(&PartialPusHandlingError::Verification(e));
-                    }
+                if let Ok(start_token) = start_token {
+                    token = start_token.into();
                 }
-
                 let event_req_with_token = if enable {
                     EventRequestWithToken {
                         request: EventRequest::Enable(event_u32),
@@ -112,7 +112,12 @@ impl<
                             GenericSendError::RxDisconnected,
                         ))
                     })?;
-                Ok(HandlingStatus::HandledOne.into())
+                if let Some(partial_error) = partial_error {
+                    return Ok(PusPacketHandlerResult::RequestHandledPartialSuccess(
+                        partial_error,
+                    ));
+                }
+                Ok(PusPacketHandlerResult::RequestHandled)
             };
 
         match srv.unwrap() {
@@ -131,14 +136,14 @@ impl<
                 handle_enable_disable_request(false)?;
             }
             Subservice::TcReportDisabledList | Subservice::TmDisabledEventsReport => {
-                return Ok(DirectPusPacketHandlerResult::SubserviceNotImplemented(
+                return Ok(PusPacketHandlerResult::SubserviceNotImplemented(
                     subservice,
                     ecss_tc_and_token.token,
                 ));
             }
         }
 
-        Ok(HandlingStatus::HandledOne.into())
+        Ok(PusPacketHandlerResult::RequestHandled)
     }
 }
 
@@ -162,7 +167,7 @@ mod tests {
     use crate::pus::verification::{
         RequestId, VerificationReporter, VerificationReportingProvider,
     };
-    use crate::pus::{GenericConversionError, HandlingStatus, MpscTcReceiver};
+    use crate::pus::{GenericConversionError, MpscTcReceiver};
     use crate::tmtc::PacketSenderWithSharedPool;
     use crate::{
         events::EventU32,
@@ -170,13 +175,13 @@ mod tests {
             event_man::EventRequestWithToken,
             tests::PusServiceHandlerWithSharedStoreCommon,
             verification::{TcStateAccepted, VerificationToken},
-            DirectPusPacketHandlerResult, EcssTcInSharedStoreConverter, PusPacketHandlingError,
+            EcssTcInSharedStoreConverter, PusPacketHandlerResult, PusPacketHandlingError,
         },
     };
 
     use super::PusEventServiceHandler;
 
-    const TEST_EVENT_0: EventU32 = EventU32::new(crate::events::Severity::Info, 5, 25);
+    const TEST_EVENT_0: EventU32 = EventU32::const_new(crate::events::Severity::INFO, 5, 25);
 
     struct Pus5HandlerWithStoreTester {
         common: PusServiceHandlerWithSharedStoreCommon,
@@ -208,13 +213,9 @@ mod tests {
                 .expect("acceptance success failure")
         }
 
-        fn send_tc(&self, token: &VerificationToken<TcStateAccepted>, tc: &PusTcCreator) {
-            self.common
-                .send_tc(self.handler.service_helper.id(), token, tc);
-        }
-
         delegate! {
             to self.common {
+                fn send_tc(&self, token: &VerificationToken<TcStateAccepted>, tc: &PusTcCreator);
                 fn read_next_tm(&mut self) -> PusTmReader<'_>;
                 fn check_no_tm_available(&self) -> bool;
                 fn check_next_verification_tm(&self, subservice: u8, expected_request_id: RequestId);
@@ -224,11 +225,9 @@ mod tests {
     }
 
     impl SimplePusPacketHandler for Pus5HandlerWithStoreTester {
-        fn handle_one_tc(
-            &mut self,
-        ) -> Result<DirectPusPacketHandlerResult, PusPacketHandlingError> {
+        fn handle_one_tc(&mut self) -> Result<PusPacketHandlerResult, PusPacketHandlingError> {
             let time_stamp = cds::CdsTime::new_with_u16_days(0, 0).to_vec().unwrap();
-            self.handler.poll_and_handle_next_tc(|_| {}, &time_stamp)
+            self.handler.poll_and_handle_next_tc(&time_stamp)
         }
     }
 
@@ -290,13 +289,10 @@ mod tests {
         let result = test_harness.handle_one_tc();
         assert!(result.is_ok());
         let result = result.unwrap();
-        assert!(
-            matches!(
-                result,
-                DirectPusPacketHandlerResult::Handled(HandlingStatus::Empty)
-            ),
-            "unexpected result type {result:?}"
-        )
+        if let PusPacketHandlerResult::Empty = result {
+        } else {
+            panic!("unexpected result type {result:?}")
+        }
     }
 
     #[test]
@@ -311,7 +307,7 @@ mod tests {
         let result = test_harness.handle_one_tc();
         assert!(result.is_ok());
         let result = result.unwrap();
-        if let DirectPusPacketHandlerResult::CustomSubservice(subservice, _) = result {
+        if let PusPacketHandlerResult::CustomSubservice(subservice, _) = result {
             assert_eq!(subservice, 200);
         } else {
             panic!("unexpected result type {result:?}")

satrs/src/pus/mod.rs

@@ -2,13 +2,10 @@
 //!
 //! This module contains structures to make working with the PUS C standard easier.
 //! The satrs-example application contains various usage examples of these components.
-use crate::pool::{PoolAddr, PoolError};
+use crate::pool::{StoreAddr, StoreError};
 use crate::pus::verification::{TcStateAccepted, TcStateToken, VerificationToken};
 use crate::queue::{GenericReceiveError, GenericSendError};
 use crate::request::{GenericMessage, MessageMetadata, RequestId};
-#[cfg(feature = "alloc")]
-use crate::tmtc::PacketAsVec;
-use crate::tmtc::PacketInPool;
 use crate::ComponentId;
 use core::fmt::{Display, Formatter};
 use core::time::Duration;
@@ -45,23 +42,14 @@ pub use std_mod::*;
 
 use self::verification::VerificationReportingProvider;
 
-/// Generic handling status for an object which is able to continuosly handle a queue to handle
-/// request or replies until the queue is empty.
-#[derive(Debug, PartialEq, Eq, Copy, Clone)]
-#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
-pub enum HandlingStatus {
-    HandledOne,
-    Empty,
-}
-
 #[derive(Debug, PartialEq, Eq, Clone)]
 pub enum PusTmVariant<'time, 'src_data> {
-    InStore(PoolAddr),
+    InStore(StoreAddr),
     Direct(PusTmCreator<'time, 'src_data>),
 }
 
-impl From<PoolAddr> for PusTmVariant<'_, '_> {
-    fn from(value: PoolAddr) -> Self {
+impl From<StoreAddr> for PusTmVariant<'_, '_> {
+    fn from(value: StoreAddr) -> Self {
         Self::InStore(value)
     }
 }
@@ -74,10 +62,10 @@ impl<'time, 'src_data> From<PusTmCreator<'time, 'src_data>> for PusTmVariant<'ti
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub enum EcssTmtcError {
-    Store(PoolError),
+    Store(StoreError),
     ByteConversion(ByteConversionError),
     Pus(PusError),
-    CantSendAddr(PoolAddr),
+    CantSendAddr(StoreAddr),
     CantSendDirectTm,
     Send(GenericSendError),
     Receive(GenericReceiveError),
@@ -111,8 +99,8 @@ impl Display for EcssTmtcError {
     }
 }
 
-impl From<PoolError> for EcssTmtcError {
-    fn from(value: PoolError) -> Self {
+impl From<StoreError> for EcssTmtcError {
+    fn from(value: StoreError) -> Self {
         Self::Store(value)
     }
 }
@@ -187,26 +175,26 @@ impl EcssTmSender for EcssTmDummySender {
     }
 }
 
-/// A PUS telecommand packet can be stored in memory and sent using different methods. Right now,
+/// A PUS telecommand packet can be stored in memory using different methods. Right now,
 /// storage inside a pool structure like [crate::pool::StaticMemoryPool], and storage inside a
 /// `Vec<u8>` are supported.
 #[non_exhaustive]
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub enum TcInMemory {
-    Pool(PacketInPool),
+    StoreAddr(StoreAddr),
     #[cfg(feature = "alloc")]
-    Vec(PacketAsVec),
+    Vec(alloc::vec::Vec<u8>),
 }
 
-impl From<PacketInPool> for TcInMemory {
-    fn from(value: PacketInPool) -> Self {
-        Self::Pool(value)
+impl From<StoreAddr> for TcInMemory {
+    fn from(value: StoreAddr) -> Self {
+        Self::StoreAddr(value)
     }
 }
 
 #[cfg(feature = "alloc")]
-impl From<PacketAsVec> for TcInMemory {
-    fn from(value: PacketAsVec) -> Self {
+impl From<alloc::vec::Vec<u8>> for TcInMemory {
+    fn from(value: alloc::vec::Vec<u8>) -> Self {
         Self::Vec(value)
     }
 }
@@ -274,8 +262,8 @@ impl From<PusError> for TryRecvTmtcError {
     }
 }
 
-impl From<PoolError> for TryRecvTmtcError {
-    fn from(value: PoolError) -> Self {
+impl From<StoreError> for TryRecvTmtcError {
+    fn from(value: StoreError) -> Self {
         Self::Tmtc(value.into())
     }
 }
@@ -377,6 +365,7 @@ pub mod alloc_mod {
     /// [DynClone] allows cloning the trait object as long as the boxed object implements
     /// [Clone].
     #[cfg(feature = "alloc")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "alloc")))]
     pub trait EcssTmSenderExt: EcssTmSender + Downcast + DynClone {
         // Remove this once trait upcasting coercion has been implemented.
         // Tracking issue: https://github.com/rust-lang/rust/issues/65991
@@ -417,6 +406,7 @@ pub mod alloc_mod {
     /// [DynClone] allows cloning the trait object as long as the boxed object implements
     /// [Clone].
     #[cfg(feature = "alloc")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "alloc")))]
     pub trait EcssTcSenderExt: EcssTcSender + Downcast + DynClone {}
 
     /// Blanket implementation for all types which implement [EcssTcSender] and are clonable.
@@ -436,6 +426,7 @@ pub mod alloc_mod {
     /// [DynClone] allows cloning the trait object as long as the boxed object implements
     /// [Clone].
     #[cfg(feature = "alloc")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "alloc")))]
     pub trait EcssTcReceiverExt: EcssTcReceiver + Downcast {}
 
     /// Blanket implementation for all types which implement [EcssTcReceiver] and are clonable.
@@ -557,6 +548,7 @@ pub mod alloc_mod {
         >
     {
         #[cfg(feature = "std")]
+        #[cfg_attr(doc_cfg, doc(cfg(feature = "std")))]
         pub fn new_from_now(
             active_request_map: ActiveRequestMap,
             fail_data_buf_size: usize,
@@ -643,6 +635,7 @@ pub mod alloc_mod {
 
         /// Update the current time used for timeout checks based on the current OS time.
         #[cfg(feature = "std")]
+        #[cfg_attr(doc_cfg, doc(cfg(feature = "std")))]
         pub fn update_time_from_now(&mut self) -> Result<(), std::time::SystemTimeError> {
             self.current_time = UnixTimestamp::from_now()?;
             Ok(())
@@ -657,13 +650,17 @@ pub mod alloc_mod {
 }
 
 #[cfg(feature = "std")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "std")))]
 pub mod std_mod {
-    use super::*;
     use crate::pool::{
-        PoolAddr, PoolError, PoolProvider, PoolProviderWithGuards, SharedStaticMemoryPool,
+        PoolProvider, PoolProviderWithGuards, SharedStaticMemoryPool, StoreAddr, StoreError,
     };
     use crate::pus::verification::{TcStateAccepted, VerificationToken};
-    use crate::tmtc::{PacketAsVec, PacketSenderWithSharedPool};
+    use crate::pus::{
+        EcssTcAndToken, EcssTcReceiver, EcssTmSender, EcssTmtcError, GenericReceiveError,
+        GenericSendError, PusTmVariant, TryRecvTmtcError,
+    };
+    use crate::tmtc::PacketSenderWithSharedPool;
     use crate::ComponentId;
     use alloc::vec::Vec;
     use core::time::Duration;
@@ -681,10 +678,24 @@ pub mod std_mod {
 
     use super::verification::{TcStateToken, VerificationReportingProvider};
     use super::{AcceptedEcssTcAndToken, ActiveRequestProvider, TcInMemory};
-    use crate::tmtc::PacketInPool;
 
-    impl From<mpsc::SendError<PoolAddr>> for EcssTmtcError {
-        fn from(_: mpsc::SendError<PoolAddr>) -> Self {
+    #[derive(Debug)]
+    pub struct PacketInPool {
+        pub sender_id: ComponentId,
+        pub store_addr: StoreAddr,
+    }
+
+    impl PacketInPool {
+        pub fn new(sender_id: ComponentId, store_addr: StoreAddr) -> Self {
+            Self {
+                sender_id,
+                store_addr,
+            }
+        }
+    }
+
+    impl From<mpsc::SendError<StoreAddr>> for EcssTmtcError {
+        fn from(_: mpsc::SendError<StoreAddr>) -> Self {
             Self::Send(GenericSendError::RxDisconnected)
         }
     }
@@ -719,6 +730,18 @@ pub mod std_mod {
         }
     }
 
+    #[derive(Debug)]
+    pub struct PacketAsVec {
+        pub sender_id: ComponentId,
+        pub packet: Vec<u8>,
+    }
+
+    impl PacketAsVec {
+        pub fn new(sender_id: ComponentId, packet: Vec<u8>) -> Self {
+            Self { sender_id, packet }
+        }
+    }
+
     pub type MpscTmAsVecSender = mpsc::Sender<PacketAsVec>;
 
     impl EcssTmSender for MpscTmAsVecSender {
@@ -771,14 +794,14 @@ pub mod std_mod {
         use super::*;
         use crossbeam_channel as cb;
 
-        impl From<cb::SendError<PoolAddr>> for EcssTmtcError {
-            fn from(_: cb::SendError<PoolAddr>) -> Self {
+        impl From<cb::SendError<StoreAddr>> for EcssTmtcError {
+            fn from(_: cb::SendError<StoreAddr>) -> Self {
                 Self::Send(GenericSendError::RxDisconnected)
             }
         }
 
-        impl From<cb::TrySendError<PoolAddr>> for EcssTmtcError {
-            fn from(value: cb::TrySendError<PoolAddr>) -> Self {
+        impl From<cb::TrySendError<StoreAddr>> for EcssTmtcError {
+            fn from(value: cb::TrySendError<StoreAddr>) -> Self {
                 match value {
                     cb::TrySendError::Full(_) => Self::Send(GenericSendError::QueueFull(None)),
                     cb::TrySendError::Disconnected(_) => {
@@ -926,24 +949,26 @@ pub mod std_mod {
         #[error("generic timestamp generation error")]
         Time(#[from] StdTimestampError),
         #[error("error sending telemetry: {0}")]
-        TmSend(EcssTmtcError),
+        TmSend(#[from] EcssTmtcError),
         #[error("error sending verification message")]
-        Verification(EcssTmtcError),
+        Verification,
         #[error("invalid verification token")]
         NoVerificationToken,
     }
 
     /// Generic result type for handlers which can process PUS packets.
     #[derive(Debug, Clone)]
-    pub enum DirectPusPacketHandlerResult {
-        Handled(HandlingStatus),
+    pub enum PusPacketHandlerResult {
+        RequestHandled,
+        RequestHandledPartialSuccess(PartialPusHandlingError),
         SubserviceNotImplemented(u8, VerificationToken<TcStateAccepted>),
         CustomSubservice(u8, VerificationToken<TcStateAccepted>),
+        Empty,
     }
 
-    impl From<HandlingStatus> for DirectPusPacketHandlerResult {
-        fn from(value: HandlingStatus) -> Self {
-            Self::Handled(value)
+    impl From<PartialPusHandlingError> for PusPacketHandlerResult {
+        fn from(value: PartialPusHandlingError) -> Self {
+            Self::RequestHandledPartialSuccess(value)
         }
     }
 
@@ -952,8 +977,6 @@ pub mod std_mod {
 
         fn tc_slice_raw(&self) -> &[u8];
 
-        fn sender_id(&self) -> Option<ComponentId>;
-
         fn cache_and_convert(
             &mut self,
             possible_packet: &TcInMemory,
@@ -976,7 +999,6 @@ pub mod std_mod {
     /// [SharedStaticMemoryPool].
     #[derive(Default, Clone)]
     pub struct EcssTcInVecConverter {
-        sender_id: Option<ComponentId>,
         pub pus_tc_raw: Option<Vec<u8>>,
     }
 
@@ -984,21 +1006,16 @@ pub mod std_mod {
         fn cache(&mut self, tc_in_memory: &TcInMemory) -> Result<(), PusTcFromMemError> {
             self.pus_tc_raw = None;
             match tc_in_memory {
-                super::TcInMemory::Pool(_packet_in_pool) => {
+                super::TcInMemory::StoreAddr(_) => {
                     return Err(PusTcFromMemError::InvalidFormat(tc_in_memory.clone()));
                 }
-                super::TcInMemory::Vec(packet_with_sender) => {
-                    self.pus_tc_raw = Some(packet_with_sender.packet.clone());
-                    self.sender_id = Some(packet_with_sender.sender_id);
+                super::TcInMemory::Vec(vec) => {
+                    self.pus_tc_raw = Some(vec.clone());
                 }
             };
             Ok(())
         }
 
-        fn sender_id(&self) -> Option<ComponentId> {
-            self.sender_id
-        }
-
         fn tc_slice_raw(&self) -> &[u8] {
             if self.pus_tc_raw.is_none() {
                 return &[];
@@ -1012,7 +1029,6 @@ pub mod std_mod {
     /// packets should be avoided. Please note that this structure is not able to convert TCs which
     /// are stored as a `Vec<u8>`.
     pub struct EcssTcInSharedStoreConverter {
-        sender_id: Option<ComponentId>,
         shared_tc_store: SharedStaticMemoryPool,
         pus_buf: Vec<u8>,
     }
@@ -1020,16 +1036,15 @@ pub mod std_mod {
     impl EcssTcInSharedStoreConverter {
         pub fn new(shared_tc_store: SharedStaticMemoryPool, max_expected_tc_size: usize) -> Self {
             Self {
-                sender_id: None,
                 shared_tc_store,
                 pus_buf: alloc::vec![0; max_expected_tc_size],
             }
         }
 
-        pub fn copy_tc_to_buf(&mut self, addr: PoolAddr) -> Result<(), PusTcFromMemError> {
+        pub fn copy_tc_to_buf(&mut self, addr: StoreAddr) -> Result<(), PusTcFromMemError> {
             // Keep locked section as short as possible.
             let mut tc_pool = self.shared_tc_store.write().map_err(|_| {
-                PusTcFromMemError::EcssTmtc(EcssTmtcError::Store(PoolError::LockError))
+                PusTcFromMemError::EcssTmtc(EcssTmtcError::Store(StoreError::LockError))
             })?;
             let tc_size = tc_pool.len_of_data(&addr).map_err(EcssTmtcError::Store)?;
             if tc_size > self.pus_buf.len() {
@@ -1051,9 +1066,8 @@ pub mod std_mod {
     impl EcssTcInMemConverter for EcssTcInSharedStoreConverter {
         fn cache(&mut self, tc_in_memory: &TcInMemory) -> Result<(), PusTcFromMemError> {
             match tc_in_memory {
-                super::TcInMemory::Pool(packet_in_pool) => {
-                    self.copy_tc_to_buf(packet_in_pool.store_addr)?;
-                    self.sender_id = Some(packet_in_pool.sender_id);
+                super::TcInMemory::StoreAddr(addr) => {
+                    self.copy_tc_to_buf(*addr)?;
                 }
                 super::TcInMemory::Vec(_) => {
                     return Err(PusTcFromMemError::InvalidFormat(tc_in_memory.clone()));
@@ -1065,10 +1079,6 @@ pub mod std_mod {
         fn tc_slice_raw(&self) -> &[u8] {
             self.pus_buf.as_ref()
         }
-
-        fn sender_id(&self) -> Option<ComponentId> {
-            self.sender_id
-        }
     }
 
     pub struct PusServiceBase<
@@ -1226,7 +1236,7 @@ pub mod test_util {
 
     use super::{
         verification::{self, TcStateAccepted, VerificationToken},
-        DirectPusPacketHandlerResult, PusPacketHandlingError,
+        PusPacketHandlerResult, PusPacketHandlingError,
     };
 
     pub const TEST_APID: u16 = 0x101;
@@ -1250,8 +1260,7 @@ pub mod test_util {
     }
 
     pub trait SimplePusPacketHandler {
-        fn handle_one_tc(&mut self)
-            -> Result<DirectPusPacketHandlerResult, PusPacketHandlingError>;
+        fn handle_one_tc(&mut self) -> Result<PusPacketHandlerResult, PusPacketHandlingError>;
     }
 }
 
@@ -1271,7 +1280,7 @@ pub mod tests {
 
     use crate::pool::{PoolProvider, SharedStaticMemoryPool, StaticMemoryPool, StaticPoolConfig};
     use crate::pus::verification::{RequestId, VerificationReporter};
-    use crate::tmtc::{PacketAsVec, PacketInPool, PacketSenderWithSharedPool, SharedPacketPool};
+    use crate::tmtc::{PacketSenderWithSharedPool, SharedPacketPool};
     use crate::ComponentId;
 
     use super::test_util::{TEST_APID, TEST_COMPONENT_ID_0};
@@ -1289,46 +1298,36 @@ pub mod tests {
         pub seq_count: u16,
         pub msg_counter: u16,
         pub dest_id: u16,
-        pub timestamp: Vec<u8>,
+        pub time_stamp: [u8; 7],
     }
 
     impl CommonTmInfo {
-        pub fn new(
-            subservice: u8,
-            apid: u16,
-            seq_count: u16,
-            msg_counter: u16,
-            dest_id: u16,
-            timestamp: &[u8],
-        ) -> Self {
-            Self {
-                subservice,
-                apid,
-                seq_count,
-                msg_counter,
-                dest_id,
-                timestamp: timestamp.to_vec(),
-            }
-        }
         pub fn new_zero_seq_count(
             subservice: u8,
             apid: u16,
             dest_id: u16,
-            timestamp: &[u8],
+            time_stamp: [u8; 7],
         ) -> Self {
-            Self::new(subservice, apid, 0, 0, dest_id, timestamp)
+            Self {
+                subservice,
+                apid,
+                seq_count: 0,
+                msg_counter: 0,
+                dest_id,
+                time_stamp,
+            }
         }
 
         pub fn new_from_tm(tm: &PusTmCreator) -> Self {
-            let mut timestamp = [0; 7];
-            timestamp.clone_from_slice(&tm.timestamp()[0..7]);
+            let mut time_stamp = [0; 7];
+            time_stamp.clone_from_slice(&tm.timestamp()[0..7]);
             Self {
                 subservice: PusPacket::subservice(tm),
                 apid: tm.apid(),
                 seq_count: tm.seq_count(),
                 msg_counter: tm.msg_counter(),
                 dest_id: tm.dest_id(),
-                timestamp: timestamp.to_vec(),
+                time_stamp,
             }
         }
     }
@@ -1390,12 +1389,7 @@ pub mod tests {
                 ),
             )
         }
-        pub fn send_tc(
-            &self,
-            sender_id: ComponentId,
-            token: &VerificationToken<TcStateAccepted>,
-            tc: &PusTcCreator,
-        ) {
+        pub fn send_tc(&self, token: &VerificationToken<TcStateAccepted>, tc: &PusTcCreator) {
             let mut mut_buf = self.pus_buf.borrow_mut();
             let tc_size = tc.write_to_bytes(mut_buf.as_mut_slice()).unwrap();
             let mut tc_pool = self.tc_pool.write().unwrap();
@@ -1403,10 +1397,7 @@ pub mod tests {
             drop(tc_pool);
             // Send accepted TC to test service handler.
             self.tc_sender
-                .send(EcssTcAndToken::new(
-                    PacketInPool::new(sender_id, addr),
-                    *token,
-                ))
+                .send(EcssTcAndToken::new(addr, *token))
                 .expect("sending tc failed");
         }
 
@@ -1520,19 +1511,11 @@ pub mod tests {
     }
 
     impl PusServiceHandlerWithVecCommon {
-        pub fn send_tc(
-            &self,
-            sender_id: ComponentId,
-            token: &VerificationToken<TcStateAccepted>,
-            tc: &PusTcCreator,
-        ) {
+        pub fn send_tc(&self, token: &VerificationToken<TcStateAccepted>, tc: &PusTcCreator) {
             // Send accepted TC to test service handler.
             self.tc_sender
                 .send(EcssTcAndToken::new(
-                    TcInMemory::Vec(PacketAsVec::new(
-                        sender_id,
-                        tc.to_vec().expect("pus tc conversion to vec failed"),
-                    )),
+                    TcInMemory::Vec(tc.to_vec().expect("pus tc conversion to vec failed")),
                     *token,
                 ))
                 .expect("sending tc failed");

satrs/src/pus/mode.rs

@@ -26,9 +26,11 @@ pub enum Subservice {
 }
 
 #[cfg(feature = "alloc")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "alloc")))]
 pub mod alloc_mod {}
 
 #[cfg(feature = "alloc")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "alloc")))]
 pub mod std_mod {}
 
 #[cfg(test)]

satrs/src/pus/scheduler.rs

@@ -14,7 +14,7 @@ use spacepackets::{ByteConversionError, CcsdsPacket};
 #[cfg(feature = "std")]
 use std::error::Error;
 
-use crate::pool::{PoolError, PoolProvider};
+use crate::pool::{PoolProvider, StoreError};
 #[cfg(feature = "alloc")]
 pub use alloc_mod::*;
 
@@ -151,7 +151,7 @@ pub enum ScheduleError {
     },
     /// Nested time-tagged commands are not allowed.
     NestedScheduledTc,
-    StoreError(PoolError),
+    StoreError(StoreError),
     TcDataEmpty,
     TimestampError(TimestampError),
     WrongSubservice(u8),
@@ -206,8 +206,8 @@ impl From<PusError> for ScheduleError {
     }
 }
 
-impl From<PoolError> for ScheduleError {
-    fn from(e: PoolError) -> Self {
+impl From<StoreError> for ScheduleError {
+    fn from(e: StoreError) -> Self {
         Self::StoreError(e)
     }
 }
@@ -240,7 +240,7 @@ impl Error for ScheduleError {
 pub trait PusSchedulerProvider {
     type TimeProvider: CcsdsTimeProvider + TimeReader;
 
-    fn reset(&mut self, store: &mut (impl PoolProvider + ?Sized)) -> Result<(), PoolError>;
+    fn reset(&mut self, store: &mut (impl PoolProvider + ?Sized)) -> Result<(), StoreError>;
 
     fn is_enabled(&self) -> bool;
 
@@ -347,7 +347,7 @@ pub mod alloc_mod {
     };
     use spacepackets::time::cds::{self, DaysLen24Bits};
 
-    use crate::pool::PoolAddr;
+    use crate::pool::StoreAddr;
 
     use super::*;
 
@@ -368,8 +368,8 @@ pub mod alloc_mod {
     }
 
     enum DeletionResult {
-        WithoutStoreDeletion(Option<PoolAddr>),
-        WithStoreDeletion(Result<bool, PoolError>),
+        WithoutStoreDeletion(Option<StoreAddr>),
+        WithStoreDeletion(Result<bool, StoreError>),
     }
 
     /// This is the core data structure for scheduling PUS telecommands with [alloc] support.
@@ -423,6 +423,7 @@ pub mod alloc_mod {
 
         /// Like [Self::new], but sets the `init_current_time` parameter to the current system time.
         #[cfg(feature = "std")]
+        #[cfg_attr(doc_cfg, doc(cfg(feature = "std")))]
         pub fn new_with_current_init_time(time_margin: Duration) -> Result<Self, SystemTimeError> {
             Ok(Self::new(UnixTime::now()?, time_margin))
         }
@@ -524,7 +525,7 @@ pub mod alloc_mod {
             &mut self,
             time_window: TimeWindow<TimeProvider>,
             pool: &mut (impl PoolProvider + ?Sized),
-        ) -> Result<u64, (u64, PoolError)> {
+        ) -> Result<u64, (u64, StoreError)> {
             let range = self.retrieve_by_time_filter(time_window);
             let mut del_packets = 0;
             let mut res_if_fails = None;
@@ -554,7 +555,7 @@ pub mod alloc_mod {
         pub fn delete_all(
             &mut self,
             pool: &mut (impl PoolProvider + ?Sized),
-        ) -> Result<u64, (u64, PoolError)> {
+        ) -> Result<u64, (u64, StoreError)> {
             self.delete_by_time_filter(TimeWindow::<cds::CdsTime>::new_select_all(), pool)
         }
 
@@ -600,7 +601,7 @@ pub mod alloc_mod {
         /// Please note that this function will stop on the first telecommand with a request ID match.
         /// In case of duplicate IDs (which should generally not happen), this function needs to be
         /// called repeatedly.
-        pub fn delete_by_request_id(&mut self, req_id: &RequestId) -> Option<PoolAddr> {
+        pub fn delete_by_request_id(&mut self, req_id: &RequestId) -> Option<StoreAddr> {
             if let DeletionResult::WithoutStoreDeletion(v) =
                 self.delete_by_request_id_internal_without_store_deletion(req_id)
             {
@@ -614,7 +615,7 @@ pub mod alloc_mod {
             &mut self,
             req_id: &RequestId,
             pool: &mut (impl PoolProvider + ?Sized),
-        ) -> Result<bool, PoolError> {
+        ) -> Result<bool, StoreError> {
             if let DeletionResult::WithStoreDeletion(v) =
                 self.delete_by_request_id_internal_with_store_deletion(req_id, pool)
             {
@@ -666,6 +667,7 @@ pub mod alloc_mod {
         }
 
         #[cfg(feature = "std")]
+        #[cfg_attr(doc_cfg, doc(cfg(feature = "std")))]
         pub fn update_time_from_now(&mut self) -> Result<(), SystemTimeError> {
             self.current_time = UnixTime::now()?;
             Ok(())
@@ -691,7 +693,7 @@ pub mod alloc_mod {
             releaser: R,
             tc_store: &mut (impl PoolProvider + ?Sized),
             tc_buf: &mut [u8],
-        ) -> Result<u64, (u64, PoolError)> {
+        ) -> Result<u64, (u64, StoreError)> {
             self.release_telecommands_internal(releaser, tc_store, Some(tc_buf))
         }
 
@@ -705,7 +707,7 @@ pub mod alloc_mod {
             &mut self,
             releaser: R,
             tc_store: &mut (impl PoolProvider + ?Sized),
-        ) -> Result<u64, (u64, PoolError)> {
+        ) -> Result<u64, (u64, StoreError)> {
             self.release_telecommands_internal(releaser, tc_store, None)
         }
 
@@ -714,7 +716,7 @@ pub mod alloc_mod {
             mut releaser: R,
             tc_store: &mut (impl PoolProvider + ?Sized),
             mut tc_buf: Option<&mut [u8]>,
-        ) -> Result<u64, (u64, PoolError)> {
+        ) -> Result<u64, (u64, StoreError)> {
             let tcs_to_release = self.telecommands_to_release();
             let mut released_tcs = 0;
             let mut store_error = Ok(());
@@ -760,7 +762,7 @@ pub mod alloc_mod {
             mut releaser: R,
             tc_store: &(impl PoolProvider + ?Sized),
             tc_buf: &mut [u8],
-        ) -> Result<alloc::vec::Vec<TcInfo>, (alloc::vec::Vec<TcInfo>, PoolError)> {
+        ) -> Result<alloc::vec::Vec<TcInfo>, (alloc::vec::Vec<TcInfo>, StoreError)> {
             let tcs_to_release = self.telecommands_to_release();
             let mut released_tcs = alloc::vec::Vec::new();
             for tc in tcs_to_release {
@@ -791,7 +793,7 @@ pub mod alloc_mod {
         /// The holding store for the telecommands needs to be passed so all the stored telecommands
         /// can be deleted to avoid a memory leak. If at last one deletion operation fails, the error
         /// will be returned but the method will still try to delete all the commands in the schedule.
-        fn reset(&mut self, store: &mut (impl PoolProvider + ?Sized)) -> Result<(), PoolError> {
+        fn reset(&mut self, store: &mut (impl PoolProvider + ?Sized)) -> Result<(), StoreError> {
             self.enabled = false;
             let mut deletion_ok = Ok(());
             for tc_lists in &mut self.tc_map {
@@ -849,7 +851,7 @@ pub mod alloc_mod {
 mod tests {
     use super::*;
     use crate::pool::{
-        PoolAddr, PoolError, PoolProvider, StaticMemoryPool, StaticPoolAddr, StaticPoolConfig,
+        PoolProvider, StaticMemoryPool, StaticPoolAddr, StaticPoolConfig, StoreAddr, StoreError,
     };
     use alloc::collections::btree_map::Range;
     use spacepackets::ecss::tc::{PusTcCreator, PusTcReader, PusTcSecondaryHeader};
@@ -988,7 +990,7 @@ mod tests {
             .insert_unwrapped_and_stored_tc(
                 UnixTime::new_only_secs(100),
                 TcInfo::new(
-                    PoolAddr::from(StaticPoolAddr {
+                    StoreAddr::from(StaticPoolAddr {
                         pool_idx: 0,
                         packet_idx: 1,
                     }),
@@ -1005,7 +1007,7 @@ mod tests {
             .insert_unwrapped_and_stored_tc(
                 UnixTime::new_only_secs(100),
                 TcInfo::new(
-                    PoolAddr::from(StaticPoolAddr {
+                    StoreAddr::from(StaticPoolAddr {
                         pool_idx: 0,
                         packet_idx: 2,
                     }),
@@ -1049,8 +1051,8 @@ mod tests {
 
     fn common_check(
         enabled: bool,
-        store_addr: &PoolAddr,
-        expected_store_addrs: Vec<PoolAddr>,
+        store_addr: &StoreAddr,
+        expected_store_addrs: Vec<StoreAddr>,
         counter: &mut usize,
     ) {
         assert!(enabled);
@@ -1059,8 +1061,8 @@ mod tests {
     }
     fn common_check_disabled(
         enabled: bool,
-        store_addr: &PoolAddr,
-        expected_store_addrs: Vec<PoolAddr>,
+        store_addr: &StoreAddr,
+        expected_store_addrs: Vec<StoreAddr>,
         counter: &mut usize,
     ) {
         assert!(!enabled);
@@ -1514,7 +1516,7 @@ mod tests {
         // TC could not even be read..
         assert_eq!(err.0, 0);
         match err.1 {
-            PoolError::DataDoesNotExist(addr) => {
+            StoreError::DataDoesNotExist(addr) => {
                 assert_eq!(tc_info_0.addr(), addr);
             }
             _ => panic!("unexpected error {}", err.1),
@@ -1537,7 +1539,7 @@ mod tests {
         assert!(reset_res.is_err());
         let err = reset_res.unwrap_err();
         match err {
-            PoolError::DataDoesNotExist(addr) => {
+            StoreError::DataDoesNotExist(addr) => {
                 assert_eq!(addr, tc_info_0.addr());
             }
             _ => panic!("unexpected error {err}"),
@@ -1639,7 +1641,7 @@ mod tests {
         let err = insert_res.unwrap_err();
         match err {
             ScheduleError::StoreError(e) => match e {
-                PoolError::StoreFull(_) => {}
+                StoreError::StoreFull(_) => {}
                 _ => panic!("unexpected store error {e}"),
             },
             _ => panic!("unexpected error {err}"),

satrs/src/pus/scheduler_srv.rs

@@ -1,13 +1,12 @@
 use super::scheduler::PusSchedulerProvider;
 use super::verification::{VerificationReporter, VerificationReportingProvider};
 use super::{
-    DirectPusPacketHandlerResult, EcssTcInMemConverter, EcssTcInSharedStoreConverter,
-    EcssTcInVecConverter, EcssTcReceiver, EcssTmSender, HandlingStatus, MpscTcReceiver,
-    PartialPusHandlingError, PusServiceHelper,
+    EcssTcInMemConverter, EcssTcInSharedStoreConverter, EcssTcInVecConverter, EcssTcReceiver,
+    EcssTmSender, MpscTcReceiver, PacketAsVec, PusServiceHelper,
 };
 use crate::pool::PoolProvider;
-use crate::pus::PusPacketHandlingError;
-use crate::tmtc::{PacketAsVec, PacketSenderWithSharedPool};
+use crate::pus::{PusPacketHandlerResult, PusPacketHandlingError};
+use crate::tmtc::PacketSenderWithSharedPool;
 use alloc::string::ToString;
 use spacepackets::ecss::{scheduling, PusPacket};
 use spacepackets::time::cds::CdsTime;
@@ -65,15 +64,14 @@ impl<
         &self.scheduler
     }
 
-    pub fn poll_and_handle_next_tc<ErrorCb: FnMut(&PartialPusHandlingError)>(
+    pub fn poll_and_handle_next_tc(
         &mut self,
-        mut error_callback: ErrorCb,
         time_stamp: &[u8],
         sched_tc_pool: &mut (impl PoolProvider + ?Sized),
-    ) -> Result<DirectPusPacketHandlerResult, PusPacketHandlingError> {
+    ) -> Result<PusPacketHandlerResult, PusPacketHandlingError> {
         let possible_packet = self.service_helper.retrieve_and_accept_next_packet()?;
         if possible_packet.is_none() {
-            return Ok(HandlingStatus::Empty.into());
+            return Ok(PusPacketHandlerResult::Empty);
         }
         let ecss_tc_and_token = possible_packet.unwrap();
         self.service_helper
@@ -83,34 +81,34 @@ impl<
         let subservice = PusPacket::subservice(&tc);
         let standard_subservice = scheduling::Subservice::try_from(subservice);
         if standard_subservice.is_err() {
-            return Ok(DirectPusPacketHandlerResult::CustomSubservice(
+            return Ok(PusPacketHandlerResult::CustomSubservice(
                 subservice,
                 ecss_tc_and_token.token,
             ));
         }
+        let partial_error = None;
         match standard_subservice.unwrap() {
             scheduling::Subservice::TcEnableScheduling => {
-                let opt_started_token = match self.service_helper.verif_reporter().start_success(
-                    &self.service_helper.common.tm_sender,
-                    ecss_tc_and_token.token,
-                    time_stamp,
-                ) {
-                    Ok(started_token) => Some(started_token),
-                    Err(e) => {
-                        error_callback(&PartialPusHandlingError::Verification(e));
-                        None
-                    }
-                };
-                self.scheduler.enable();
-
-                if self.scheduler.is_enabled() && opt_started_token.is_some() {
-                    if let Err(e) = self.service_helper.verif_reporter().completion_success(
+                let start_token = self
+                    .service_helper
+                    .verif_reporter()
+                    .start_success(
                         &self.service_helper.common.tm_sender,
-                        opt_started_token.unwrap(),
+                        ecss_tc_and_token.token,
                         time_stamp,
-                    ) {
-                        error_callback(&PartialPusHandlingError::Verification(e));
-                    }
+                    )
+                    .expect("Error sending start success");
+
+                self.scheduler.enable();
+                if self.scheduler.is_enabled() {
+                    self.service_helper
+                        .verif_reporter()
+                        .completion_success(
+                            &self.service_helper.common.tm_sender,
+                            start_token,
+                            time_stamp,
+                        )
+                        .expect("Error sending completion success");
                 } else {
                     return Err(PusPacketHandlingError::Other(
                         "failed to enabled scheduler".to_string(),
@@ -118,27 +116,26 @@ impl<
                 }
             }
             scheduling::Subservice::TcDisableScheduling => {
-                let opt_started_token = match self.service_helper.verif_reporter().start_success(
-                    &self.service_helper.common.tm_sender,
-                    ecss_tc_and_token.token,
-                    time_stamp,
-                ) {
-                    Ok(started_token) => Some(started_token),
-                    Err(e) => {
-                        error_callback(&PartialPusHandlingError::Verification(e));
-                        None
-                    }
-                };
+                let start_token = self
+                    .service_helper
+                    .verif_reporter()
+                    .start_success(
+                        &self.service_helper.common.tm_sender,
+                        ecss_tc_and_token.token,
+                        time_stamp,
+                    )
+                    .expect("Error sending start success");
 
                 self.scheduler.disable();
-                if !self.scheduler.is_enabled() && opt_started_token.is_some() {
-                    if let Err(e) = self.service_helper.verif_reporter().completion_success(
-                        &self.service_helper.common.tm_sender,
-                        opt_started_token.unwrap(),
-                        time_stamp,
-                    ) {
-                        error_callback(&PartialPusHandlingError::Verification(e));
-                    }
+                if !self.scheduler.is_enabled() {
+                    self.service_helper
+                        .verif_reporter()
+                        .completion_success(
+                            &self.service_helper.common.tm_sender,
+                            start_token,
+                            time_stamp,
+                        )
+                        .expect("Error sending completion success");
                 } else {
                     return Err(PusPacketHandlingError::Other(
                         "failed to disable scheduler".to_string(),
@@ -197,13 +194,18 @@ impl<
             }
             _ => {
                 // Treat unhandled standard subservices as custom subservices for now.
-                return Ok(DirectPusPacketHandlerResult::CustomSubservice(
+                return Ok(PusPacketHandlerResult::CustomSubservice(
                     subservice,
                     ecss_tc_and_token.token,
                 ));
             }
         }
-        Ok(HandlingStatus::HandledOne.into())
+        if let Some(partial_error) = partial_error {
+            return Ok(PusPacketHandlerResult::RequestHandledPartialSuccess(
+                partial_error,
+            ));
+        }
+        Ok(PusPacketHandlerResult::RequestHandled)
     }
 }
 /// Helper type definition for a PUS 11 handler with a dynamic TMTC memory backend and regular
@@ -255,7 +257,7 @@ mod tests {
         verification::{RequestId, TcStateAccepted, VerificationToken},
         EcssTcInSharedStoreConverter,
     };
-    use crate::pus::{DirectPusPacketHandlerResult, MpscTcReceiver, PusPacketHandlingError};
+    use crate::pus::{MpscTcReceiver, PusPacketHandlerResult, PusPacketHandlingError};
     use crate::tmtc::PacketSenderWithSharedPool;
     use alloc::collections::VecDeque;
     use delegate::delegate;
@@ -296,12 +298,10 @@ mod tests {
             }
         }
 
-        pub fn handle_one_tc(
-            &mut self,
-        ) -> Result<DirectPusPacketHandlerResult, PusPacketHandlingError> {
+        pub fn handle_one_tc(&mut self) -> Result<PusPacketHandlerResult, PusPacketHandlingError> {
             let time_stamp = cds::CdsTime::new_with_u16_days(0, 0).to_vec().unwrap();
             self.handler
-                .poll_and_handle_next_tc(|_| {}, &time_stamp, &mut self.sched_tc_pool)
+                .poll_and_handle_next_tc(&time_stamp, &mut self.sched_tc_pool)
         }
     }
 
@@ -315,13 +315,9 @@ mod tests {
                 .expect("acceptance success failure")
         }
 
-        fn send_tc(&self, token: &VerificationToken<TcStateAccepted>, tc: &PusTcCreator) {
-            self.common
-                .send_tc(self.handler.service_helper.id(), token, tc);
-        }
-
         delegate! {
             to self.common {
+                fn send_tc(&self, token: &VerificationToken<TcStateAccepted>, tc: &PusTcCreator);
                 fn read_next_tm(&mut self) -> PusTmReader<'_>;
                 fn check_no_tm_available(&self) -> bool;
                 fn check_next_verification_tm(&self, subservice: u8, expected_request_id: RequestId);
@@ -344,7 +340,7 @@ mod tests {
         fn reset(
             &mut self,
             _store: &mut (impl crate::pool::PoolProvider + ?Sized),
-        ) -> Result<(), crate::pool::PoolError> {
+        ) -> Result<(), crate::pool::StoreError> {
             self.reset_count += 1;
             Ok(())
         }
@@ -387,7 +383,7 @@ mod tests {
         let time_stamp = cds::CdsTime::new_with_u16_days(0, 0).to_vec().unwrap();
         test_harness
             .handler
-            .poll_and_handle_next_tc(|_| {}, &time_stamp, &mut test_harness.sched_tc_pool)
+            .poll_and_handle_next_tc(&time_stamp, &mut test_harness.sched_tc_pool)
             .unwrap();
         test_harness.check_next_verification_tm(1, request_id);
         test_harness.check_next_verification_tm(3, request_id);

satrs/src/pus/test.rs

@@ -1,7 +1,8 @@
 use crate::pus::{
-    DirectPusPacketHandlerResult, PartialPusHandlingError, PusPacketHandlingError, PusTmVariant,
+    PacketAsVec, PartialPusHandlingError, PusPacketHandlerResult, PusPacketHandlingError,
+    PusTmVariant,
 };
-use crate::tmtc::{PacketAsVec, PacketSenderWithSharedPool};
+use crate::tmtc::PacketSenderWithSharedPool;
 use spacepackets::ecss::tm::{PusTmCreator, PusTmSecondaryHeader};
 use spacepackets::ecss::PusPacket;
 use spacepackets::SpHeader;
@@ -10,7 +11,7 @@ use std::sync::mpsc;
 use super::verification::{VerificationReporter, VerificationReportingProvider};
 use super::{
     EcssTcInMemConverter, EcssTcInSharedStoreConverter, EcssTcInVecConverter, EcssTcReceiver,
-    EcssTmSender, GenericConversionError, HandlingStatus, MpscTcReceiver, PusServiceHelper,
+    EcssTmSender, GenericConversionError, MpscTcReceiver, PusServiceHelper,
 };
 
 /// This is a helper class for [std] environments to handle generic PUS 17 (test service) packets.
@@ -43,14 +44,13 @@ impl<
         Self { service_helper }
     }
 
-    pub fn poll_and_handle_next_tc<ErrorCb: FnMut(&PartialPusHandlingError)>(
+    pub fn poll_and_handle_next_tc(
         &mut self,
-        mut error_callback: ErrorCb,
         time_stamp: &[u8],
-    ) -> Result<DirectPusPacketHandlerResult, PusPacketHandlingError> {
+    ) -> Result<PusPacketHandlerResult, PusPacketHandlingError> {
         let possible_packet = self.service_helper.retrieve_and_accept_next_packet()?;
         if possible_packet.is_none() {
-            return Ok(HandlingStatus::Empty.into());
+            return Ok(PusPacketHandlerResult::Empty);
         }
         let ecss_tc_and_token = possible_packet.unwrap();
         self.service_helper
@@ -61,16 +61,21 @@ impl<
             return Err(GenericConversionError::WrongService(tc.service()).into());
         }
         if tc.subservice() == 1 {
-            let opt_started_token = match self.service_helper.verif_reporter().start_success(
-                &self.service_helper.common.tm_sender,
-                ecss_tc_and_token.token,
-                time_stamp,
-            ) {
-                Ok(token) => Some(token),
-                Err(e) => {
-                    error_callback(&PartialPusHandlingError::Verification(e));
-                    None
-                }
+            let mut partial_error = None;
+            let result = self
+                .service_helper
+                .verif_reporter()
+                .start_success(
+                    &self.service_helper.common.tm_sender,
+                    ecss_tc_and_token.token,
+                    time_stamp,
+                )
+                .map_err(|_| PartialPusHandlingError::Verification);
+            let start_token = if let Ok(result) = result {
+                Some(result)
+            } else {
+                partial_error = Some(result.unwrap_err());
+                None
             };
             // Sequence count will be handled centrally in TM funnel.
             // It is assumed that the verification reporter was built with a valid APID, so we use
@@ -79,30 +84,42 @@ impl<
                 SpHeader::new_for_unseg_tm(self.service_helper.verif_reporter().apid(), 0, 0);
             let tc_header = PusTmSecondaryHeader::new_simple(17, 2, time_stamp);
             let ping_reply = PusTmCreator::new(reply_header, tc_header, &[], true);
-            if let Err(e) = self
+            let result = self
                 .service_helper
                 .common
                 .tm_sender
                 .send_tm(self.service_helper.id(), PusTmVariant::Direct(ping_reply))
-            {
-                error_callback(&PartialPusHandlingError::TmSend(e));
+                .map_err(PartialPusHandlingError::TmSend);
+            if let Err(err) = result {
+                partial_error = Some(err);
             }
-            if let Some(start_token) = opt_started_token {
-                if let Err(e) = self.service_helper.verif_reporter().completion_success(
-                    &self.service_helper.common.tm_sender,
-                    start_token,
-                    time_stamp,
-                ) {
-                    error_callback(&PartialPusHandlingError::Verification(e));
+
+            if let Some(start_token) = start_token {
+                if self
+                    .service_helper
+                    .verif_reporter()
+                    .completion_success(
+                        &self.service_helper.common.tm_sender,
+                        start_token,
+                        time_stamp,
+                    )
+                    .is_err()
+                {
+                    partial_error = Some(PartialPusHandlingError::Verification)
                 }
             }
+            if let Some(partial_error) = partial_error {
+                return Ok(PusPacketHandlerResult::RequestHandledPartialSuccess(
+                    partial_error,
+                ));
+            };
         } else {
-            return Ok(DirectPusPacketHandlerResult::CustomSubservice(
+            return Ok(PusPacketHandlerResult::CustomSubservice(
                 tc.subservice(),
                 ecss_tc_and_token.token,
             ));
         }
-        Ok(HandlingStatus::HandledOne.into())
+        Ok(PusPacketHandlerResult::RequestHandled)
     }
 }
 
@@ -142,9 +159,8 @@ mod tests {
     };
     use crate::pus::verification::{TcStateAccepted, VerificationToken};
     use crate::pus::{
-        DirectPusPacketHandlerResult, EcssTcInSharedStoreConverter, EcssTcInVecConverter,
-        GenericConversionError, HandlingStatus, MpscTcReceiver, MpscTmAsVecSender,
-        PartialPusHandlingError, PusPacketHandlingError,
+        EcssTcInSharedStoreConverter, EcssTcInVecConverter, GenericConversionError, MpscTcReceiver,
+        MpscTmAsVecSender, PusPacketHandlerResult, PusPacketHandlingError,
     };
     use crate::tmtc::PacketSenderWithSharedPool;
     use crate::ComponentId;
@@ -188,14 +204,10 @@ mod tests {
                 .expect("acceptance success failure")
         }
 
-        fn send_tc(&self, token: &VerificationToken<TcStateAccepted>, tc: &PusTcCreator) {
-            self.common
-                .send_tc(self.handler.service_helper.id(), token, tc);
-        }
-
         delegate! {
             to self.common {
                 fn read_next_tm(&mut self) -> PusTmReader<'_>;
+                fn send_tc(&self, token: &VerificationToken<TcStateAccepted>, tc: &PusTcCreator);
                 fn check_no_tm_available(&self) -> bool;
                 fn check_next_verification_tm(
                     &self,
@@ -206,12 +218,9 @@ mod tests {
         }
     }
     impl SimplePusPacketHandler for Pus17HandlerWithStoreTester {
-        fn handle_one_tc(
-            &mut self,
-        ) -> Result<DirectPusPacketHandlerResult, PusPacketHandlingError> {
+        fn handle_one_tc(&mut self) -> Result<PusPacketHandlerResult, PusPacketHandlingError> {
             let time_stamp = cds::CdsTime::new_with_u16_days(0, 0).to_vec().unwrap();
-            self.handler
-                .poll_and_handle_next_tc(|_partial_error: &PartialPusHandlingError| {}, &time_stamp)
+            self.handler.poll_and_handle_next_tc(&time_stamp)
         }
     }
 
@@ -246,13 +255,9 @@ mod tests {
                 .expect("acceptance success failure")
         }
 
-        fn send_tc(&self, token: &VerificationToken<TcStateAccepted>, tc: &PusTcCreator) {
-            self.common
-                .send_tc(self.handler.service_helper.id(), token, tc);
-        }
-
         delegate! {
             to self.common {
+                fn send_tc(&self, token: &VerificationToken<TcStateAccepted>, tc: &PusTcCreator);
                 fn read_next_tm(&mut self) -> PusTmReader<'_>;
                 fn check_no_tm_available(&self) -> bool;
                 fn check_next_verification_tm(
@@ -264,12 +269,9 @@ mod tests {
         }
     }
     impl SimplePusPacketHandler for Pus17HandlerWithVecTester {
-        fn handle_one_tc(
-            &mut self,
-        ) -> Result<DirectPusPacketHandlerResult, PusPacketHandlingError> {
+        fn handle_one_tc(&mut self) -> Result<PusPacketHandlerResult, PusPacketHandlingError> {
             let time_stamp = cds::CdsTime::new_with_u16_days(0, 0).to_vec().unwrap();
-            self.handler
-                .poll_and_handle_next_tc(|_partial_error: &PartialPusHandlingError| {}, &time_stamp)
+            self.handler.poll_and_handle_next_tc(&time_stamp)
         }
     }
 
@@ -319,11 +321,10 @@ mod tests {
         let mut test_harness = Pus17HandlerWithStoreTester::new(0);
         let result = test_harness.handle_one_tc();
         assert!(result.is_ok());
-        match result.unwrap() {
-            DirectPusPacketHandlerResult::Handled(handled) => {
-                assert_eq!(handled, HandlingStatus::Empty);
-            }
-            _ => panic!("unexpected result"),
+        let result = result.unwrap();
+        if let PusPacketHandlerResult::Empty = result {
+        } else {
+            panic!("unexpected result type {result:?}")
         }
     }
 
@@ -359,7 +360,7 @@ mod tests {
         let result = test_harness.handle_one_tc();
         assert!(result.is_ok());
         let result = result.unwrap();
-        if let DirectPusPacketHandlerResult::CustomSubservice(subservice, _) = result {
+        if let PusPacketHandlerResult::CustomSubservice(subservice, _) = result {
             assert_eq!(subservice, 200);
         } else {
             panic!("unexpected result type {result:?}")

satrs/src/pus/verification.rs

@@ -79,7 +79,6 @@
 //! The [integration test](https://egit.irs.uni-stuttgart.de/rust/fsrc-launchpad/src/branch/main/fsrc-core/tests/verification_test.rs)
 //! 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::{source_buffer_large_enough, EcssTmSender, EcssTmtcError};
 use core::fmt::{Debug, Display, Formatter};
 use core::hash::{Hash, Hasher};
@@ -99,11 +98,18 @@ pub use crate::seq_count::SeqCountProviderSimple;
 pub use spacepackets::ecss::verification::*;
 
 #[cfg(feature = "alloc")]
+#[cfg_attr(feature = "doc_cfg", doc(cfg(feature = "alloc")))]
 pub use alloc_mod::*;
 
 use crate::request::Apid;
 use crate::ComponentId;
 
+/*
+#[cfg(feature = "std")]
+#[cfg_attr(feature = "doc_cfg", doc(cfg(feature = "std")))]
+pub use std_mod::*;
+ */
+
 /// This is a request identifier as specified in 5.4.11.2 c. of the PUS standard.
 ///
 /// This field equivalent to the first two bytes of the CCSDS space packet header.
@@ -354,7 +360,7 @@ pub struct FailParams<'stamp, 'fargs> {
 impl<'stamp, 'fargs> FailParams<'stamp, 'fargs> {
     pub fn new(
         time_stamp: &'stamp [u8],
-        failure_code: &'fargs dyn EcssEnumeration,
+        failure_code: &'fargs impl EcssEnumeration,
         failure_data: &'fargs [u8],
     ) -> Self {
         Self {
@@ -382,7 +388,7 @@ impl<'stamp, 'fargs> FailParamsWithStep<'stamp, 'fargs> {
     pub fn new(
         time_stamp: &'stamp [u8],
         step: &'fargs impl EcssEnumeration,
-        failure_code: &'fargs dyn EcssEnumeration,
+        failure_code: &'fargs impl EcssEnumeration,
         failure_data: &'fargs [u8],
     ) -> Self {
         Self {
@@ -1172,143 +1178,26 @@ pub mod alloc_mod {
     }
 }
 
-pub struct FailParamHelper<'stamp, 'fargs, 'buf, 'params> {
-    pub timestamp: &'stamp [u8],
-    pub error_code: &'fargs dyn EcssEnumeration,
-    pub small_data_buf: &'buf mut [u8],
-    pub params: Option<&'params Params>,
-}
+/*
+#[cfg(feature = "std")]
+pub mod std_mod {
+    use std::sync::mpsc;
 
-/// This helper function simplifies generating completion failures where the error data has
-/// the generic [Params] type.
-///
-/// A small data buffer needs to be supplied for the [Params::Heapless] type because all data
-/// suplied as error data must be held in a slice. Passing a static buffer avoids dynamic memory
-/// allocation for this case.
-///
-/// Please note that this specific function can not propagate the [Params::Store] variant.
-/// This function also might not be able to propagate other error variants which are added in
-/// the future. The returned boolean on success denotes whether the error parameters were
-/// propagated properly.
-pub fn handle_completion_failure_with_generic_params<TcState: WasAtLeastAccepted + Copy>(
-    tm_sender: &(impl EcssTmSender + ?Sized),
-    verif_token: VerificationToken<TcState>,
-    verif_reporter: &impl VerificationReportingProvider,
-    helper: FailParamHelper,
-) -> Result<bool, EcssTmtcError> {
-    let mut error_params_propagated = true;
-    if helper.params.is_none() {
-        verif_reporter.completion_failure(
-            tm_sender,
-            verif_token,
-            FailParams::new(helper.timestamp, helper.error_code, &[]),
-        )?;
-        return Ok(true);
-    }
-    let error_params = helper.params.unwrap();
-    match error_params {
-        Params::Heapless(heapless_param) => {
-            heapless_param
-                .write_to_be_bytes(&mut helper.small_data_buf[..heapless_param.written_len()])?;
-            verif_reporter.completion_failure(
-                tm_sender,
-                verif_token,
-                FailParams::new(
-                    helper.timestamp,
-                    helper.error_code,
-                    &helper.small_data_buf[..heapless_param.written_len()],
-                ),
-            )?;
-        }
-        #[cfg(feature = "alloc")]
-        Params::Vec(vec) => {
-            verif_reporter.completion_failure(
-                tm_sender,
-                verif_token,
-                FailParams::new(helper.timestamp, helper.error_code, vec),
-            )?;
-        }
-        #[cfg(feature = "alloc")]
-        Params::String(str) => {
-            verif_reporter.completion_failure(
-                tm_sender,
-                verif_token,
-                FailParams::new(helper.timestamp, helper.error_code, str.as_bytes()),
-            )?;
-        }
-        _ => {
-            verif_reporter.completion_failure(
-                tm_sender,
-                verif_token,
-                FailParams::new(helper.timestamp, helper.error_code, &[]),
-            )?;
-            error_params_propagated = false;
-        }
-    }
-    Ok(error_params_propagated)
-}
+    use crate::pool::StoreAddr;
+    use crate::pus::verification::VerificationReporterWithSender;
 
-/// This function is similar to [handle_completion_failure_with_error_as_params] but handles the
-/// step failure case.
-pub fn handle_step_failure_with_generic_params(
-    tm_sender: &(impl EcssTmSender + ?Sized),
-    verif_token: VerificationToken<TcStateStarted>,
-    verif_reporter: &impl VerificationReportingProvider,
-    helper: FailParamHelper,
-    step: &impl EcssEnumeration,
-) -> Result<bool, EcssTmtcError> {
-    if helper.params.is_none() {
-        verif_reporter.step_failure(
-            tm_sender,
-            verif_token,
-            FailParamsWithStep::new(helper.timestamp, step, helper.error_code, &[]),
-        )?;
-        return Ok(true);
-    }
-    let error_params = helper.params.unwrap();
-    let mut error_params_propagated = true;
-    match error_params {
-        Params::Heapless(heapless_param) => {
-            heapless_param
-                .write_to_be_bytes(&mut helper.small_data_buf[..heapless_param.written_len()])?;
-            verif_reporter.step_failure(
-                tm_sender,
-                verif_token,
-                FailParamsWithStep::new(
-                    helper.timestamp,
-                    step,
-                    helper.error_code,
-                    &helper.small_data_buf[..heapless_param.written_len()],
-                ),
-            )?;
-        }
-        #[cfg(feature = "alloc")]
-        Params::Vec(vec) => {
-            verif_reporter.step_failure(
-                tm_sender,
-                verif_token,
-                FailParamsWithStep::new(helper.timestamp, step, helper.error_code, vec),
-            )?;
-        }
-        #[cfg(feature = "alloc")]
-        Params::String(str) => {
-            verif_reporter.step_failure(
-                tm_sender,
-                verif_token,
-                FailParamsWithStep::new(helper.timestamp, step, helper.error_code, str.as_bytes()),
-            )?;
-        }
-        _ => {
-            verif_reporter.step_failure(
-                tm_sender,
-                verif_token,
-                FailParamsWithStep::new(helper.timestamp, step, helper.error_code, &[]),
-            )?;
-            error_params_propagated = false;
-        }
-    }
-    Ok(error_params_propagated)
+    use super::alloc_mod::VerificationReporterWithSharedPoolSender;
+
+    pub type VerificationReporterWithSharedPoolMpscSender =
+        VerificationReporterWithSharedPoolSender<mpsc::Sender<StoreAddr>>;
+    pub type VerificationReporterWithSharedPoolMpscBoundedSender =
+        VerificationReporterWithSharedPoolSender<mpsc::SyncSender<StoreAddr>>;
+    pub type VerificationReporterWithVecMpscSender =
+        VerificationReporterWithSender<mpsc::Sender<alloc::vec::Vec<u8>>>;
+    pub type VerificationReporterWithVecMpscBoundedSender =
+        VerificationReporterWithSender<mpsc::SyncSender<alloc::vec::Vec<u8>>>;
 }
+ */
 
 #[cfg(any(feature = "test_util", test))]
 pub mod test_util {
@@ -1684,19 +1573,73 @@ pub mod test_util {
                 .pop_front()
                 .expect("report queue is empty")
         }
+        /*
+        pub fn verification_info(&self, req_id: &RequestId) -> Option<VerificationStatus> {
+            let verif_map = self.verification_map.lock().unwrap();
+            let value = verif_map.borrow().get(req_id).cloned();
+            value
+        }
+
+
+        pub fn check_started(&self, req_id: &RequestId) -> bool {
+            let verif_map = self.verification_map.lock().unwrap();
+            if let Some(entry) = verif_map.borrow().get(req_id) {
+                return entry.started.unwrap_or(false);
+            }
+            false
+        }
+
+        fn generic_completion_checks(
+            entry: &VerificationStatus,
+            step: Option<u16>,
+            completion_success: bool,
+        ) {
+            assert!(entry.accepted.unwrap());
+            assert!(entry.started.unwrap());
+            if let Some(step) = step {
+                assert!(entry.step_status.unwrap());
+                assert_eq!(entry.step, step);
+            } else {
+                assert!(entry.step_status.is_none());
+            }
+            assert_eq!(entry.completed.unwrap(), completion_success);
+        }
+
+
+        pub fn assert_completion_failure(
+            &self,
+            req_id: &RequestId,
+            step: Option<u16>,
+            error_code: u64,
+        ) {
+            let verif_map = self.verification_map.lock().unwrap();
+            if let Some(entry) = verif_map.borrow().get(req_id) {
+                Self::generic_completion_checks(entry, step, false);
+                assert_eq!(entry.fail_enum.unwrap(), error_code);
+                return;
+            }
+            panic!("request not in verification map");
+        }
+
+        pub fn completion_status(&self, req_id: &RequestId) -> Option<bool> {
+            let verif_map = self.verification_map.lock().unwrap();
+            if let Some(entry) = verif_map.borrow().get(req_id) {
+                return entry.completed;
+            }
+            panic!("request not in verification map");
+        }
+         */
     }
 }
 
 #[cfg(test)]
 pub mod tests {
-    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::{
-        handle_step_failure_with_generic_params, EcssTmSender, EcssTmtcError, FailParams,
-        FailParamsWithStep, RequestId, TcStateNone, VerificationReporter, VerificationReporterCfg,
-        VerificationToken,
+        EcssTmSender, EcssTmtcError, FailParams, FailParamsWithStep, RequestId, TcStateNone,
+        VerificationReporter, VerificationReporterCfg, VerificationToken,
     };
     use crate::pus::{ChannelWithId, PusTmVariant};
     use crate::request::MessageMetadata;
@@ -1704,7 +1647,6 @@ pub mod tests {
     use crate::tmtc::{PacketSenderWithSharedPool, SharedPacketPool};
     use crate::ComponentId;
     use alloc::format;
-    use alloc::string::ToString;
     use spacepackets::ecss::tc::{PusTcCreator, PusTcReader, PusTcSecondaryHeader};
     use spacepackets::ecss::{
         EcssEnumU16, EcssEnumU32, EcssEnumU8, EcssEnumeration, PusError, PusPacket,
@@ -1719,9 +1661,8 @@ pub mod tests {
     use std::vec::Vec;
 
     use super::{
-        handle_completion_failure_with_generic_params, DummyVerificationHook, FailParamHelper,
-        SeqCountProviderSimple, TcStateAccepted, TcStateStarted, VerificationHookProvider,
-        VerificationReportingProvider, WasAtLeastAccepted,
+        DummyVerificationHook, SeqCountProviderSimple, TcStateAccepted, TcStateStarted,
+        VerificationHookProvider, VerificationReportingProvider, WasAtLeastAccepted,
     };
 
     fn is_send<T: Send>(_: &T) {}
@@ -1729,7 +1670,6 @@ pub mod tests {
     fn is_sync<T: Sync>(_: &T) {}
 
     const EMPTY_STAMP: [u8; 7] = [0; 7];
-    const DUMMY_STAMP: &[u8] = &[0, 1, 0, 1, 0, 1, 0];
 
     #[derive(Debug, Eq, PartialEq, Clone)]
     struct TmInfo {
@@ -1807,8 +1747,8 @@ pub mod tests {
         tc: Vec<u8>,
     }
 
-    fn base_reporter(id: ComponentId, max_fail_data_len: usize) -> VerificationReporter {
-        let cfg = VerificationReporterCfg::new(TEST_APID, 1, 2, max_fail_data_len).unwrap();
+    fn base_reporter(id: ComponentId) -> VerificationReporter {
+        let cfg = VerificationReporterCfg::new(TEST_APID, 1, 2, 8).unwrap();
         VerificationReporter::new(id, &cfg)
     }
 
@@ -1911,57 +1851,66 @@ pub mod tests {
                 .completion_failure(&self.sender, token, params)
         }
 
-        fn check_acceptance_success(&self, timestamp: &[u8; 7]) {
+        fn completion_success_check(&mut self, incrementing_couters: bool) {
+            assert_eq!(self.sender.service_queue.borrow().len(), 3);
+            let mut current_seq_count = 0;
             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 {
+                    subservice: 1,
+                    apid: TEST_APID,
+                    seq_count: current_seq_count,
+                    msg_counter: current_seq_count,
+                    dest_id: self.reporter.dest_id(),
+                    time_stamp: EMPTY_STAMP,
+                },
                 additional_data: None,
             };
-            let mut service_queue = self.sender.service_queue.borrow_mut();
-            assert!(service_queue.len() >= 1);
-            let info = service_queue.pop_front().unwrap();
+            let mut info = self.sender.service_queue.borrow_mut().pop_front().unwrap();
             assert_eq!(info, cmp_info);
-        }
 
-        fn check_start_success(&mut self, seq_count: u16, msg_counter: u16, timestamp: &[u8]) {
-            let mut srv_queue = self.sender.service_queue.borrow_mut();
+            if incrementing_couters {
+                current_seq_count += 1;
+            }
+
             let cmp_info = TmInfo {
                 requestor: MessageMetadata::new(self.request_id.into(), self.id),
-                common: CommonTmInfo::new(
-                    3,
-                    TEST_APID,
-                    seq_count,
-                    msg_counter,
-                    self.reporter.dest_id(),
-                    timestamp,
-                ),
+                common: CommonTmInfo {
+                    subservice: 3,
+                    apid: TEST_APID,
+                    msg_counter: current_seq_count,
+                    seq_count: current_seq_count,
+                    dest_id: self.reporter.dest_id(),
+                    time_stamp: [0, 1, 0, 1, 0, 1, 0],
+                },
                 additional_data: None,
             };
-            let info = srv_queue.pop_front().unwrap();
+            info = self.sender.service_queue.borrow_mut().pop_front().unwrap();
             assert_eq!(info, cmp_info);
-        }
 
-        fn check_completion_success(&mut self, seq_count: u16, msg_counter: u16) {
+            if incrementing_couters {
+                current_seq_count += 1;
+            }
             let cmp_info = TmInfo {
                 requestor: MessageMetadata::new(self.request_id.into(), self.id),
-                common: CommonTmInfo::new(
-                    7,
-                    TEST_APID,
-                    seq_count,
-                    msg_counter,
-                    self.reporter.dest_id(),
-                    &EMPTY_STAMP,
-                ),
+                common: CommonTmInfo {
+                    subservice: 7,
+                    apid: TEST_APID,
+                    msg_counter: current_seq_count,
+                    seq_count: current_seq_count,
+                    dest_id: self.reporter.dest_id(),
+                    time_stamp: EMPTY_STAMP,
+                },
                 additional_data: None,
             };
-            let info = self.sender.service_queue.borrow_mut().pop_front().unwrap();
+            info = self.sender.service_queue.borrow_mut().pop_front().unwrap();
             assert_eq!(info, cmp_info);
         }
     }
 
     impl VerificationReporterTestbench<DummyVerificationHook> {
-        fn new(id: ComponentId, tc: PusTcCreator, max_fail_data_len: usize) -> Self {
-            let reporter = base_reporter(id, max_fail_data_len);
+        fn new(id: ComponentId, tc: PusTcCreator) -> Self {
+            let reporter = base_reporter(id);
             Self {
                 id,
                 sender: TestSender::default(),
@@ -1971,10 +1920,36 @@ pub mod tests {
             }
         }
 
-        fn check_acceptance_failure(&mut self, timestamp: &[u8; 7]) {
+        fn acceptance_check(&self, time_stamp: &[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 {
+                    subservice: 1,
+                    apid: TEST_APID,
+                    seq_count: 0,
+                    msg_counter: 0,
+                    dest_id: self.reporter.dest_id(),
+                    time_stamp: *time_stamp,
+                },
+                additional_data: None,
+            };
+            let mut service_queue = self.sender.service_queue.borrow_mut();
+            assert_eq!(service_queue.len(), 1);
+            let info = service_queue.pop_front().unwrap();
+            assert_eq!(info, cmp_info);
+        }
+
+        fn acceptance_fail_check(&mut self, stamp_buf: [u8; 7]) {
+            let cmp_info = TmInfo {
+                requestor: MessageMetadata::new(self.request_id.into(), self.id),
+                common: CommonTmInfo {
+                    subservice: 2,
+                    seq_count: 0,
+                    apid: TEST_APID,
+                    msg_counter: 0,
+                    dest_id: self.reporter.dest_id(),
+                    time_stamp: stamp_buf,
+                },
                 additional_data: Some([0, 2].to_vec()),
             };
             let service_queue = self.sender.service_queue.get_mut();
@@ -1983,12 +1958,12 @@ pub mod tests {
             assert_eq!(info, cmp_info);
         }
 
-        fn check_start_failure(&mut self, fail_data_raw: [u8; 4]) {
+        fn start_fail_check(&mut self, fail_data_raw: [u8; 4]) {
             let mut srv_queue = self.sender.service_queue.borrow_mut();
             assert_eq!(srv_queue.len(), 2);
             let mut cmp_info = TmInfo {
                 requestor: MessageMetadata::new(self.request_id.into(), self.id),
-                common: CommonTmInfo::new_zero_seq_count(1, TEST_APID, 0, &EMPTY_STAMP),
+                common: CommonTmInfo::new_zero_seq_count(1, TEST_APID, 0, EMPTY_STAMP),
                 additional_data: None,
             };
             let mut info = srv_queue.pop_front().unwrap();
@@ -1996,67 +1971,148 @@ pub mod tests {
 
             cmp_info = TmInfo {
                 requestor: MessageMetadata::new(self.request_id.into(), self.id),
-                common: CommonTmInfo::new_zero_seq_count(4, TEST_APID, 0, &EMPTY_STAMP),
+                common: CommonTmInfo::new_zero_seq_count(4, TEST_APID, 0, EMPTY_STAMP),
                 additional_data: Some([&[22], fail_data_raw.as_slice()].concat().to_vec()),
             };
             info = srv_queue.pop_front().unwrap();
             assert_eq!(info, cmp_info);
         }
 
-        fn check_step_success(&mut self, step: u8, timestamp: &[u8; 7]) {
-            let cmp_info = TmInfo {
+        fn step_success_check(&mut self, time_stamp: &[u8; 7]) {
+            let mut cmp_info = TmInfo {
                 requestor: MessageMetadata::new(self.request_id.into(), self.id),
-                common: CommonTmInfo::new_zero_seq_count(5, TEST_APID, 0, timestamp),
-                additional_data: Some([step].to_vec()),
+                common: CommonTmInfo::new_zero_seq_count(1, TEST_APID, 0, *time_stamp),
+                additional_data: None,
             };
             let mut srv_queue = self.sender.service_queue.borrow_mut();
-            let info = srv_queue.pop_front().unwrap();
+            let mut info = srv_queue.pop_front().unwrap();
+            assert_eq!(info, cmp_info);
+            cmp_info = TmInfo {
+                requestor: MessageMetadata::new(self.request_id.into(), self.id),
+                common: CommonTmInfo::new_zero_seq_count(3, TEST_APID, 0, *time_stamp),
+                additional_data: None,
+            };
+            info = srv_queue.pop_front().unwrap();
+            assert_eq!(info, cmp_info);
+            cmp_info = TmInfo {
+                requestor: MessageMetadata::new(self.request_id.into(), self.id),
+                common: CommonTmInfo::new_zero_seq_count(5, TEST_APID, 0, *time_stamp),
+                additional_data: Some([0].to_vec()),
+            };
+            info = srv_queue.pop_front().unwrap();
+            assert_eq!(info, cmp_info);
+            cmp_info = TmInfo {
+                requestor: MessageMetadata::new(self.request_id.into(), self.id),
+                common: CommonTmInfo::new_zero_seq_count(5, TEST_APID, 0, *time_stamp),
+                additional_data: Some([1].to_vec()),
+            };
+            info = srv_queue.pop_front().unwrap();
             assert_eq!(info, cmp_info);
         }
 
-        fn check_step_failure(
-            &mut self,
-            step: &impl EcssEnumeration,
-            error_code: &impl EcssEnumeration,
-            fail_data: &[u8],
-        ) {
-            let mut additional_data = Vec::new();
-            additional_data.extend(step.to_vec());
-            additional_data.extend(error_code.to_vec());
-            additional_data.extend(fail_data);
-            let cmp_info = TmInfo {
+        fn check_step_failure(&mut self, fail_data_raw: [u8; 4]) {
+            assert_eq!(self.sender.service_queue.borrow().len(), 4);
+            let mut cmp_info = TmInfo {
+                requestor: MessageMetadata::new(self.request_id.into(), self.id),
+                common: CommonTmInfo::new_zero_seq_count(
+                    1,
+                    TEST_APID,
+                    self.reporter.dest_id(),
+                    EMPTY_STAMP,
+                ),
+                additional_data: None,
+            };
+            let mut info = self.sender.service_queue.borrow_mut().pop_front().unwrap();
+            assert_eq!(info, cmp_info);
+
+            cmp_info = TmInfo {
+                requestor: MessageMetadata::new(self.request_id.into(), self.id),
+                common: CommonTmInfo::new_zero_seq_count(
+                    3,
+                    TEST_APID,
+                    self.reporter.dest_id(),
+                    [0, 1, 0, 1, 0, 1, 0],
+                ),
+                additional_data: None,
+            };
+            info = self.sender.service_queue.borrow_mut().pop_front().unwrap();
+            assert_eq!(info, cmp_info);
+
+            cmp_info = TmInfo {
+                requestor: MessageMetadata::new(self.request_id.into(), self.id),
+                common: CommonTmInfo::new_zero_seq_count(
+                    5,
+                    TEST_APID,
+                    self.reporter.dest_id(),
+                    EMPTY_STAMP,
+                ),
+                additional_data: Some([0].to_vec()),
+            };
+            info = self.sender.service_queue.get_mut().pop_front().unwrap();
+            assert_eq!(info, cmp_info);
+
+            cmp_info = TmInfo {
                 requestor: MessageMetadata::new(self.request_id.into(), self.id),
                 common: CommonTmInfo::new_zero_seq_count(
                     6,
                     TEST_APID,
                     self.reporter.dest_id(),
-                    &EMPTY_STAMP,
+                    EMPTY_STAMP,
+                ),
+                additional_data: Some(
+                    [
+                        [1].as_slice(),
+                        &[0, 0, 0x10, 0x20],
+                        fail_data_raw.as_slice(),
+                    ]
+                    .concat()
+                    .to_vec(),
                 ),
-                additional_data: Some(additional_data),
             };
-            let info = self.sender.service_queue.get_mut().pop_front().unwrap();
+            info = self.sender.service_queue.get_mut().pop_front().unwrap();
             assert_eq!(info, cmp_info);
         }
 
-        fn check_completion_failure(
-            &mut self,
-            error_code: &impl EcssEnumeration,
-            fail_data: &[u8],
-        ) {
-            let mut additional_data = Vec::new();
-            additional_data.extend(error_code.to_vec());
-            additional_data.extend(fail_data);
-            let cmp_info = TmInfo {
+        fn completion_fail_check(&mut self) {
+            assert_eq!(self.sender.service_queue.borrow().len(), 3);
+
+            let mut cmp_info = TmInfo {
+                requestor: MessageMetadata::new(self.request_id.into(), self.id),
+                common: CommonTmInfo::new_zero_seq_count(
+                    1,
+                    TEST_APID,
+                    self.reporter.dest_id(),
+                    EMPTY_STAMP,
+                ),
+                additional_data: None,
+            };
+            let mut info = self.sender.service_queue.get_mut().pop_front().unwrap();
+            assert_eq!(info, cmp_info);
+
+            cmp_info = TmInfo {
+                requestor: MessageMetadata::new(self.request_id.into(), self.id),
+                common: CommonTmInfo::new_zero_seq_count(
+                    3,
+                    TEST_APID,
+                    self.reporter.dest_id(),
+                    [0, 1, 0, 1, 0, 1, 0],
+                ),
+                additional_data: None,
+            };
+            info = self.sender.service_queue.get_mut().pop_front().unwrap();
+            assert_eq!(info, cmp_info);
+
+            cmp_info = TmInfo {
                 requestor: MessageMetadata::new(self.request_id.into(), self.id),
                 common: CommonTmInfo::new_zero_seq_count(
                     8,
                     TEST_APID,
                     self.reporter.dest_id(),
-                    &EMPTY_STAMP,
+                    EMPTY_STAMP,
                 ),
-                additional_data: Some(additional_data),
+                additional_data: Some([0, 0, 0x10, 0x20].to_vec()),
             };
-            let info = self.sender.service_queue.get_mut().pop_front().unwrap();
+            info = self.sender.service_queue.get_mut().pop_front().unwrap();
             assert_eq!(info, cmp_info);
         }
     }
@@ -2079,7 +2135,7 @@ pub mod tests {
 
     #[test]
     fn test_state() {
-        let mut testbench = VerificationReporterTestbench::new(0, create_generic_ping(), 16);
+        let mut testbench = VerificationReporterTestbench::new(0, create_generic_ping());
         assert_eq!(testbench.reporter.apid(), TEST_APID);
         testbench.reporter.set_apid(TEST_APID + 1);
         assert_eq!(testbench.reporter.apid(), TEST_APID + 1);
@@ -2087,43 +2143,43 @@ pub mod tests {
 
     #[test]
     fn test_basic_acceptance_success() {
-        let mut testbench = VerificationReporterTestbench::new(0, create_generic_ping(), 16);
+        let mut testbench = VerificationReporterTestbench::new(0, create_generic_ping());
         let token = testbench.init();
         testbench
             .acceptance_success(token, &EMPTY_STAMP)
             .expect("sending acceptance success failed");
-        testbench.check_acceptance_success(&EMPTY_STAMP);
+        testbench.acceptance_check(&EMPTY_STAMP);
     }
 
     #[test]
     fn test_basic_acceptance_failure() {
-        let mut testbench = VerificationReporterTestbench::new(0, create_generic_ping(), 16);
+        let mut testbench = VerificationReporterTestbench::new(0, create_generic_ping());
         let init_token = testbench.init();
-        let timestamp = [1, 2, 3, 4, 5, 6, 7];
+        let stamp_buf = [1, 2, 3, 4, 5, 6, 7];
         let fail_code = EcssEnumU16::new(2);
-        let fail_params = FailParams::new_no_fail_data(timestamp.as_slice(), &fail_code);
+        let fail_params = FailParams::new_no_fail_data(stamp_buf.as_slice(), &fail_code);
         testbench
             .acceptance_failure(init_token, fail_params)
             .expect("sending acceptance failure failed");
-        testbench.check_acceptance_failure(&timestamp);
+        testbench.acceptance_fail_check(stamp_buf);
     }
 
     #[test]
     fn test_basic_acceptance_failure_with_helper() {
-        let mut testbench = VerificationReporterTestbench::new(0, create_generic_ping(), 16);
+        let mut testbench = VerificationReporterTestbench::new(0, create_generic_ping());
         let init_token = testbench.init();
-        let timestamp = [1, 2, 3, 4, 5, 6, 7];
+        let stamp_buf = [1, 2, 3, 4, 5, 6, 7];
         let fail_code = EcssEnumU16::new(2);
-        let fail_params = FailParams::new_no_fail_data(timestamp.as_slice(), &fail_code);
+        let fail_params = FailParams::new_no_fail_data(stamp_buf.as_slice(), &fail_code);
         testbench
             .acceptance_failure(init_token, fail_params)
             .expect("sending acceptance failure failed");
-        testbench.check_acceptance_failure(&timestamp);
+        testbench.acceptance_fail_check(stamp_buf);
     }
 
     #[test]
     fn test_acceptance_fail_data_too_large() {
-        let mut testbench = VerificationReporterTestbench::new(0, create_generic_ping(), 8);
+        let mut testbench = VerificationReporterTestbench::new(0, create_generic_ping());
         let init_token = testbench.init();
         let stamp_buf = [1, 2, 3, 4, 5, 6, 7];
         let fail_code = EcssEnumU16::new(2);
@@ -2155,7 +2211,7 @@ pub mod tests {
 
     #[test]
     fn test_basic_acceptance_failure_with_fail_data() {
-        let mut testbench = VerificationReporterTestbench::new(0, create_generic_ping(), 16);
+        let mut testbench = VerificationReporterTestbench::new(0, create_generic_ping());
         let fail_code = EcssEnumU8::new(10);
         let fail_data = EcssEnumU32::new(12);
         let mut fail_data_raw = [0; 4];
@@ -2167,7 +2223,7 @@ pub mod tests {
             .expect("sending acceptance failure failed");
         let cmp_info = TmInfo {
             requestor: MessageMetadata::new(testbench.request_id.into(), testbench.id),
-            common: CommonTmInfo::new_zero_seq_count(2, TEST_APID, 0, &EMPTY_STAMP),
+            common: CommonTmInfo::new_zero_seq_count(2, TEST_APID, 0, EMPTY_STAMP),
             additional_data: Some([10, 0, 0, 0, 12].to_vec()),
         };
         let mut service_queue = testbench.sender.service_queue.borrow_mut();
@@ -2178,7 +2234,7 @@ pub mod tests {
 
     #[test]
     fn test_start_failure() {
-        let mut testbench = VerificationReporterTestbench::new(0, create_generic_ping(), 16);
+        let mut testbench = VerificationReporterTestbench::new(0, create_generic_ping());
         let init_token = testbench.init();
         let fail_code = EcssEnumU8::new(22);
         let fail_data: i32 = -12;
@@ -2192,12 +2248,12 @@ pub mod tests {
         testbench
             .start_failure(accepted_token, fail_params)
             .expect("Start failure failure");
-        testbench.check_start_failure(fail_data_raw);
+        testbench.start_fail_check(fail_data_raw);
     }
 
     #[test]
     fn test_start_failure_with_helper() {
-        let mut testbench = VerificationReporterTestbench::new(0, create_generic_ping(), 16);
+        let mut testbench = VerificationReporterTestbench::new(0, create_generic_ping());
         let token = testbench.init();
         let fail_code = EcssEnumU8::new(22);
         let fail_data: i32 = -12;
@@ -2211,12 +2267,12 @@ pub mod tests {
         testbench
             .start_failure(accepted_token, fail_params)
             .expect("start failure failed");
-        testbench.check_start_failure(fail_data_raw);
+        testbench.start_fail_check(fail_data_raw);
     }
 
     #[test]
     fn test_steps_success() {
-        let mut testbench = VerificationReporterTestbench::new(0, create_generic_ping(), 16);
+        let mut testbench = VerificationReporterTestbench::new(0, create_generic_ping());
         let token = testbench.init();
         let accepted_token = testbench
             .acceptance_success(token, &EMPTY_STAMP)
@@ -2231,15 +2287,12 @@ pub mod tests {
             .step_success(&started_token, &EMPTY_STAMP, EcssEnumU8::new(1))
             .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_step_success(0, &EMPTY_STAMP);
-        testbench.check_step_success(1, &EMPTY_STAMP);
+        testbench.step_success_check(&EMPTY_STAMP);
     }
 
     #[test]
     fn test_step_failure() {
-        let mut testbench = VerificationReporterTestbench::new(0, create_generic_ping(), 16);
+        let mut testbench = VerificationReporterTestbench::new(0, create_generic_ping());
         let token = testbench.init();
         let fail_code = EcssEnumU32::new(0x1020);
         let fail_data: f32 = -22.3232;
@@ -2257,7 +2310,7 @@ pub mod tests {
             .acceptance_success(token, &EMPTY_STAMP)
             .expect("Sending acceptance success failed");
         let started_token = testbench
-            .start_success(accepted_token, DUMMY_STAMP)
+            .start_success(accepted_token, &[0, 1, 0, 1, 0, 1, 0])
             .expect("Sending start success failed");
         testbench
             .step_success(&started_token, &EMPTY_STAMP, EcssEnumU8::new(0))
@@ -2265,15 +2318,12 @@ pub mod tests {
         testbench
             .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_step_success(0, &EMPTY_STAMP);
-        testbench.check_step_failure(&fail_step, &fail_code, &fail_data_raw);
+        testbench.check_step_failure(fail_data_raw);
     }
 
     #[test]
     fn test_completion_failure() {
-        let mut testbench = VerificationReporterTestbench::new(0, create_generic_ping(), 16);
+        let mut testbench = VerificationReporterTestbench::new(0, create_generic_ping());
         let token = testbench.init();
         let fail_code = EcssEnumU32::new(0x1020);
         let fail_params = FailParams::new_no_fail_data(&EMPTY_STAMP, &fail_code);
@@ -2282,34 +2332,29 @@ pub mod tests {
             .acceptance_success(token, &EMPTY_STAMP)
             .expect("Sending acceptance success failed");
         let started_token = testbench
-            .start_success(accepted_token, DUMMY_STAMP)
+            .start_success(accepted_token, &[0, 1, 0, 1, 0, 1, 0])
             .expect("Sending start success failed");
         testbench
             .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_completion_failure(&fail_code, &[]);
+        testbench.completion_fail_check();
     }
 
     #[test]
     fn test_complete_success_sequence() {
         let mut testbench =
-            VerificationReporterTestbench::new(TEST_COMPONENT_ID_0.id(), create_generic_ping(), 16);
+            VerificationReporterTestbench::new(TEST_COMPONENT_ID_0.id(), create_generic_ping());
         let token = testbench.init();
         let accepted_token = testbench
             .acceptance_success(token, &EMPTY_STAMP)
             .expect("Sending acceptance success failed");
         let started_token = testbench
-            .start_success(accepted_token, DUMMY_STAMP)
+            .start_success(accepted_token, &[0, 1, 0, 1, 0, 1, 0])
             .expect("Sending start success failed");
         testbench
             .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.completion_success_check(false);
     }
 
     #[test]
@@ -2329,83 +2374,6 @@ pub mod tests {
         testbench
             .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);
-    }
-
-    #[test]
-    fn test_completion_failure_helper_string_param() {
-        let mut testbench = VerificationReporterTestbench::new(0, create_generic_ping(), 32);
-        let token = testbench.init();
-        let accepted_token = testbench
-            .acceptance_success(token, &EMPTY_STAMP)
-            .expect("Sending acceptance success failed");
-        let mut small_data_buf: [u8; 16] = [0; 16];
-        let fail_code = EcssEnumU8::new(1);
-        let fail_data = "error 404 oh no".to_string();
-        let fail_params = Params::String(fail_data.clone());
-        let result = handle_completion_failure_with_generic_params(
-            &testbench.sender,
-            accepted_token,
-            &testbench.reporter,
-            FailParamHelper {
-                timestamp: &EMPTY_STAMP,
-                error_code: &fail_code,
-                small_data_buf: &mut small_data_buf,
-                params: Some(&fail_params),
-            },
-        );
-        assert!(result.unwrap());
-        testbench.check_acceptance_success(&EMPTY_STAMP);
-        testbench.check_completion_failure(&fail_code, fail_data.as_bytes());
-    }
-
-    #[test]
-    fn test_step_failure_helper_string_param() {
-        let mut testbench = VerificationReporterTestbench::new(0, create_generic_ping(), 32);
-        let token = testbench.init();
-        let accepted_token = testbench
-            .acceptance_success(token, &EMPTY_STAMP)
-            .expect("Sending acceptance success failed");
-        let started_token = testbench
-            .start_success(accepted_token, &EMPTY_STAMP)
-            .expect("Sending start success failed");
-        let mut small_data_buf: [u8; 16] = [0; 16];
-        let step = EcssEnumU8::new(2);
-        let fail_code = EcssEnumU8::new(1);
-        let fail_data = "AAAAAAAAAAAHHHHHH".to_string();
-        let fail_params = Params::String(fail_data.clone());
-        let result = handle_step_failure_with_generic_params(
-            &testbench.sender,
-            started_token,
-            &testbench.reporter,
-            FailParamHelper {
-                timestamp: &EMPTY_STAMP,
-                error_code: &fail_code,
-                small_data_buf: &mut small_data_buf,
-                params: Some(&fail_params),
-            },
-            &step,
-        );
-        assert!(result.unwrap());
-        testbench.check_acceptance_success(&EMPTY_STAMP);
-        testbench.check_start_success(0, 0, &EMPTY_STAMP);
-        testbench.check_step_failure(&step, &fail_code, fail_data.as_bytes());
-    }
-
-    #[test]
-    fn test_completion_failure_helper_vec_param() {
-        // TODO: Test this.
-    }
-
-    #[test]
-    fn test_completion_failure_helper_raw_param() {
-        // TODO: Test this.
-    }
-
-    #[test]
-    fn test_completion_failure_helper_store_param_ignored() {
-        // TODO: Test this.
+        testbench.completion_success_check(true);
     }
 }

satrs/src/request.rs

@@ -10,7 +10,7 @@ pub use std_mod::*;
 
 use spacepackets::{
     ecss::{tc::IsPusTelecommand, PusPacket},
-    ByteConversionError,
+    ByteConversionError, CcsdsPacket,
 };
 
 use crate::{queue::GenericTargetedMessagingError, ComponentId};
@@ -47,7 +47,7 @@ impl UniqueApidTargetId {
     /// This function attempts to build the ID from a PUS telecommand by extracting the APID
     /// and the first four bytes of the application data field as the target field.
     pub fn from_pus_tc(
-        tc: &(impl PusPacket + IsPusTelecommand),
+        tc: &(impl CcsdsPacket + PusPacket + IsPusTelecommand),
     ) -> Result<Self, ByteConversionError> {
         if tc.user_data().len() < 4 {
             return Err(ByteConversionError::FromSliceTooSmall {

satrs/src/tmtc/mod.rs

@@ -7,19 +7,21 @@
 //! all received telecommands are sent to a special handler object called TC source. Using
 //! a design like this makes it simpler to add new TC packet sources or new telemetry generators:
 //! They only need to send the received and generated data to these objects.
+#[cfg(feature = "std")]
 use crate::queue::GenericSendError;
 use crate::{
-    pool::{PoolAddr, PoolError},
+    pool::{PoolProvider, StoreAddr, StoreError},
+    pus::PacketAsVec,
     ComponentId,
 };
-#[cfg(feature = "std")]
-pub use alloc_mod::*;
+use core::cell::RefCell;
 #[cfg(feature = "alloc")]
 use downcast_rs::{impl_downcast, Downcast};
 use spacepackets::{
     ecss::{
         tc::PusTcReader,
         tm::{PusTmCreator, PusTmReader},
+        WritablePusPacket,
     },
     SpHeader,
 };
@@ -30,23 +32,6 @@ pub use std_mod::*;
 
 pub mod tm_helper;
 
-/// Simple type modelling packet stored inside a pool structure. This structure is intended to
-/// be used when sending a packet via a message queue, so it also contains the sender ID.
-#[derive(Debug, PartialEq, Eq, Clone)]
-pub struct PacketInPool {
-    pub sender_id: ComponentId,
-    pub store_addr: PoolAddr,
-}
-
-impl PacketInPool {
-    pub fn new(sender_id: ComponentId, store_addr: PoolAddr) -> Self {
-        Self {
-            sender_id,
-            store_addr,
-        }
-    }
-}
-
 /// Generic trait for object which can send any packets in form of a raw bytestream, with
 /// no assumptions about the received protocol.
 pub trait PacketSenderRaw: Send {
@@ -54,6 +39,29 @@ pub trait PacketSenderRaw: Send {
     fn send_packet(&self, sender_id: ComponentId, packet: &[u8]) -> Result<(), Self::Error>;
 }
 
+#[cfg(feature = "std")]
+impl PacketSenderRaw for mpsc::Sender<PacketAsVec> {
+    type Error = GenericSendError;
+
+    fn send_packet(&self, sender_id: ComponentId, packet: &[u8]) -> Result<(), Self::Error> {
+        self.send(PacketAsVec::new(sender_id, packet.to_vec()))
+            .map_err(|_| GenericSendError::RxDisconnected)
+    }
+}
+
+#[cfg(feature = "std")]
+impl PacketSenderRaw for mpsc::SyncSender<PacketAsVec> {
+    type Error = GenericSendError;
+
+    fn send_packet(&self, sender_id: ComponentId, tc_raw: &[u8]) -> Result<(), Self::Error> {
+        self.try_send(PacketAsVec::new(sender_id, tc_raw.to_vec()))
+            .map_err(|e| match e {
+                mpsc::TrySendError::Full(_) => GenericSendError::QueueFull(None),
+                mpsc::TrySendError::Disconnected(_) => GenericSendError::RxDisconnected,
+            })
+    }
+}
+
 /// Extension trait of [PacketSenderRaw] which allows downcasting by implementing [Downcast].
 #[cfg(feature = "alloc")]
 pub trait PacketSenderRawExt: PacketSenderRaw + Downcast {
@@ -169,24 +177,75 @@ where
     }
 }
 
+/// Newtype wrapper around the [SharedStaticMemoryPool] to enable extension helper traits on
+/// top of the regular shared memory pool API.
+#[derive(Clone)]
+pub struct SharedPacketPool(pub SharedStaticMemoryPool);
+
+impl SharedPacketPool {
+    pub fn new(pool: &SharedStaticMemoryPool) -> Self {
+        Self(pool.clone())
+    }
+}
+
 /// Helper trait for any generic (static) store which allows storing raw or CCSDS packets.
 pub trait CcsdsPacketPool {
-    fn add_ccsds_tc(&mut self, _: &SpHeader, tc_raw: &[u8]) -> Result<PoolAddr, PoolError> {
+    fn add_ccsds_tc(&mut self, _: &SpHeader, tc_raw: &[u8]) -> Result<StoreAddr, StoreError> {
         self.add_raw_tc(tc_raw)
     }
 
-    fn add_raw_tc(&mut self, tc_raw: &[u8]) -> Result<PoolAddr, PoolError>;
+    fn add_raw_tc(&mut self, tc_raw: &[u8]) -> Result<StoreAddr, StoreError>;
 }
 
 /// Helper trait for any generic (static) store which allows storing ECSS PUS Telecommand packets.
 pub trait PusTcPool {
-    fn add_pus_tc(&mut self, pus_tc: &PusTcReader) -> Result<PoolAddr, PoolError>;
+    fn add_pus_tc(&mut self, pus_tc: &PusTcReader) -> Result<StoreAddr, StoreError>;
 }
 
 /// Helper trait for any generic (static) store which allows storing ECSS PUS Telemetry packets.
 pub trait PusTmPool {
-    fn add_pus_tm_from_reader(&mut self, pus_tm: &PusTmReader) -> Result<PoolAddr, PoolError>;
-    fn add_pus_tm_from_creator(&mut self, pus_tm: &PusTmCreator) -> Result<PoolAddr, PoolError>;
+    fn add_pus_tm_from_reader(&mut self, pus_tm: &PusTmReader) -> Result<StoreAddr, StoreError>;
+    fn add_pus_tm_from_creator(&mut self, pus_tm: &PusTmCreator) -> Result<StoreAddr, StoreError>;
+}
+
+impl PusTcPool for SharedPacketPool {
+    fn add_pus_tc(&mut self, pus_tc: &PusTcReader) -> Result<StoreAddr, StoreError> {
+        let mut pg = self.0.write().map_err(|_| StoreError::LockError)?;
+        let addr = pg.free_element(pus_tc.len_packed(), |buf| {
+            buf[0..pus_tc.len_packed()].copy_from_slice(pus_tc.raw_data());
+        })?;
+        Ok(addr)
+    }
+}
+
+impl PusTmPool for SharedPacketPool {
+    fn add_pus_tm_from_reader(&mut self, pus_tm: &PusTmReader) -> Result<StoreAddr, StoreError> {
+        let mut pg = self.0.write().map_err(|_| StoreError::LockError)?;
+        let addr = pg.free_element(pus_tm.len_packed(), |buf| {
+            buf[0..pus_tm.len_packed()].copy_from_slice(pus_tm.raw_data());
+        })?;
+        Ok(addr)
+    }
+
+    fn add_pus_tm_from_creator(&mut self, pus_tm: &PusTmCreator) -> Result<StoreAddr, StoreError> {
+        let mut pg = self.0.write().map_err(|_| StoreError::LockError)?;
+        let mut result = Ok(0);
+        let addr = pg.free_element(pus_tm.len_written(), |buf| {
+            result = pus_tm.write_to_bytes(buf);
+        })?;
+        result?;
+        Ok(addr)
+    }
+}
+
+impl CcsdsPacketPool for SharedPacketPool {
+    fn add_raw_tc(&mut self, tc_raw: &[u8]) -> Result<StoreAddr, StoreError> {
+        let mut pg = self.0.write().map_err(|_| StoreError::LockError)?;
+        let addr = pg.free_element(tc_raw.len(), |buf| {
+            buf[0..tc_raw.len()].copy_from_slice(tc_raw);
+        })?;
+        Ok(addr)
+    }
 }
 
 /// Generic trait for any sender component able to send packets stored inside a pool structure.
@@ -194,126 +253,25 @@ pub trait PacketInPoolSender: Send {
     fn send_packet(
         &self,
         sender_id: ComponentId,
-        store_addr: PoolAddr,
+        store_addr: StoreAddr,
     ) -> Result<(), GenericSendError>;
 }
 
-#[cfg(feature = "alloc")]
-pub mod alloc_mod {
-    use alloc::vec::Vec;
-
-    use super::*;
-
-    /// Simple type modelling packet stored in the heap. This structure is intended to
-    /// be used when sending a packet via a message queue, so it also contains the sender ID.
-    #[derive(Debug, PartialEq, Eq, Clone)]
-    pub struct PacketAsVec {
-        pub sender_id: ComponentId,
-        pub packet: Vec<u8>,
-    }
-
-    impl PacketAsVec {
-        pub fn new(sender_id: ComponentId, packet: Vec<u8>) -> Self {
-            Self { sender_id, packet }
-        }
-    }
-}
 #[cfg(feature = "std")]
 pub mod std_mod {
 
-    use core::cell::RefCell;
-
     #[cfg(feature = "crossbeam")]
     use crossbeam_channel as cb;
-    use spacepackets::ecss::WritablePusPacket;
     use thiserror::Error;
 
-    use crate::pool::PoolProvider;
-    use crate::pus::{EcssTmSender, EcssTmtcError, PacketSenderPusTc};
+    use crate::pus::{EcssTmSender, EcssTmtcError, PacketInPool, PacketSenderPusTc};
 
     use super::*;
 
-    /// Newtype wrapper around the [SharedStaticMemoryPool] to enable extension helper traits on
-    /// top of the regular shared memory pool API.
-    #[derive(Clone)]
-    pub struct SharedPacketPool(pub SharedStaticMemoryPool);
-
-    impl SharedPacketPool {
-        pub fn new(pool: &SharedStaticMemoryPool) -> Self {
-            Self(pool.clone())
-        }
-    }
-
-    impl PusTcPool for SharedPacketPool {
-        fn add_pus_tc(&mut self, pus_tc: &PusTcReader) -> Result<PoolAddr, PoolError> {
-            let mut pg = self.0.write().map_err(|_| PoolError::LockError)?;
-            let addr = pg.free_element(pus_tc.len_packed(), |buf| {
-                buf[0..pus_tc.len_packed()].copy_from_slice(pus_tc.raw_data());
-            })?;
-            Ok(addr)
-        }
-    }
-
-    impl PusTmPool for SharedPacketPool {
-        fn add_pus_tm_from_reader(&mut self, pus_tm: &PusTmReader) -> Result<PoolAddr, PoolError> {
-            let mut pg = self.0.write().map_err(|_| PoolError::LockError)?;
-            let addr = pg.free_element(pus_tm.len_packed(), |buf| {
-                buf[0..pus_tm.len_packed()].copy_from_slice(pus_tm.raw_data());
-            })?;
-            Ok(addr)
-        }
-
-        fn add_pus_tm_from_creator(
-            &mut self,
-            pus_tm: &PusTmCreator,
-        ) -> Result<PoolAddr, PoolError> {
-            let mut pg = self.0.write().map_err(|_| PoolError::LockError)?;
-            let mut result = Ok(0);
-            let addr = pg.free_element(pus_tm.len_written(), |buf| {
-                result = pus_tm.write_to_bytes(buf);
-            })?;
-            result?;
-            Ok(addr)
-        }
-    }
-
-    impl CcsdsPacketPool for SharedPacketPool {
-        fn add_raw_tc(&mut self, tc_raw: &[u8]) -> Result<PoolAddr, PoolError> {
-            let mut pg = self.0.write().map_err(|_| PoolError::LockError)?;
-            let addr = pg.free_element(tc_raw.len(), |buf| {
-                buf[0..tc_raw.len()].copy_from_slice(tc_raw);
-            })?;
-            Ok(addr)
-        }
-    }
-
-    #[cfg(feature = "std")]
-    impl PacketSenderRaw for mpsc::Sender<PacketAsVec> {
-        type Error = GenericSendError;
-
-        fn send_packet(&self, sender_id: ComponentId, packet: &[u8]) -> Result<(), Self::Error> {
-            self.send(PacketAsVec::new(sender_id, packet.to_vec()))
-                .map_err(|_| GenericSendError::RxDisconnected)
-        }
-    }
-
-    #[cfg(feature = "std")]
-    impl PacketSenderRaw for mpsc::SyncSender<PacketAsVec> {
-        type Error = GenericSendError;
-
-        fn send_packet(&self, sender_id: ComponentId, tc_raw: &[u8]) -> Result<(), Self::Error> {
-            self.try_send(PacketAsVec::new(sender_id, tc_raw.to_vec()))
-                .map_err(|e| match e {
-                    mpsc::TrySendError::Full(_) => GenericSendError::QueueFull(None),
-                    mpsc::TrySendError::Disconnected(_) => GenericSendError::RxDisconnected,
-                })
-        }
-    }
-
     #[derive(Debug, Clone, PartialEq, Eq, Error)]
     pub enum StoreAndSendError {
         #[error("Store error: {0}")]
-        Store(#[from] PoolError),
+        Store(#[from] StoreError),
         #[error("Genreric send error: {0}")]
         Send(#[from] GenericSendError),
     }
@@ -324,7 +282,7 @@ pub mod std_mod {
         fn send_packet(
             &self,
             sender_id: ComponentId,
-            store_addr: PoolAddr,
+            store_addr: StoreAddr,
         ) -> Result<(), GenericSendError> {
             self.send(PacketInPool::new(sender_id, store_addr))
                 .map_err(|_| GenericSendError::RxDisconnected)
@@ -335,7 +293,7 @@ pub mod std_mod {
         fn send_packet(
             &self,
             sender_id: ComponentId,
-            store_addr: PoolAddr,
+            store_addr: StoreAddr,
         ) -> Result<(), GenericSendError> {
             self.try_send(PacketInPool::new(sender_id, store_addr))
                 .map_err(|e| match e {
@@ -350,7 +308,7 @@ pub mod std_mod {
         fn send_packet(
             &self,
             sender_id: ComponentId,
-            store_addr: PoolAddr,
+            store_addr: StoreAddr,
         ) -> Result<(), GenericSendError> {
             self.try_send(PacketInPool::new(sender_id, store_addr))
                 .map_err(|e| match e {
@@ -463,7 +421,7 @@ pub mod std_mod {
             sender_id: crate::ComponentId,
             tm: crate::pus::PusTmVariant,
         ) -> Result<(), crate::pus::EcssTmtcError> {
-            let send_addr = |store_addr: PoolAddr| {
+            let send_addr = |store_addr: StoreAddr| {
                 self.sender
                     .send_packet(sender_id, store_addr)
                     .map_err(EcssTmtcError::Send)
@@ -640,7 +598,7 @@ pub(crate) mod tests {
         assert!(result.is_err());
         matches!(
             result.unwrap_err(),
-            StoreAndSendError::Store(PoolError::StoreFull(..))
+            StoreAndSendError::Store(StoreError::StoreFull(..))
         );
         let packet_in_pool = tc_rx.try_recv().unwrap();
         let mut pool = shared_pool.0.write().unwrap();

satrs/tests/pools.rs

@@ -1,4 +1,4 @@
-use satrs::pool::{PoolAddr, PoolGuard, PoolProvider, StaticMemoryPool, StaticPoolConfig};
+use satrs::pool::{PoolGuard, PoolProvider, StaticMemoryPool, StaticPoolConfig, StoreAddr};
 use std::ops::DerefMut;
 use std::sync::mpsc;
 use std::sync::mpsc::{Receiver, Sender};
@@ -12,7 +12,7 @@ fn threaded_usage() {
     let pool_cfg = StaticPoolConfig::new(vec![(16, 6), (32, 3), (8, 12)], false);
     let shared_pool = Arc::new(RwLock::new(StaticMemoryPool::new(pool_cfg)));
     let shared_clone = shared_pool.clone();
-    let (tx, rx): (Sender<PoolAddr>, Receiver<PoolAddr>) = mpsc::channel();
+    let (tx, rx): (Sender<StoreAddr>, Receiver<StoreAddr>) = mpsc::channel();
     let jh0 = thread::spawn(move || {
         let mut dummy = shared_pool.write().unwrap();
         let addr = dummy.add(&DUMMY_DATA).expect("Writing data failed");

satrs/tests/pus_autogen_events.rs

@@ -21,7 +21,7 @@ struct EventIntrospection {
 }
 
 //#[event(descr="This is some info event")]
-const INFO_EVENT_0: EventU32TypedSev<SeverityInfo> = EventU32TypedSev::new(0, 0);
+const INFO_EVENT_0: EventU32TypedSev<SeverityInfo> = EventU32TypedSev::const_new(0, 0);
 const INFO_EVENT_0_ERASED: EventU32 = EventU32::const_from_info(INFO_EVENT_0);
 
 // This is ideally auto-generated
@@ -36,7 +36,7 @@ const INFO_EVENT_0_INTROSPECTION: EventIntrospection = EventIntrospection {
 };
 
 //#[event(descr="This is some low severity event")]
-const SOME_LOW_SEV_EVENT: EventU32TypedSev<SeverityLow> = EventU32TypedSev::new(0, 12);
+const SOME_LOW_SEV_EVENT: EventU32TypedSev<SeverityLow> = EventU32TypedSev::const_new(0, 12);
 
 //const EVENT_LIST: [&'static Event; 2] = [&INFO_EVENT_0, &SOME_LOW_SEV_EVENT];
 
@@ -47,7 +47,7 @@ const TEST_GROUP_NAME_NAME: &str = "TEST_GROUP_NAME";
 
 //#[event(desc="Some medium severity event")]
 const MEDIUM_SEV_EVENT_IN_OTHER_GROUP: EventU32TypedSev<SeverityMedium> =
-    EventU32TypedSev::new(TEST_GROUP_NAME, 0);
+    EventU32TypedSev::const_new(TEST_GROUP_NAME, 0);
 const MEDIUM_SEV_EVENT_IN_OTHER_GROUP_REDUCED: EventU32 =
     EventU32::const_from_medium(MEDIUM_SEV_EVENT_IN_OTHER_GROUP);
 
@@ -62,7 +62,7 @@ const MEDIUM_SEV_EVENT_IN_OTHER_GROUP_INTROSPECTION: EventIntrospection = EventI
     info: "Some medium severity event",
 };
 
-const CONST_SLICE: &[u8] = &[0, 1, 2, 3];
+const CONST_SLICE: &'static [u8] = &[0, 1, 2, 3];
 const INTROSPECTION_FOR_TEST_GROUP_0: [&EventIntrospection; 2] =
     [&INFO_EVENT_0_INTROSPECTION, &INFO_EVENT_0_INTROSPECTION];
 

satrs/tests/pus_events.rs

@@ -1,21 +1,22 @@
 use satrs::event_man::{
     EventManagerWithMpsc, EventMessage, EventMessageU32, EventRoutingError, EventSendProvider,
-    EventU32SenderMpsc,
+    EventU32SenderMpsc, MpscEventU32Receiver,
 };
 use satrs::events::{EventU32, EventU32TypedSev, Severity, SeverityInfo};
 use satrs::params::U32Pair;
 use satrs::params::{Params, ParamsHeapless, WritableToBeBytes};
-use satrs::pus::event_man::{DefaultPusEventReportingMap, EventReporter, PusEventTmCreatorWithMap};
+use satrs::pus::event_man::{DefaultPusEventMgmtBackend, EventReporter, PusEventDispatcher};
 use satrs::pus::test_util::TEST_COMPONENT_ID_0;
+use satrs::pus::PacketAsVec;
 use satrs::request::UniqueApidTargetId;
-use satrs::tmtc::PacketAsVec;
 use spacepackets::ecss::tm::PusTmReader;
 use spacepackets::ecss::{PusError, PusPacket};
 use std::sync::mpsc::{self, SendError, TryRecvError};
 use std::thread;
 
-const INFO_EVENT: EventU32TypedSev<SeverityInfo> = EventU32TypedSev::<SeverityInfo>::new(1, 0);
-const LOW_SEV_EVENT: EventU32 = EventU32::new(Severity::Low, 1, 5);
+const INFO_EVENT: EventU32TypedSev<SeverityInfo> =
+    EventU32TypedSev::<SeverityInfo>::const_new(1, 0);
+const LOW_SEV_EVENT: EventU32 = EventU32::const_new(Severity::LOW, 1, 5);
 const EMPTY_STAMP: [u8; 7] = [0; 7];
 const TEST_APID: u16 = 0x02;
 const TEST_ID: UniqueApidTargetId = UniqueApidTargetId::new(TEST_APID, 0x05);
@@ -28,18 +29,18 @@ pub enum CustomTmSenderError {
 
 #[test]
 fn test_threaded_usage() {
-    let (event_tx, event_rx) = mpsc::sync_channel(100);
-    let mut event_man = EventManagerWithMpsc::new(event_rx);
+    let (event_sender, event_man_receiver) = mpsc::channel();
+    let event_receiver = MpscEventU32Receiver::new(event_man_receiver);
+    let mut event_man = EventManagerWithMpsc::new(event_receiver);
 
     let (pus_event_man_tx, pus_event_man_rx) = mpsc::channel();
     let pus_event_man_send_provider = EventU32SenderMpsc::new(1, pus_event_man_tx);
     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 (event_tx, event_rx) = mpsc::channel::<PacketAsVec>();
     let reporter =
         EventReporter::new(TEST_ID.raw(), 0x02, 0, 128).expect("Creating event reporter failed");
-    let pus_event_man =
-        PusEventTmCreatorWithMap::new(reporter, DefaultPusEventReportingMap::default());
+    let pus_event_man = PusEventDispatcher::new(reporter, DefaultPusEventMgmtBackend::default());
     let error_handler = |event_msg: &EventMessageU32, error: EventRoutingError| {
         panic!("received routing error for event {event_msg:?}: {error:?}");
     };
@@ -53,7 +54,7 @@ fn test_threaded_usage() {
                 Ok(event_msg) => {
                     let gen_event = |aux_data| {
                         pus_event_man.generate_pus_event_tm_generic(
-                            &event_packet_tx,
+                            &event_tx,
                             &EMPTY_STAMP,
                             event_msg.event(),
                             aux_data,
@@ -99,14 +100,14 @@ fn test_threaded_usage() {
 
     // Event sender and TM checker thread
     let jh1 = thread::spawn(move || {
-        event_tx
+        event_sender
             .send(EventMessage::new(
                 TEST_COMPONENT_ID_0.id(),
                 INFO_EVENT.into(),
             ))
             .expect("Sending info event failed");
         loop {
-            match event_packet_rx.try_recv() {
+            match event_rx.try_recv() {
                 // Event TM received successfully
                 Ok(event_tm) => {
                     let tm = PusTmReader::new(event_tm.packet.as_slice(), 7)
@@ -128,7 +129,7 @@ fn test_threaded_usage() {
                 }
             }
         }
-        event_tx
+        event_sender
             .send(EventMessage::new_with_params(
                 TEST_COMPONENT_ID_0.id(),
                 LOW_SEV_EVENT,
@@ -136,7 +137,7 @@ fn test_threaded_usage() {
             ))
             .expect("Sending low severity event failed");
         loop {
-            match event_packet_rx.try_recv() {
+            match event_rx.try_recv() {
                 // Event TM received successfully
                 Ok(event_tm) => {
                     let tm = PusTmReader::new(event_tm.packet.as_slice(), 7)

satrs/tests/tcp_servers.rs

@@ -23,10 +23,7 @@ use std::{
 
 use hashbrown::HashSet;
 use satrs::{
-    encoding::{
-        ccsds::{SpValidity, SpacePacketValidator},
-        cobs::encode_packet_with_cobs,
-    },
+    encoding::cobs::encode_packet_with_cobs,
     hal::std::tcp_server::{
         ConnectionResult, HandledConnectionHandler, HandledConnectionInfo, ServerConfig,
         TcpSpacepacketsServer, TcpTmtcInCobsServer,
@@ -36,7 +33,7 @@ use satrs::{
 };
 use spacepackets::{
     ecss::{tc::PusTcCreator, WritablePusPacket},
-    CcsdsPacket, PacketId, SpHeader,
+    PacketId, SpHeader,
 };
 use std::{collections::VecDeque, sync::Arc, vec::Vec};
 
@@ -133,7 +130,7 @@ fn test_cobs_server() {
 
     // Call the connection handler in separate thread, does block.
     thread::spawn(move || {
-        let result = tcp_server.handle_all_connections(Some(Duration::from_millis(400)));
+        let result = tcp_server.handle_next_connection(Some(Duration::from_millis(400)));
         if result.is_err() {
             panic!("handling connection failed: {:?}", result.unwrap_err());
         }
@@ -195,24 +192,6 @@ fn test_cobs_server() {
 const TEST_APID_0: u16 = 0x02;
 const TEST_PACKET_ID_0: PacketId = PacketId::new_for_tc(true, TEST_APID_0);
 
-#[derive(Default)]
-pub struct SimpleVerificator {
-    pub valid_ids: HashSet<PacketId>,
-}
-
-impl SpacePacketValidator for SimpleVerificator {
-    fn validate(
-        &self,
-        sp_header: &SpHeader,
-        _raw_buf: &[u8],
-    ) -> satrs::encoding::ccsds::SpValidity {
-        if self.valid_ids.contains(&sp_header.packet_id()) {
-            return SpValidity::Valid;
-        }
-        SpValidity::Skip
-    }
-}
-
 #[test]
 fn test_ccsds_server() {
     let (tc_sender, tc_receiver) = mpsc::channel();
@@ -221,8 +200,8 @@ fn test_ccsds_server() {
     let verif_tm = PusTcCreator::new_simple(sph, 1, 1, &[], true);
     let tm_0 = verif_tm.to_vec().expect("tm generation failed");
     tm_source.add_tm(&tm_0);
-    let mut packet_id_lookup = SimpleVerificator::default();
-    packet_id_lookup.valid_ids.insert(TEST_PACKET_ID_0);
+    let mut packet_id_lookup = HashSet::new();
+    packet_id_lookup.insert(TEST_PACKET_ID_0);
     let mut tcp_server = TcpSpacepacketsServer::new(
         ServerConfig::new(
             TCP_SERVER_ID,
@@ -245,7 +224,7 @@ fn test_ccsds_server() {
     let set_if_done = conn_handled.clone();
     // Call the connection handler in separate thread, does block.
     thread::spawn(move || {
-        let result = tcp_server.handle_all_connections(Some(Duration::from_millis(500)));
+        let result = tcp_server.handle_next_connection(Some(Duration::from_millis(500)));
         if result.is_err() {
             panic!("handling connection failed: {:?}", result.unwrap_err());
         }