refactored verification reporter

- Use generics instead of trait objects where applicable.

satrs-example/src/acs.rs

@@ -1,7 +1,7 @@
 use std::sync::mpsc::{self, TryRecvError};
 
 use log::{info, warn};
-use satrs::pus::verification::{VerificationReporterWithSender, VerificationReportingProvider};
+use satrs::pus::verification::VerificationReportingProvider;
 use satrs::pus::{EcssTmSender, PusTmWrapper};
 use satrs::request::TargetAndApidId;
 use satrs::spacepackets::ecss::hk::Subservice as HkSubservice;
@@ -21,19 +21,19 @@ use crate::{
     update_time,
 };
 
-pub struct AcsTask {
+pub struct AcsTask<VerificationReporter: VerificationReportingProvider> {
     timestamp: [u8; 7],
     time_provider: TimeProvider<DaysLen16Bits>,
-    verif_reporter: VerificationReporterWithSender,
+    verif_reporter: VerificationReporter,
     tm_sender: Box<dyn EcssTmSender>,
     request_rx: mpsc::Receiver<RequestWithToken>,
 }
 
-impl AcsTask {
+impl<VerificationReporter: VerificationReportingProvider> AcsTask<VerificationReporter> {
     pub fn new(
         tm_sender: impl EcssTmSender,
         request_rx: mpsc::Receiver<RequestWithToken>,
-        verif_reporter: VerificationReporterWithSender,
+        verif_reporter: VerificationReporter,
     ) -> Self {
         Self {
             timestamp: [0; 7],

satrs-example/src/events.rs

@@ -11,10 +11,7 @@ use satrs::{
         event_man::{
             DefaultPusEventU32Dispatcher, EventReporter, EventRequest, EventRequestWithToken,
         },
-        verification::{
-            TcStateStarted, VerificationReporterWithSender, VerificationReportingProvider,
-            VerificationToken,
-        },
+        verification::{TcStateStarted, VerificationReportingProvider, VerificationToken},
         EcssTmSender,
     },
     spacepackets::time::cds::{self, TimeProvider},
@@ -23,21 +20,21 @@ use satrs_example::config::PUS_APID;
 
 use crate::update_time;
 
-pub struct PusEventHandler {
+pub struct PusEventHandler<VerificationReporter: VerificationReportingProvider> {
     event_request_rx: mpsc::Receiver<EventRequestWithToken>,
     pus_event_dispatcher: DefaultPusEventU32Dispatcher<()>,
     pus_event_man_rx: mpsc::Receiver<(EventU32, Option<Params>)>,
     tm_sender: Box<dyn EcssTmSender>,
     time_provider: TimeProvider,
     timestamp: [u8; 7],
-    verif_handler: VerificationReporterWithSender,
+    verif_handler: VerificationReporter,
 }
 /*
 */
 
-impl PusEventHandler {
+impl<VerificationReporter: VerificationReportingProvider> PusEventHandler<VerificationReporter> {
     pub fn new(
-        verif_handler: VerificationReporterWithSender,
+        verif_handler: VerificationReporter,
         event_manager: &mut EventManagerWithBoundedMpsc,
         event_request_rx: mpsc::Receiver<EventRequestWithToken>,
         tm_sender: impl EcssTmSender,
@@ -147,15 +144,15 @@ impl EventManagerWrapper {
     }
 }
 
-pub struct EventHandler {
+pub struct EventHandler<VerificationReporter: VerificationReportingProvider> {
     pub event_man_wrapper: EventManagerWrapper,
-    pub pus_event_handler: PusEventHandler,
+    pub pus_event_handler: PusEventHandler<VerificationReporter>,
 }
 
-impl EventHandler {
+impl<VerificationReporter: VerificationReportingProvider> EventHandler<VerificationReporter> {
     pub fn new(
         tm_sender: impl EcssTmSender,
-        verif_handler: VerificationReporterWithSender,
+        verif_handler: VerificationReporter,
         event_request_rx: mpsc::Receiver<EventRequestWithToken>,
     ) -> Self {
         let mut event_man_wrapper = EventManagerWrapper::new();

satrs-example/src/main.rs

@@ -44,7 +44,7 @@ use crate::tmtc::{
 use crate::udp::{StaticUdpTmHandler, UdpTmtcServer};
 use satrs::pus::event_man::EventRequestWithToken;
 use satrs::pus::verification::{VerificationReporterCfg, VerificationReporterWithSender};
-use satrs::pus::{EcssTmSender, MpscTmAsVecSender, MpscTmInSharedPoolSender};
+use satrs::pus::{EcssTmSender, TmAsVecSenderWithId, TmInSharedPoolSenderWithId};
 use satrs::spacepackets::{time::cds::TimeProvider, time::TimeWriter};
 use satrs::tmtc::CcsdsDistributor;
 use satrs::ChannelId;
@@ -54,11 +54,13 @@ use std::sync::{Arc, RwLock};
 use std::thread;
 use std::time::Duration;
 
-fn create_verification_reporter(verif_sender: impl EcssTmSender) -> VerificationReporterWithSender {
+fn create_verification_reporter<Sender: EcssTmSender + Clone>(
+    verif_sender: Sender,
+) -> VerificationReporterWithSender<Sender> {
     let verif_cfg = VerificationReporterCfg::new(PUS_APID, 1, 2, 8).unwrap();
     // Every software component which needs to generate verification telemetry, gets a cloned
     // verification reporter.
-    VerificationReporterWithSender::new(&verif_cfg, Box::new(verif_sender))
+    VerificationReporterWithSender::new(&verif_cfg, verif_sender)
 }
 
 #[allow(dead_code)]
@@ -68,13 +70,13 @@ fn static_tmtc_pool_main() {
     let shared_tc_pool = SharedTcPool {
         pool: Arc::new(RwLock::new(tc_pool)),
     };
-    let (tc_source_tx, tc_source_rx) = channel();
-    let (tm_funnel_tx, tm_funnel_rx) = channel();
-    let (tm_server_tx, tm_server_rx) = channel();
+    let (tc_source_tx, tc_source_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);
 
     // Every software component which needs to generate verification telemetry, receives a cloned
     // verification reporter.
-    let verif_reporter = create_verification_reporter(MpscTmInSharedPoolSender::new(
+    let verif_reporter = create_verification_reporter(TmInSharedPoolSenderWithId::new(
         TmSenderId::PusVerification as ChannelId,
         "verif_sender",
         shared_tm_pool.clone(),
@@ -102,7 +104,7 @@ fn static_tmtc_pool_main() {
     // 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(
-        MpscTmInSharedPoolSender::new(
+        TmInSharedPoolSenderWithId::new(
             TmSenderId::AllEvents as ChannelId,
             "ALL_EVENTS_TX",
             shared_tm_pool.clone(),
@@ -202,7 +204,7 @@ fn static_tmtc_pool_main() {
     .expect("tcp server creation failed");
 
     let mut acs_task = AcsTask::new(
-        MpscTmInSharedPoolSender::new(
+        TmInSharedPoolSenderWithId::new(
             TmSenderId::AcsSubsystem as ChannelId,
             "ACS_TASK_SENDER",
             shared_tm_pool.clone(),
@@ -303,7 +305,7 @@ fn dyn_tmtc_pool_main() {
     let (tm_server_tx, tm_server_rx) = channel();
     // Every software component which needs to generate verification telemetry, gets a cloned
     // verification reporter.
-    let verif_reporter = create_verification_reporter(MpscTmAsVecSender::new(
+    let verif_reporter = create_verification_reporter(TmAsVecSenderWithId::new(
         TmSenderId::PusVerification as ChannelId,
         "verif_sender",
         tm_funnel_tx.clone(),
@@ -324,7 +326,7 @@ fn dyn_tmtc_pool_main() {
     // 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(
-        MpscTmAsVecSender::new(
+        TmAsVecSenderWithId::new(
             TmSenderId::AllEvents as ChannelId,
             "ALL_EVENTS_TX",
             tm_funnel_tx.clone(),
@@ -415,7 +417,7 @@ fn dyn_tmtc_pool_main() {
     .expect("tcp server creation failed");
 
     let mut acs_task = AcsTask::new(
-        MpscTmAsVecSender::new(
+        TmAsVecSenderWithId::new(
             TmSenderId::AcsSubsystem as ChannelId,
             "ACS_TASK_SENDER",
             tm_funnel_tx.clone(),

satrs-example/src/pus/action.rs

@@ -2,14 +2,16 @@ use log::{error, warn};
 use satrs::action::ActionRequest;
 use satrs::pool::{SharedStaticMemoryPool, StoreAddr};
 use satrs::pus::action::{PusActionToRequestConverter, PusService8ActionHandler};
+use satrs::pus::verification::std_mod::{
+    VerificationReporterWithSharedPoolMpscBoundedSender, VerificationReporterWithVecMpscSender,
+};
 use satrs::pus::verification::{
-    FailParams, TcStateAccepted, VerificationReporterWithSender, VerificationReportingProvider,
-    VerificationToken,
+    FailParams, TcStateAccepted, VerificationReportingProvider, VerificationToken,
 };
 use satrs::pus::{
     EcssTcAndToken, EcssTcInMemConverter, EcssTcInSharedStoreConverter, EcssTcInVecConverter,
-    MpscTcReceiver, MpscTmAsVecSender, MpscTmInSharedPoolSender, PusPacketHandlerResult,
-    PusPacketHandlingError, PusServiceHelper,
+    MpscTcReceiver, PusPacketHandlerResult, PusPacketHandlingError, PusServiceHelper,
+    TmAsVecSenderWithId, TmInSharedPoolSenderWithId,
 };
 use satrs::request::TargetAndApidId;
 use satrs::spacepackets::ecss::tc::PusTcReader;
@@ -74,13 +76,14 @@ impl PusActionToRequestConverter for ExampleActionRequestConverter {
 
 pub fn create_action_service_static(
     shared_tm_store: SharedTmPool,
-    tm_funnel_tx: mpsc::Sender<StoreAddr>,
-    verif_reporter: VerificationReporterWithSender,
+    tm_funnel_tx: mpsc::SyncSender<StoreAddr>,
+    verif_reporter: VerificationReporterWithSharedPoolMpscBoundedSender,
     tc_pool: SharedStaticMemoryPool,
     pus_action_rx: mpsc::Receiver<EcssTcAndToken>,
     action_router: GenericRequestRouter,
-) -> Pus8Wrapper<EcssTcInSharedStoreConverter> {
-    let action_srv_tm_sender = MpscTmInSharedPoolSender::new(
+) -> Pus8Wrapper<EcssTcInSharedStoreConverter, VerificationReporterWithSharedPoolMpscBoundedSender>
+{
+    let action_srv_tm_sender = TmInSharedPoolSenderWithId::new(
         TmSenderId::PusAction as ChannelId,
         "PUS_8_TM_SENDER",
         shared_tm_store.clone(),
@@ -108,11 +111,11 @@ pub fn create_action_service_static(
 
 pub fn create_action_service_dynamic(
     tm_funnel_tx: mpsc::Sender<Vec<u8>>,
-    verif_reporter: VerificationReporterWithSender,
+    verif_reporter: VerificationReporterWithVecMpscSender,
     pus_action_rx: mpsc::Receiver<EcssTcAndToken>,
     action_router: GenericRequestRouter,
-) -> Pus8Wrapper<EcssTcInVecConverter> {
-    let action_srv_tm_sender = MpscTmAsVecSender::new(
+) -> Pus8Wrapper<EcssTcInVecConverter, VerificationReporterWithVecMpscSender> {
+    let action_srv_tm_sender = TmAsVecSenderWithId::new(
         TmSenderId::PusAction as ChannelId,
         "PUS_8_TM_SENDER",
         tm_funnel_tx.clone(),
@@ -137,17 +140,24 @@ pub fn create_action_service_dynamic(
     Pus8Wrapper { pus_8_handler }
 }
 
-pub struct Pus8Wrapper<TcInMemConverter: EcssTcInMemConverter> {
+pub struct Pus8Wrapper<
+    TcInMemConverter: EcssTcInMemConverter,
+    VerificationReporter: VerificationReportingProvider,
+> {
     pub(crate) pus_8_handler: PusService8ActionHandler<
         TcInMemConverter,
-        VerificationReporterWithSender,
+        VerificationReporter,
         ExampleActionRequestConverter,
         GenericRequestRouter,
         GenericRoutingErrorHandler<8>,
     >,
 }
 
-impl<TcInMemConverter: EcssTcInMemConverter> Pus8Wrapper<TcInMemConverter> {
+impl<
+        TcInMemConverter: EcssTcInMemConverter,
+        VerificationReporter: VerificationReportingProvider,
+    > Pus8Wrapper<TcInMemConverter, VerificationReporter>
+{
     pub fn handle_next_packet(&mut self) -> bool {
         match self.pus_8_handler.handle_one_tc() {
             Ok(result) => match result {

satrs-example/src/pus/event.rs

@@ -4,11 +4,14 @@ use log::{error, warn};
 use satrs::pool::{SharedStaticMemoryPool, StoreAddr};
 use satrs::pus::event_man::EventRequestWithToken;
 use satrs::pus::event_srv::PusService5EventHandler;
-use satrs::pus::verification::VerificationReporterWithSender;
+use satrs::pus::verification::std_mod::{
+    VerificationReporterWithSharedPoolMpscBoundedSender, VerificationReporterWithVecMpscSender,
+};
+use satrs::pus::verification::VerificationReportingProvider;
 use satrs::pus::{
     EcssTcAndToken, EcssTcInMemConverter, EcssTcInSharedStoreConverter, EcssTcInVecConverter,
-    MpscTcReceiver, MpscTmAsVecSender, MpscTmInSharedPoolSender, PusPacketHandlerResult,
-    PusServiceHelper,
+    MpscTcReceiver, PusPacketHandlerResult, PusServiceHelper, TmAsVecSenderWithId,
+    TmInSharedPoolSenderWithId,
 };
 use satrs::tmtc::tm_helper::SharedTmPool;
 use satrs::ChannelId;
@@ -16,13 +19,14 @@ use satrs_example::config::{TcReceiverId, TmSenderId, PUS_APID};
 
 pub fn create_event_service_static(
     shared_tm_store: SharedTmPool,
-    tm_funnel_tx: mpsc::Sender<StoreAddr>,
-    verif_reporter: VerificationReporterWithSender,
+    tm_funnel_tx: mpsc::SyncSender<StoreAddr>,
+    verif_reporter: VerificationReporterWithSharedPoolMpscBoundedSender,
     tc_pool: SharedStaticMemoryPool,
     pus_event_rx: mpsc::Receiver<EcssTcAndToken>,
     event_request_tx: mpsc::Sender<EventRequestWithToken>,
-) -> Pus5Wrapper<EcssTcInSharedStoreConverter> {
-    let event_srv_tm_sender = MpscTmInSharedPoolSender::new(
+) -> Pus5Wrapper<EcssTcInSharedStoreConverter, VerificationReporterWithSharedPoolMpscBoundedSender>
+{
+    let event_srv_tm_sender = TmInSharedPoolSenderWithId::new(
         TmSenderId::PusEvent as ChannelId,
         "PUS_5_TM_SENDER",
         shared_tm_store.clone(),
@@ -48,11 +52,11 @@ pub fn create_event_service_static(
 
 pub fn create_event_service_dynamic(
     tm_funnel_tx: mpsc::Sender<Vec<u8>>,
-    verif_reporter: VerificationReporterWithSender,
+    verif_reporter: VerificationReporterWithVecMpscSender,
     pus_event_rx: mpsc::Receiver<EcssTcAndToken>,
     event_request_tx: mpsc::Sender<EventRequestWithToken>,
-) -> Pus5Wrapper<EcssTcInVecConverter> {
-    let event_srv_tm_sender = MpscTmAsVecSender::new(
+) -> Pus5Wrapper<EcssTcInVecConverter, VerificationReporterWithVecMpscSender> {
+    let event_srv_tm_sender = TmAsVecSenderWithId::new(
         TmSenderId::PusEvent as ChannelId,
         "PUS_5_TM_SENDER",
         tm_funnel_tx,
@@ -75,11 +79,18 @@ pub fn create_event_service_dynamic(
     Pus5Wrapper { pus_5_handler }
 }
 
-pub struct Pus5Wrapper<TcInMemConverter: EcssTcInMemConverter> {
-    pub pus_5_handler: PusService5EventHandler<TcInMemConverter, VerificationReporterWithSender>,
+pub struct Pus5Wrapper<
+    TcInMemConverter: EcssTcInMemConverter,
+    VerificationReporter: VerificationReportingProvider,
+> {
+    pub pus_5_handler: PusService5EventHandler<TcInMemConverter, VerificationReporter>,
 }
 
-impl<TcInMemConverter: EcssTcInMemConverter> Pus5Wrapper<TcInMemConverter> {
+impl<
+        TcInMemConverter: EcssTcInMemConverter,
+        VerificationReporter: VerificationReportingProvider,
+    > Pus5Wrapper<TcInMemConverter, VerificationReporter>
+{
     pub fn handle_next_packet(&mut self) -> bool {
         match self.pus_5_handler.handle_one_tc() {
             Ok(result) => match result {

satrs-example/src/pus/hk.rs

@@ -2,14 +2,16 @@ use log::{error, warn};
 use satrs::hk::{CollectionIntervalFactor, HkRequest};
 use satrs::pool::{SharedStaticMemoryPool, StoreAddr};
 use satrs::pus::hk::{PusHkToRequestConverter, PusService3HkHandler};
+use satrs::pus::verification::std_mod::{
+    VerificationReporterWithSharedPoolMpscBoundedSender, VerificationReporterWithVecMpscSender,
+};
 use satrs::pus::verification::{
-    FailParams, TcStateAccepted, VerificationReporterWithSender, VerificationReportingProvider,
-    VerificationToken,
+    FailParams, TcStateAccepted, VerificationReportingProvider, VerificationToken,
 };
 use satrs::pus::{
     EcssTcAndToken, EcssTcInMemConverter, EcssTcInSharedStoreConverter, EcssTcInVecConverter,
-    MpscTcReceiver, MpscTmAsVecSender, MpscTmInSharedPoolSender, PusPacketHandlerResult,
-    PusPacketHandlingError, PusServiceHelper,
+    MpscTcReceiver, PusPacketHandlerResult, PusPacketHandlingError, PusServiceHelper,
+    TmAsVecSenderWithId, TmInSharedPoolSenderWithId,
 };
 use satrs::request::TargetAndApidId;
 use satrs::spacepackets::ecss::tc::PusTcReader;
@@ -143,13 +145,14 @@ impl PusHkToRequestConverter for ExampleHkRequestConverter {
 
 pub fn create_hk_service_static(
     shared_tm_store: SharedTmPool,
-    tm_funnel_tx: mpsc::Sender<StoreAddr>,
-    verif_reporter: VerificationReporterWithSender,
+    tm_funnel_tx: mpsc::SyncSender<StoreAddr>,
+    verif_reporter: VerificationReporterWithSharedPoolMpscBoundedSender,
     tc_pool: SharedStaticMemoryPool,
     pus_hk_rx: mpsc::Receiver<EcssTcAndToken>,
     request_router: GenericRequestRouter,
-) -> Pus3Wrapper<EcssTcInSharedStoreConverter> {
-    let hk_srv_tm_sender = MpscTmInSharedPoolSender::new(
+) -> Pus3Wrapper<EcssTcInSharedStoreConverter, VerificationReporterWithSharedPoolMpscBoundedSender>
+{
+    let hk_srv_tm_sender = TmInSharedPoolSenderWithId::new(
         TmSenderId::PusHk as ChannelId,
         "PUS_3_TM_SENDER",
         shared_tm_store.clone(),
@@ -174,11 +177,11 @@ pub fn create_hk_service_static(
 
 pub fn create_hk_service_dynamic(
     tm_funnel_tx: mpsc::Sender<Vec<u8>>,
-    verif_reporter: VerificationReporterWithSender,
+    verif_reporter: VerificationReporterWithVecMpscSender,
     pus_hk_rx: mpsc::Receiver<EcssTcAndToken>,
     request_router: GenericRequestRouter,
-) -> Pus3Wrapper<EcssTcInVecConverter> {
-    let hk_srv_tm_sender = MpscTmAsVecSender::new(
+) -> Pus3Wrapper<EcssTcInVecConverter, VerificationReporterWithVecMpscSender> {
+    let hk_srv_tm_sender = TmAsVecSenderWithId::new(
         TmSenderId::PusHk as ChannelId,
         "PUS_3_TM_SENDER",
         tm_funnel_tx.clone(),
@@ -200,17 +203,24 @@ pub fn create_hk_service_dynamic(
     Pus3Wrapper { pus_3_handler }
 }
 
-pub struct Pus3Wrapper<TcInMemConverter: EcssTcInMemConverter> {
+pub struct Pus3Wrapper<
+    TcInMemConverter: EcssTcInMemConverter,
+    VerificationReporter: VerificationReportingProvider,
+> {
     pub(crate) pus_3_handler: PusService3HkHandler<
         TcInMemConverter,
-        VerificationReporterWithSender,
+        VerificationReporter,
         ExampleHkRequestConverter,
         GenericRequestRouter,
         GenericRoutingErrorHandler<3>,
     >,
 }
 
-impl<TcInMemConverter: EcssTcInMemConverter> Pus3Wrapper<TcInMemConverter> {
+impl<
+        TcInMemConverter: EcssTcInMemConverter,
+        VerificationReporter: VerificationReportingProvider,
+    > Pus3Wrapper<TcInMemConverter, VerificationReporter>
+{
     pub fn handle_next_packet(&mut self) -> bool {
         match self.pus_3_handler.handle_one_tc() {
             Ok(result) => match result {

satrs-example/src/pus/mod.rs

@@ -1,8 +1,6 @@
 use crate::tmtc::MpscStoreAndSendError;
 use log::warn;
-use satrs::pus::verification::{
-    FailParams, StdVerifReporterWithSender, VerificationReportingProvider,
-};
+use satrs::pus::verification::{FailParams, VerificationReportingProvider};
 use satrs::pus::{
     EcssTcAndToken, GenericRoutingError, PusPacketHandlerResult, PusRoutingErrorHandler, TcInMemory,
 };
@@ -28,8 +26,8 @@ pub struct PusTcMpscRouter {
     pub action_service_receiver: Sender<EcssTcAndToken>,
 }
 
-pub struct PusReceiver {
-    pub verif_reporter: StdVerifReporterWithSender,
+pub struct PusReceiver<VerificationReporter: VerificationReportingProvider> {
+    pub verif_reporter: VerificationReporter,
     pub pus_router: PusTcMpscRouter,
     stamp_helper: TimeStampHelper,
 }
@@ -61,8 +59,8 @@ impl TimeStampHelper {
     }
 }
 
-impl PusReceiver {
-    pub fn new(verif_reporter: StdVerifReporterWithSender, pus_router: PusTcMpscRouter) -> Self {
+impl<VerificationReporter: VerificationReportingProvider> PusReceiver<VerificationReporter> {
+    pub fn new(verif_reporter: VerificationReporter, pus_router: PusTcMpscRouter) -> Self {
         Self {
             verif_reporter,
             pus_router,
@@ -71,7 +69,7 @@ impl PusReceiver {
     }
 }
 
-impl PusReceiver {
+impl<VerificationReporter: VerificationReportingProvider> PusReceiver<VerificationReporter> {
     pub fn handle_tc_packet(
         &mut self,
         tc_in_memory: TcInMemory,

satrs-example/src/pus/scheduler.rs

@@ -5,11 +5,14 @@ use log::{error, info, warn};
 use satrs::pool::{PoolProvider, StaticMemoryPool, StoreAddr};
 use satrs::pus::scheduler::{PusScheduler, TcInfo};
 use satrs::pus::scheduler_srv::PusService11SchedHandler;
-use satrs::pus::verification::VerificationReporterWithSender;
+use satrs::pus::verification::std_mod::{
+    VerificationReporterWithSharedPoolMpscBoundedSender, VerificationReporterWithVecMpscSender,
+};
+use satrs::pus::verification::VerificationReportingProvider;
 use satrs::pus::{
     EcssTcAndToken, EcssTcInMemConverter, EcssTcInSharedStoreConverter, EcssTcInVecConverter,
-    MpscTcReceiver, MpscTmAsVecSender, MpscTmInSharedPoolSender, PusPacketHandlerResult,
-    PusServiceHelper,
+    MpscTcReceiver, PusPacketHandlerResult, PusServiceHelper, TmAsVecSenderWithId,
+    TmInSharedPoolSenderWithId,
 };
 use satrs::tmtc::tm_helper::SharedTmPool;
 use satrs::ChannelId;
@@ -51,15 +54,22 @@ impl TcReleaser for mpsc::Sender<Vec<u8>> {
     }
 }
 
-pub struct Pus11Wrapper<TcInMemConverter: EcssTcInMemConverter> {
+pub struct Pus11Wrapper<
+    TcInMemConverter: EcssTcInMemConverter,
+    VerificationReporter: VerificationReportingProvider,
+> {
     pub pus_11_handler:
-        PusService11SchedHandler<TcInMemConverter, VerificationReporterWithSender, PusScheduler>,
+        PusService11SchedHandler<TcInMemConverter, VerificationReporter, PusScheduler>,
     pub sched_tc_pool: StaticMemoryPool,
     pub releaser_buf: [u8; 4096],
     pub tc_releaser: Box<dyn TcReleaser + Send>,
 }
 
-impl<TcInMemConverter: EcssTcInMemConverter> Pus11Wrapper<TcInMemConverter> {
+impl<
+        TcInMemConverter: EcssTcInMemConverter,
+        VerificationReporter: VerificationReportingProvider,
+    > Pus11Wrapper<TcInMemConverter, VerificationReporter>
+{
     pub fn release_tcs(&mut self) {
         let releaser = |enabled: bool, info: &TcInfo, tc: &[u8]| -> bool {
             self.tc_releaser.release(enabled, info, tc)
@@ -110,13 +120,14 @@ impl<TcInMemConverter: EcssTcInMemConverter> Pus11Wrapper<TcInMemConverter> {
 
 pub fn create_scheduler_service_static(
     shared_tm_store: SharedTmPool,
-    tm_funnel_tx: mpsc::Sender<StoreAddr>,
-    verif_reporter: VerificationReporterWithSender,
+    tm_funnel_tx: mpsc::SyncSender<StoreAddr>,
+    verif_reporter: VerificationReporterWithSharedPoolMpscBoundedSender,
     tc_releaser: PusTcSourceProviderSharedPool,
     pus_sched_rx: mpsc::Receiver<EcssTcAndToken>,
     sched_tc_pool: StaticMemoryPool,
-) -> Pus11Wrapper<EcssTcInSharedStoreConverter> {
-    let sched_srv_tm_sender = MpscTmInSharedPoolSender::new(
+) -> Pus11Wrapper<EcssTcInSharedStoreConverter, VerificationReporterWithSharedPoolMpscBoundedSender>
+{
+    let sched_srv_tm_sender = TmInSharedPoolSenderWithId::new(
         TmSenderId::PusSched as ChannelId,
         "PUS_11_TM_SENDER",
         shared_tm_store.clone(),
@@ -149,12 +160,12 @@ pub fn create_scheduler_service_static(
 
 pub fn create_scheduler_service_dynamic(
     tm_funnel_tx: mpsc::Sender<Vec<u8>>,
-    verif_reporter: VerificationReporterWithSender,
+    verif_reporter: VerificationReporterWithVecMpscSender,
     tc_source_sender: mpsc::Sender<Vec<u8>>,
     pus_sched_rx: mpsc::Receiver<EcssTcAndToken>,
     sched_tc_pool: StaticMemoryPool,
-) -> Pus11Wrapper<EcssTcInVecConverter> {
-    let sched_srv_tm_sender = MpscTmAsVecSender::new(
+) -> Pus11Wrapper<EcssTcInVecConverter, VerificationReporterWithVecMpscSender> {
+    let sched_srv_tm_sender = TmAsVecSenderWithId::new(
         TmSenderId::PusSched as ChannelId,
         "PUS_11_TM_SENDER",
         tm_funnel_tx,

satrs-example/src/pus/stack.rs

@@ -1,25 +1,32 @@
-use satrs::pus::EcssTcInMemConverter;
+use satrs::pus::{verification::VerificationReportingProvider, EcssTcInMemConverter};
 
 use super::{
     action::Pus8Wrapper, event::Pus5Wrapper, hk::Pus3Wrapper, scheduler::Pus11Wrapper,
     test::Service17CustomWrapper,
 };
 
-pub struct PusStack<TcInMemConverter: EcssTcInMemConverter> {
-    event_srv: Pus5Wrapper<TcInMemConverter>,
-    hk_srv: Pus3Wrapper<TcInMemConverter>,
-    action_srv: Pus8Wrapper<TcInMemConverter>,
-    schedule_srv: Pus11Wrapper<TcInMemConverter>,
-    test_srv: Service17CustomWrapper<TcInMemConverter>,
+pub struct PusStack<
+    TcInMemConverter: EcssTcInMemConverter,
+    VerificationReporter: VerificationReportingProvider,
+> {
+    event_srv: Pus5Wrapper<TcInMemConverter, VerificationReporter>,
+    hk_srv: Pus3Wrapper<TcInMemConverter, VerificationReporter>,
+    action_srv: Pus8Wrapper<TcInMemConverter, VerificationReporter>,
+    schedule_srv: Pus11Wrapper<TcInMemConverter, VerificationReporter>,
+    test_srv: Service17CustomWrapper<TcInMemConverter, VerificationReporter>,
 }
 
-impl<TcInMemConverter: EcssTcInMemConverter> PusStack<TcInMemConverter> {
+impl<
+        TcInMemConverter: EcssTcInMemConverter,
+        VerificationReporter: VerificationReportingProvider,
+    > PusStack<TcInMemConverter, VerificationReporter>
+{
     pub fn new(
-        hk_srv: Pus3Wrapper<TcInMemConverter>,
-        event_srv: Pus5Wrapper<TcInMemConverter>,
-        action_srv: Pus8Wrapper<TcInMemConverter>,
-        schedule_srv: Pus11Wrapper<TcInMemConverter>,
-        test_srv: Service17CustomWrapper<TcInMemConverter>,
+        hk_srv: Pus3Wrapper<TcInMemConverter, VerificationReporter>,
+        event_srv: Pus5Wrapper<TcInMemConverter, VerificationReporter>,
+        action_srv: Pus8Wrapper<TcInMemConverter, VerificationReporter>,
+        schedule_srv: Pus11Wrapper<TcInMemConverter, VerificationReporter>,
+        test_srv: Service17CustomWrapper<TcInMemConverter, VerificationReporter>,
     ) -> Self {
         Self {
             event_srv,

satrs-example/src/pus/test.rs

@@ -2,12 +2,13 @@ use log::{info, warn};
 use satrs::params::Params;
 use satrs::pool::{SharedStaticMemoryPool, StoreAddr};
 use satrs::pus::test::PusService17TestHandler;
+use satrs::pus::verification::{FailParams, VerificationReportingProvider};
 use satrs::pus::verification::{
-    FailParams, VerificationReporterWithSender, VerificationReportingProvider,
+    VerificationReporterWithSharedPoolMpscBoundedSender, VerificationReporterWithVecMpscSender,
 };
 use satrs::pus::{
-    EcssTcAndToken, EcssTcInMemConverter, EcssTcInVecConverter, MpscTcReceiver, MpscTmAsVecSender,
-    MpscTmInSharedPoolSender, PusPacketHandlerResult, PusServiceHelper,
+    EcssTcAndToken, EcssTcInMemConverter, EcssTcInVecConverter, MpscTcReceiver,
+    PusPacketHandlerResult, PusServiceHelper, TmAsVecSenderWithId, TmInSharedPoolSenderWithId,
 };
 use satrs::spacepackets::ecss::tc::PusTcReader;
 use satrs::spacepackets::ecss::PusPacket;
@@ -21,13 +22,16 @@ use std::sync::mpsc::{self, Sender};
 
 pub fn create_test_service_static(
     shared_tm_store: SharedTmPool,
-    tm_funnel_tx: mpsc::Sender<StoreAddr>,
-    verif_reporter: VerificationReporterWithSender,
+    tm_funnel_tx: mpsc::SyncSender<StoreAddr>,
+    verif_reporter: VerificationReporterWithSharedPoolMpscBoundedSender,
     tc_pool: SharedStaticMemoryPool,
     event_sender: mpsc::Sender<(EventU32, Option<Params>)>,
     pus_test_rx: mpsc::Receiver<EcssTcAndToken>,
-) -> Service17CustomWrapper<EcssTcInSharedStoreConverter> {
-    let test_srv_tm_sender = MpscTmInSharedPoolSender::new(
+) -> Service17CustomWrapper<
+    EcssTcInSharedStoreConverter,
+    VerificationReporterWithSharedPoolMpscBoundedSender,
+> {
+    let test_srv_tm_sender = TmInSharedPoolSenderWithId::new(
         TmSenderId::PusTest as ChannelId,
         "PUS_17_TM_SENDER",
         shared_tm_store.clone(),
@@ -53,11 +57,11 @@ pub fn create_test_service_static(
 
 pub fn create_test_service_dynamic(
     tm_funnel_tx: mpsc::Sender<Vec<u8>>,
-    verif_reporter: VerificationReporterWithSender,
+    verif_reporter: VerificationReporterWithVecMpscSender,
     event_sender: mpsc::Sender<(EventU32, Option<Params>)>,
     pus_test_rx: mpsc::Receiver<EcssTcAndToken>,
-) -> Service17CustomWrapper<EcssTcInVecConverter> {
-    let test_srv_tm_sender = MpscTmAsVecSender::new(
+) -> Service17CustomWrapper<EcssTcInVecConverter, VerificationReporterWithVecMpscSender> {
+    let test_srv_tm_sender = TmAsVecSenderWithId::new(
         TmSenderId::PusTest as ChannelId,
         "PUS_17_TM_SENDER",
         tm_funnel_tx.clone(),
@@ -80,12 +84,19 @@ pub fn create_test_service_dynamic(
     }
 }
 
-pub struct Service17CustomWrapper<TcInMemConverter: EcssTcInMemConverter> {
-    pub pus17_handler: PusService17TestHandler<TcInMemConverter, VerificationReporterWithSender>,
+pub struct Service17CustomWrapper<
+    TcInMemConverter: EcssTcInMemConverter,
+    VerificationReporter: VerificationReportingProvider,
+> {
+    pub pus17_handler: PusService17TestHandler<TcInMemConverter, VerificationReporter>,
     pub test_srv_event_sender: Sender<(EventU32, Option<Params>)>,
 }
 
-impl<TcInMemConverter: EcssTcInMemConverter> Service17CustomWrapper<TcInMemConverter> {
+impl<
+        TcInMemConverter: EcssTcInMemConverter,
+        VerificationReporter: VerificationReportingProvider,
+    > Service17CustomWrapper<TcInMemConverter, VerificationReporter>
+{
     pub fn handle_next_packet(&mut self) -> bool {
         let res = self.pus17_handler.handle_one_tc();
         if res.is_err() {

satrs-example/src/tm_funnel.rs

@@ -1,6 +1,6 @@
 use std::{
     collections::HashMap,
-    sync::mpsc::{Receiver, Sender},
+    sync::mpsc::{self},
 };
 
 use log::info;
@@ -77,16 +77,16 @@ impl TmFunnelCommon {
 pub struct TmFunnelStatic {
     common: TmFunnelCommon,
     shared_tm_store: SharedTmPool,
-    tm_funnel_rx: Receiver<StoreAddr>,
-    tm_server_tx: Sender<StoreAddr>,
+    tm_funnel_rx: mpsc::Receiver<StoreAddr>,
+    tm_server_tx: mpsc::SyncSender<StoreAddr>,
 }
 
 impl TmFunnelStatic {
     pub fn new(
         shared_tm_store: SharedTmPool,
         sync_tm_tcp_source: SyncTcpTmSource,
-        tm_funnel_rx: Receiver<StoreAddr>,
-        tm_server_tx: Sender<StoreAddr>,
+        tm_funnel_rx: mpsc::Receiver<StoreAddr>,
+        tm_server_tx: mpsc::SyncSender<StoreAddr>,
     ) -> Self {
         Self {
             common: TmFunnelCommon::new(sync_tm_tcp_source),
@@ -123,15 +123,15 @@ impl TmFunnelStatic {
 
 pub struct TmFunnelDynamic {
     common: TmFunnelCommon,
-    tm_funnel_rx: Receiver<Vec<u8>>,
-    tm_server_tx: Sender<Vec<u8>>,
+    tm_funnel_rx: mpsc::Receiver<Vec<u8>>,
+    tm_server_tx: mpsc::Sender<Vec<u8>>,
 }
 
 impl TmFunnelDynamic {
     pub fn new(
         sync_tm_tcp_source: SyncTcpTmSource,
-        tm_funnel_rx: Receiver<Vec<u8>>,
-        tm_server_tx: Sender<Vec<u8>>,
+        tm_funnel_rx: mpsc::Receiver<Vec<u8>>,
+        tm_server_tx: mpsc::Sender<Vec<u8>>,
     ) -> Self {
         Self {
             common: TmFunnelCommon::new(sync_tm_tcp_source),

satrs-example/src/tmtc.rs

@@ -1,7 +1,10 @@
 use log::warn;
+use satrs::pus::verification::std_mod::{
+    VerificationReporterWithSharedPoolMpscBoundedSender, VerificationReporterWithVecMpscSender,
+};
 use satrs::pus::{EcssTcAndToken, ReceivesEcssPusTc};
 use satrs::spacepackets::SpHeader;
-use std::sync::mpsc::{self, Receiver, SendError, Sender, TryRecvError};
+use std::sync::mpsc::{self, Receiver, SendError, Sender, SyncSender, TryRecvError};
 use thiserror::Error;
 
 use crate::pus::PusReceiver;
@@ -37,7 +40,7 @@ impl SharedTcPool {
 
 #[derive(Clone)]
 pub struct PusTcSourceProviderSharedPool {
-    pub tc_source: Sender<StoreAddr>,
+    pub tc_source: SyncSender<StoreAddr>,
     pub shared_pool: SharedTcPool,
 }
 
@@ -97,14 +100,14 @@ pub struct TcSourceTaskStatic {
     shared_tc_pool: SharedTcPool,
     tc_receiver: Receiver<StoreAddr>,
     tc_buf: [u8; 4096],
-    pus_receiver: PusReceiver,
+    pus_receiver: PusReceiver<VerificationReporterWithSharedPoolMpscBoundedSender>,
 }
 
 impl TcSourceTaskStatic {
     pub fn new(
         shared_tc_pool: SharedTcPool,
         tc_receiver: Receiver<StoreAddr>,
-        pus_receiver: PusReceiver,
+        pus_receiver: PusReceiver<VerificationReporterWithSharedPoolMpscBoundedSender>,
     ) -> Self {
         Self {
             shared_tc_pool,
@@ -161,11 +164,14 @@ impl TcSourceTaskStatic {
 // TC source components where the heap is the backing memory of the received telecommands.
 pub struct TcSourceTaskDynamic {
     pub tc_receiver: Receiver<Vec<u8>>,
-    pus_receiver: PusReceiver,
+    pus_receiver: PusReceiver<VerificationReporterWithVecMpscSender>,
 }
 
 impl TcSourceTaskDynamic {
-    pub fn new(tc_receiver: Receiver<Vec<u8>>, pus_receiver: PusReceiver) -> Self {
+    pub fn new(
+        tc_receiver: Receiver<Vec<u8>>,
+        pus_receiver: PusReceiver<VerificationReporterWithVecMpscSender>,
+    ) -> Self {
         Self {
             tc_receiver,
             pus_receiver,