Improvements for example and documentation

- Added diagrams for sat-rs example for both structure and data flow.
- Added explanations for those diagrams as well.
- Some renaming: Use `Pool` instead of `Store` for pool components.
- General improvements for satrs-book.

satrs-example/src/main.rs

@@ -17,6 +17,7 @@ use log::info;
 use pus::test::create_test_service_dynamic;
 use satrs_core::hal::std::tcp_server::ServerConfig;
 use satrs_core::hal::std::udp_server::UdpTcServer;
+use satrs_core::tmtc::tm_helper::SharedTmPool;
 use satrs_example::config::pool::{create_sched_tc_pool, create_static_pools};
 use satrs_example::config::tasks::{
     FREQ_MS_AOCS, FREQ_MS_EVENT_HANDLING, FREQ_MS_PUS_STACK, FREQ_MS_UDP_TMTC,
@@ -37,14 +38,13 @@ use crate::pus::{PusReceiver, PusTcMpscRouter};
 use crate::requests::RequestWithToken;
 use crate::tcp::{SyncTcpTmSource, TcpTask};
 use crate::tmtc::{
-    PusTcSourceProviderSharedPool, SharedTcPool, TcArgs, TmArgs, TmtcTaskDynamic, TmtcTaskStatic,
+    PusTcSourceProviderSharedPool, SharedTcPool, TcSourceTaskDynamic, TcSourceTaskStatic,
 };
 use crate::udp::{StaticUdpTmHandler, UdpTmtcServer};
 use satrs_core::pus::event_man::EventRequestWithToken;
 use satrs_core::pus::verification::{VerificationReporterCfg, VerificationReporterWithSender};
-use satrs_core::pus::{EcssTmSender, MpscTmAsVecSender, MpscTmInStoreSender};
+use satrs_core::pus::{EcssTmSender, MpscTmAsVecSender, MpscTmInSharedPoolSender};
 use satrs_core::spacepackets::{time::cds::TimeProvider, time::TimeWriter};
-use satrs_core::tmtc::tm_helper::SharedTmStore;
 use satrs_core::tmtc::{CcsdsDistributor, TargetId};
 use satrs_core::ChannelId;
 use satrs_example::TargetIdWithApid;
@@ -65,7 +65,7 @@ fn create_verification_reporter(verif_sender: impl EcssTmSender) -> Verification
 #[allow(dead_code)]
 fn static_tmtc_pool_main() {
     let (tm_pool, tc_pool) = create_static_pools();
-    let shared_tm_store = SharedTmStore::new(tm_pool);
+    let shared_tm_pool = SharedTmPool::new(tm_pool);
     let shared_tc_pool = SharedTcPool {
         pool: Arc::new(RwLock::new(tc_pool)),
     };
@@ -75,10 +75,10 @@ fn static_tmtc_pool_main() {
 
     // Every software component which needs to generate verification telemetry, receives a cloned
     // verification reporter.
-    let verif_reporter = create_verification_reporter(MpscTmInStoreSender::new(
+    let verif_reporter = create_verification_reporter(MpscTmInSharedPoolSender::new(
         TmSenderId::PusVerification as ChannelId,
         "verif_sender",
-        shared_tm_store.clone(),
+        shared_tm_pool.clone(),
         tm_funnel_tx.clone(),
     ));
 
@@ -88,22 +88,13 @@ fn static_tmtc_pool_main() {
     let mut request_map = HashMap::new();
     request_map.insert(acs_target_id, acs_thread_tx);
 
-    let tc_source_wrapper = PusTcSourceProviderSharedPool {
+    // This helper structure is used by all telecommand providers which need to send telecommands
+    // to the TC source.
+    let tc_source = PusTcSourceProviderSharedPool {
         shared_pool: shared_tc_pool.clone(),
         tc_source: tc_source_tx,
     };
 
-    // Create clones here to allow moving the values
-    let tc_args = TcArgs {
-        tc_source: tc_source_wrapper.clone(),
-        tc_receiver: tc_source_rx,
-    };
-    let tm_args = TmArgs {
-        tm_store: shared_tm_store.clone(),
-        tm_sink_sender: tm_funnel_tx.clone(),
-        tm_udp_server_rx: tm_server_rx,
-    };
-
     // Create event handling components
     // These sender handles are used to send event requests, for example to enable or disable
     // certain events.
@@ -112,10 +103,10 @@ 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(
-        MpscTmInStoreSender::new(
+        MpscTmInSharedPoolSender::new(
             TmSenderId::AllEvents as ChannelId,
             "ALL_EVENTS_TX",
-            shared_tm_store.clone(),
+            shared_tm_pool.clone(),
             tm_funnel_tx.clone(),
         ),
         verif_reporter.clone(),
@@ -135,7 +126,7 @@ fn static_tmtc_pool_main() {
         action_service_receiver: pus_action_tx,
     };
     let pus_test_service = create_test_service_static(
-        shared_tm_store.clone(),
+        shared_tm_pool.clone(),
         tm_funnel_tx.clone(),
         verif_reporter.clone(),
         shared_tc_pool.pool.clone(),
@@ -143,15 +134,15 @@ fn static_tmtc_pool_main() {
         pus_test_rx,
     );
     let pus_scheduler_service = create_scheduler_service_static(
-        shared_tm_store.clone(),
+        shared_tm_pool.clone(),
         tm_funnel_tx.clone(),
         verif_reporter.clone(),
-        tc_source_wrapper,
+        tc_source.clone(),
         pus_sched_rx,
         create_sched_tc_pool(),
     );
     let pus_event_service = create_event_service_static(
-        shared_tm_store.clone(),
+        shared_tm_pool.clone(),
         tm_funnel_tx.clone(),
         verif_reporter.clone(),
         shared_tc_pool.pool.clone(),
@@ -159,7 +150,7 @@ fn static_tmtc_pool_main() {
         event_request_tx,
     );
     let pus_action_service = create_action_service_static(
-        shared_tm_store.clone(),
+        shared_tm_pool.clone(),
         tm_funnel_tx.clone(),
         verif_reporter.clone(),
         shared_tc_pool.pool.clone(),
@@ -167,7 +158,7 @@ fn static_tmtc_pool_main() {
         request_map.clone(),
     );
     let pus_hk_service = create_hk_service_static(
-        shared_tm_store.clone(),
+        shared_tm_pool.clone(),
         tm_funnel_tx.clone(),
         verif_reporter.clone(),
         shared_tc_pool.pool.clone(),
@@ -182,11 +173,10 @@ fn static_tmtc_pool_main() {
         pus_test_service,
     );
 
-    let ccsds_receiver = CcsdsReceiver {
-        tc_source: tc_args.tc_source.clone(),
-    };
-    let mut tmtc_task = TmtcTaskStatic::new(
-        tc_args,
+    let ccsds_receiver = CcsdsReceiver { tc_source };
+    let mut tmtc_task = TcSourceTaskStatic::new(
+        shared_tc_pool.clone(),
+        tc_source_rx,
         PusReceiver::new(verif_reporter.clone(), pus_router),
     );
 
@@ -197,8 +187,8 @@ fn static_tmtc_pool_main() {
     let mut udp_tmtc_server = UdpTmtcServer {
         udp_tc_server,
         tm_handler: StaticUdpTmHandler {
-            tm_rx: tm_args.tm_udp_server_rx,
-            tm_store: tm_args.tm_store.clone_backing_pool(),
+            tm_rx: tm_server_rx,
+            tm_store: shared_tm_pool.clone_backing_pool(),
         },
     };
 
@@ -213,10 +203,10 @@ fn static_tmtc_pool_main() {
     .expect("tcp server creation failed");
 
     let mut acs_task = AcsTask::new(
-        MpscTmInStoreSender::new(
+        MpscTmInSharedPoolSender::new(
             TmSenderId::AcsSubsystem as ChannelId,
             "ACS_TASK_SENDER",
-            shared_tm_store.clone(),
+            shared_tm_pool.clone(),
             tm_funnel_tx.clone(),
         ),
         acs_thread_rx,
@@ -224,7 +214,7 @@ fn static_tmtc_pool_main() {
     );
 
     let mut tm_funnel = TmFunnelStatic::new(
-        shared_tm_store,
+        shared_tm_pool,
         sync_tm_tcp_source,
         tm_funnel_rx,
         tm_server_tx,
@@ -399,7 +389,7 @@ fn dyn_tmtc_pool_main() {
 
     let ccsds_receiver = CcsdsReceiver { tc_source };
 
-    let mut tmtc_task = TmtcTaskDynamic::new(
+    let mut tmtc_task = TcSourceTaskDynamic::new(
         tc_source_rx,
         PusReceiver::new(verif_reporter.clone(), pus_router),
     );

satrs-example/src/pus/action.rs

@@ -6,12 +6,12 @@ use satrs_core::pus::verification::{
 };
 use satrs_core::pus::{
     EcssTcAndToken, EcssTcInMemConverter, EcssTcInSharedStoreConverter, EcssTcInVecConverter,
-    EcssTcReceiver, EcssTmSender, MpscTcReceiver, MpscTmAsVecSender, MpscTmInStoreSender,
+    EcssTcReceiver, EcssTmSender, MpscTcReceiver, MpscTmAsVecSender, MpscTmInSharedPoolSender,
     PusPacketHandlerResult, PusPacketHandlingError, PusServiceBase, PusServiceHelper,
 };
 use satrs_core::spacepackets::ecss::tc::PusTcReader;
 use satrs_core::spacepackets::ecss::PusPacket;
-use satrs_core::tmtc::tm_helper::SharedTmStore;
+use satrs_core::tmtc::tm_helper::SharedTmPool;
 use satrs_core::ChannelId;
 use satrs_example::config::{tmtc_err, TcReceiverId, TmSenderId, PUS_APID};
 use satrs_example::TargetIdWithApid;
@@ -19,14 +19,14 @@ use std::collections::HashMap;
 use std::sync::mpsc::{self, Sender};
 
 pub fn create_action_service_static(
-    shared_tm_store: SharedTmStore,
+    shared_tm_store: SharedTmPool,
     tm_funnel_tx: mpsc::Sender<StoreAddr>,
     verif_reporter: VerificationReporterWithSender,
     tc_pool: SharedStaticMemoryPool,
     pus_action_rx: mpsc::Receiver<EcssTcAndToken>,
     request_map: HashMap<TargetIdWithApid, mpsc::Sender<RequestWithToken>>,
 ) -> Pus8Wrapper<EcssTcInSharedStoreConverter> {
-    let action_srv_tm_sender = MpscTmInStoreSender::new(
+    let action_srv_tm_sender = MpscTmInSharedPoolSender::new(
         TmSenderId::PusAction as ChannelId,
         "PUS_8_TM_SENDER",
         shared_tm_store.clone(),

satrs-example/src/pus/event.rs

@@ -7,22 +7,22 @@ use satrs_core::pus::event_srv::PusService5EventHandler;
 use satrs_core::pus::verification::VerificationReporterWithSender;
 use satrs_core::pus::{
     EcssTcAndToken, EcssTcInMemConverter, EcssTcInSharedStoreConverter, EcssTcInVecConverter,
-    MpscTcReceiver, MpscTmAsVecSender, MpscTmInStoreSender, PusPacketHandlerResult,
+    MpscTcReceiver, MpscTmAsVecSender, MpscTmInSharedPoolSender, PusPacketHandlerResult,
     PusServiceHelper,
 };
-use satrs_core::tmtc::tm_helper::SharedTmStore;
+use satrs_core::tmtc::tm_helper::SharedTmPool;
 use satrs_core::ChannelId;
 use satrs_example::config::{TcReceiverId, TmSenderId, PUS_APID};
 
 pub fn create_event_service_static(
-    shared_tm_store: SharedTmStore,
+    shared_tm_store: SharedTmPool,
     tm_funnel_tx: mpsc::Sender<StoreAddr>,
     verif_reporter: VerificationReporterWithSender,
     tc_pool: SharedStaticMemoryPool,
     pus_event_rx: mpsc::Receiver<EcssTcAndToken>,
     event_request_tx: mpsc::Sender<EventRequestWithToken>,
 ) -> Pus5Wrapper<EcssTcInSharedStoreConverter> {
-    let event_srv_tm_sender = MpscTmInStoreSender::new(
+    let event_srv_tm_sender = MpscTmInSharedPoolSender::new(
         TmSenderId::PusEvent as ChannelId,
         "PUS_5_TM_SENDER",
         shared_tm_store.clone(),

satrs-example/src/pus/hk.rs

@@ -7,11 +7,11 @@ use satrs_core::pus::verification::{
 };
 use satrs_core::pus::{
     EcssTcAndToken, EcssTcInMemConverter, EcssTcInSharedStoreConverter, EcssTcInVecConverter,
-    EcssTcReceiver, EcssTmSender, MpscTcReceiver, MpscTmAsVecSender, MpscTmInStoreSender,
+    EcssTcReceiver, EcssTmSender, MpscTcReceiver, MpscTmAsVecSender, MpscTmInSharedPoolSender,
     PusPacketHandlerResult, PusPacketHandlingError, PusServiceBase, PusServiceHelper,
 };
 use satrs_core::spacepackets::ecss::{hk, PusPacket};
-use satrs_core::tmtc::tm_helper::SharedTmStore;
+use satrs_core::tmtc::tm_helper::SharedTmPool;
 use satrs_core::ChannelId;
 use satrs_example::config::{hk_err, tmtc_err, TcReceiverId, TmSenderId, PUS_APID};
 use satrs_example::TargetIdWithApid;
@@ -19,14 +19,14 @@ use std::collections::HashMap;
 use std::sync::mpsc::{self, Sender};
 
 pub fn create_hk_service_static(
-    shared_tm_store: SharedTmStore,
+    shared_tm_store: SharedTmPool,
     tm_funnel_tx: mpsc::Sender<StoreAddr>,
     verif_reporter: VerificationReporterWithSender,
     tc_pool: SharedStaticMemoryPool,
     pus_hk_rx: mpsc::Receiver<EcssTcAndToken>,
     request_map: HashMap<TargetIdWithApid, mpsc::Sender<RequestWithToken>>,
 ) -> Pus3Wrapper<EcssTcInSharedStoreConverter> {
-    let hk_srv_tm_sender = MpscTmInStoreSender::new(
+    let hk_srv_tm_sender = MpscTmInSharedPoolSender::new(
         TmSenderId::PusHk as ChannelId,
         "PUS_3_TM_SENDER",
         shared_tm_store.clone(),

satrs-example/src/pus/scheduler.rs

@@ -8,10 +8,10 @@ use satrs_core::pus::scheduler_srv::PusService11SchedHandler;
 use satrs_core::pus::verification::VerificationReporterWithSender;
 use satrs_core::pus::{
     EcssTcAndToken, EcssTcInMemConverter, EcssTcInSharedStoreConverter, EcssTcInVecConverter,
-    MpscTcReceiver, MpscTmAsVecSender, MpscTmInStoreSender, PusPacketHandlerResult,
+    MpscTcReceiver, MpscTmAsVecSender, MpscTmInSharedPoolSender, PusPacketHandlerResult,
     PusServiceHelper,
 };
-use satrs_core::tmtc::tm_helper::SharedTmStore;
+use satrs_core::tmtc::tm_helper::SharedTmPool;
 use satrs_core::ChannelId;
 use satrs_example::config::{TcReceiverId, TmSenderId, PUS_APID};
 
@@ -103,14 +103,14 @@ impl<TcInMemConverter: EcssTcInMemConverter> Pus11Wrapper<TcInMemConverter> {
 }
 
 pub fn create_scheduler_service_static(
-    shared_tm_store: SharedTmStore,
+    shared_tm_store: SharedTmPool,
     tm_funnel_tx: mpsc::Sender<StoreAddr>,
     verif_reporter: VerificationReporterWithSender,
     tc_releaser: PusTcSourceProviderSharedPool,
     pus_sched_rx: mpsc::Receiver<EcssTcAndToken>,
     sched_tc_pool: StaticMemoryPool,
 ) -> Pus11Wrapper<EcssTcInSharedStoreConverter> {
-    let sched_srv_tm_sender = MpscTmInStoreSender::new(
+    let sched_srv_tm_sender = MpscTmInSharedPoolSender::new(
         TmSenderId::PusSched as ChannelId,
         "PUS_11_TM_SENDER",
         shared_tm_store.clone(),

satrs-example/src/pus/test.rs

@@ -5,27 +5,27 @@ use satrs_core::pus::test::PusService17TestHandler;
 use satrs_core::pus::verification::{FailParams, VerificationReporterWithSender};
 use satrs_core::pus::{
     EcssTcAndToken, EcssTcInMemConverter, EcssTcInVecConverter, MpscTcReceiver, MpscTmAsVecSender,
-    MpscTmInStoreSender, PusPacketHandlerResult, PusServiceHelper,
+    MpscTmInSharedPoolSender, PusPacketHandlerResult, PusServiceHelper,
 };
 use satrs_core::spacepackets::ecss::tc::PusTcReader;
 use satrs_core::spacepackets::ecss::PusPacket;
 use satrs_core::spacepackets::time::cds::TimeProvider;
 use satrs_core::spacepackets::time::TimeWriter;
-use satrs_core::tmtc::tm_helper::SharedTmStore;
+use satrs_core::tmtc::tm_helper::SharedTmPool;
 use satrs_core::ChannelId;
 use satrs_core::{events::EventU32, pus::EcssTcInSharedStoreConverter};
 use satrs_example::config::{tmtc_err, TcReceiverId, TmSenderId, PUS_APID, TEST_EVENT};
 use std::sync::mpsc::{self, Sender};
 
 pub fn create_test_service_static(
-    shared_tm_store: SharedTmStore,
+    shared_tm_store: SharedTmPool,
     tm_funnel_tx: mpsc::Sender<StoreAddr>,
     verif_reporter: VerificationReporterWithSender,
     tc_pool: SharedStaticMemoryPool,
     event_sender: mpsc::Sender<(EventU32, Option<Params>)>,
     pus_test_rx: mpsc::Receiver<EcssTcAndToken>,
 ) -> Service17CustomWrapper<EcssTcInSharedStoreConverter> {
-    let test_srv_tm_sender = MpscTmInStoreSender::new(
+    let test_srv_tm_sender = MpscTmInSharedPoolSender::new(
         TmSenderId::PusTest as ChannelId,
         "PUS_17_TM_SENDER",
         shared_tm_store.clone(),

satrs-example/src/tcp.rs

@@ -76,7 +76,6 @@ pub struct TcpTask<MpscErrorType: 'static> {
         SyncTcpTmSource,
         CcsdsDistributor<MpscErrorType>,
     >,
-    phantom: std::marker::PhantomData<MpscErrorType>,
 }
 
 impl<MpscErrorType: 'static + core::fmt::Debug> TcpTask<MpscErrorType> {
@@ -92,7 +91,6 @@ impl<MpscErrorType: 'static + core::fmt::Debug> TcpTask<MpscErrorType> {
                 tc_receiver,
                 Box::new(PACKET_ID_LOOKUP),
             )?,
-            phantom: std::marker::PhantomData,
         })
     }
 

satrs-example/src/tm_funnel.rs

@@ -11,7 +11,7 @@ use satrs_core::{
         time::cds::MIN_CDS_FIELD_LEN,
         CcsdsPacket,
     },
-    tmtc::tm_helper::SharedTmStore,
+    tmtc::tm_helper::SharedTmPool,
 };
 
 use crate::tcp::SyncTcpTmSource;
@@ -70,14 +70,14 @@ impl TmFunnelCommon {
 
 pub struct TmFunnelStatic {
     common: TmFunnelCommon,
-    shared_tm_store: SharedTmStore,
+    shared_tm_store: SharedTmPool,
     tm_funnel_rx: Receiver<StoreAddr>,
     tm_server_tx: Sender<StoreAddr>,
 }
 
 impl TmFunnelStatic {
     pub fn new(
-        shared_tm_store: SharedTmStore,
+        shared_tm_store: SharedTmPool,
         sync_tm_tcp_source: SyncTcpTmSource,
         tm_funnel_rx: Receiver<StoreAddr>,
         tm_server_tx: Sender<StoreAddr>,

satrs-example/src/tmtc.rs

@@ -8,27 +8,8 @@ use crate::pus::PusReceiver;
 use satrs_core::pool::{PoolProviderMemInPlace, SharedStaticMemoryPool, StoreAddr, StoreError};
 use satrs_core::spacepackets::ecss::tc::PusTcReader;
 use satrs_core::spacepackets::ecss::PusPacket;
-use satrs_core::tmtc::tm_helper::SharedTmStore;
 use satrs_core::tmtc::ReceivesCcsdsTc;
 
-pub struct TmArgs {
-    pub tm_store: SharedTmStore,
-    pub tm_sink_sender: Sender<StoreAddr>,
-    pub tm_udp_server_rx: Receiver<StoreAddr>,
-}
-
-pub struct TcArgs {
-    pub tc_source: PusTcSourceProviderSharedPool,
-    pub tc_receiver: Receiver<StoreAddr>,
-}
-
-impl TcArgs {
-    #[allow(dead_code)]
-    fn split(self) -> (PusTcSourceProviderSharedPool, Receiver<StoreAddr>) {
-        (self.tc_source, self.tc_receiver)
-    }
-}
-
 #[derive(Debug, Clone, PartialEq, Eq, Error)]
 pub enum MpscStoreAndSendError {
     #[error("Store error: {0}")]
@@ -110,16 +91,23 @@ impl ReceivesCcsdsTc for PusTcSourceProviderDynamic {
     }
 }
 
-pub struct TmtcTaskStatic {
-    tc_args: TcArgs,
+// TC source components where static pools are the backing memory of the received telecommands.
+pub struct TcSourceTaskStatic {
+    shared_tc_pool: SharedTcPool,
+    tc_receiver: Receiver<StoreAddr>,
     tc_buf: [u8; 4096],
     pus_receiver: PusReceiver,
 }
 
-impl TmtcTaskStatic {
-    pub fn new(tc_args: TcArgs, pus_receiver: PusReceiver) -> Self {
+impl TcSourceTaskStatic {
+    pub fn new(
+        shared_tc_pool: SharedTcPool,
+        tc_receiver: Receiver<StoreAddr>,
+        pus_receiver: PusReceiver,
+    ) -> Self {
         Self {
-            tc_args,
+            shared_tc_pool,
+            tc_receiver,
             tc_buf: [0; 4096],
             pus_receiver,
         }
@@ -130,12 +118,10 @@ impl TmtcTaskStatic {
     }
 
     pub fn poll_tc(&mut self) -> bool {
-        match self.tc_args.tc_receiver.try_recv() {
+        match self.tc_receiver.try_recv() {
             Ok(addr) => {
                 let pool = self
-                    .tc_args
-                    .tc_source
-                    .shared_pool
+                    .shared_tc_pool
                     .pool
                     .read()
                     .expect("locking tc pool failed");
@@ -171,12 +157,13 @@ impl TmtcTaskStatic {
     }
 }
 
-pub struct TmtcTaskDynamic {
+// 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,
 }
 
-impl TmtcTaskDynamic {
+impl TcSourceTaskDynamic {
     pub fn new(tc_receiver: Receiver<Vec<u8>>, pus_receiver: PusReceiver) -> Self {
         Self {
             tc_receiver,