Finish PUS service optimizations

- Better naming for pool abstractions
- Added last unittests for PUS helper services
- Introduce new abstraction for PUS schedulers
- `StoreAddr` is now a generic u64
- `spacepackets` points to 0.7.0 release

satrs-example/pyclient/.gitignore

@@ -6,3 +6,4 @@ __pycache__
 !/.idea/runConfigurations
 
 /seqcnt.txt
+/.tmtc-history.txt

satrs-example/pyclient/common.py

@@ -44,10 +44,6 @@ class AcsHkIds(enum.IntEnum):
     MGM_SET = 1
 
 
-class HkOpCodes:
-    GENERATE_ONE_SHOT = ["0", "oneshot"]
-
-
 def make_addressable_id(target_id: int, unique_id: int) -> bytes:
     byte_string = bytearray(struct.pack("!I", target_id))
     byte_string.extend(struct.pack("!I", unique_id))

satrs-example/pyclient/main.py

@@ -4,6 +4,8 @@ import logging
 import sys
 import time
 from typing import Optional
+from prompt_toolkit.history import History
+from prompt_toolkit.history import FileHistory
 
 import tmtccmd
 from spacepackets.ecss import PusTelemetry, PusVerificator
@@ -11,16 +13,16 @@ from spacepackets.ecss.pus_17_test import Service17Tm
 from spacepackets.ecss.pus_1_verification import UnpackParams, Service1Tm
 from spacepackets.ccsds.time import CdsShortTimestamp
 
-from tmtccmd import CcsdsTmtcBackend, TcHandlerBase, ProcedureParamsWrapper
+from tmtccmd import TcHandlerBase, ProcedureParamsWrapper
 from tmtccmd.core.base import BackendRequest
 from tmtccmd.pus import VerificationWrapper
 from tmtccmd.tmtc import CcsdsTmHandler, SpecificApidHandlerBase
 from tmtccmd.com import ComInterface
 from tmtccmd.config import (
+    CmdTreeNode,
     default_json_path,
     SetupParams,
     HookBase,
-    TmtcDefinitionWrapper,
     params_to_procedure_conversion,
 )
 from tmtccmd.config import PreArgsParsingWrapper, SetupWrapper
@@ -39,12 +41,11 @@ from tmtccmd.tmtc import (
     DefaultPusQueueHelper,
     QueueWrapper,
 )
-from tmtccmd.util import FileSeqCountProvider, PusFileSeqCountProvider
+from spacepackets.seqcount import FileSeqCountProvider, PusFileSeqCountProvider
 from tmtccmd.util.obj_id import ObjectIdDictT
 
 
 import pus_tc
-import tc_definitions
 from common import EXAMPLE_PUS_APID, TM_PACKET_IDS, EventU32
 
 _LOGGER = logging.getLogger()
@@ -54,25 +55,29 @@ class SatRsConfigHook(HookBase):
     def __init__(self, json_cfg_path: str):
         super().__init__(json_cfg_path=json_cfg_path)
 
-    def assign_communication_interface(self, com_if_key: str) -> Optional[ComInterface]:
+    def get_communication_interface(self, com_if_key: str) -> Optional[ComInterface]:
         from tmtccmd.config.com import (
             create_com_interface_default,
             create_com_interface_cfg_default,
         )
 
+        assert self.cfg_path is not None
         cfg = create_com_interface_cfg_default(
             com_if_key=com_if_key,
             json_cfg_path=self.cfg_path,
             space_packet_ids=TM_PACKET_IDS,
         )
+        assert cfg is not None
         return create_com_interface_default(cfg)
 
-    def get_tmtc_definitions(self) -> TmtcDefinitionWrapper:
-        return tc_definitions.tc_definitions()
+    def get_command_definitions(self) -> CmdTreeNode:
+        """This function should return the root node of the command definition tree."""
+        return pus_tc.create_cmd_definition_tree()
 
-    def perform_mode_operation(self, tmtc_backend: CcsdsTmtcBackend, mode: int):
-        _LOGGER.info("Mode operation hook was called")
-        pass
+    def get_cmd_history(self) -> Optional[History]:
+        """Optionlly return a history class for the past command paths which will be used
+        when prompting a command path from the user in CLI mode."""
+        return FileHistory(".tmtc-history.txt")
 
     def get_object_ids(self) -> ObjectIdDictT:
         from tmtccmd.config.objects import get_core_object_ids
@@ -94,15 +99,12 @@ class PusHandler(SpecificApidHandlerBase):
 
     def handle_tm(self, packet: bytes, _user_args: any):
         try:
-            tm_packet = PusTelemetry.unpack(
-                packet, time_reader=CdsShortTimestamp.empty()
-            )
+            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}")
             raise e
-        service = tm_packet.service
-        dedicated_handler = False
+        service = pus_tm.service
         if service == 1:
             tm_packet = Service1Tm.unpack(
                 data=packet, params=UnpackParams(CdsShortTimestamp.empty(), 1, 2)
@@ -119,8 +121,7 @@ class PusHandler(SpecificApidHandlerBase):
             else:
                 self.verif_wrapper.log_to_console(tm_packet, res)
                 self.verif_wrapper.log_to_file(tm_packet, res)
-            dedicated_handler = True
-        if service == 3:
+        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, time_reader=CdsShortTimestamp.empty())
@@ -129,8 +130,7 @@ class PusHandler(SpecificApidHandlerBase):
                     raise ValueError("No addressable ID in HK packet")
                 json_str = pus_tm.source_data[8:]
                 _LOGGER.info(json_str)
-            dedicated_handler = True
-        if service == 5:
+        elif service == 5:
             tm_packet = PusTelemetry.unpack(
                 packet, time_reader=CdsShortTimestamp.empty()
             )
@@ -139,11 +139,10 @@ class PusHandler(SpecificApidHandlerBase):
             _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")
-        if service == 17:
+        elif service == 17:
             tm_packet = Service17Tm.unpack(
                 packet, time_reader=CdsShortTimestamp.empty()
             )
-            dedicated_handler = True
             if tm_packet.subservice == 2:
                 self.file_logger.info("Received Ping Reply TM[17,2]")
                 _LOGGER.info("Received Ping Reply TM[17,2]")
@@ -154,17 +153,14 @@ class PusHandler(SpecificApidHandlerBase):
                 _LOGGER.info(
                     f"Received Test Packet with unknown subservice {tm_packet.subservice}"
                 )
-        if tm_packet is None:
+        else:
             _LOGGER.info(
                 f"The service {service} is not implemented in Telemetry Factory"
             )
             tm_packet = PusTelemetry.unpack(
                 packet, time_reader=CdsShortTimestamp.empty()
             )
-        self.raw_logger.log_tm(tm_packet)
-        if not dedicated_handler and tm_packet is not None:
-            pass
-            # self.printer.handle_long_tm_print(packet_if=tm_packet, info_if=tm_packet)
+        self.raw_logger.log_tm(pus_tm)
 
 
 class TcHandler(TcHandlerBase):
@@ -196,22 +192,18 @@ class TcHandler(TcHandlerBase):
             log_entry = entry_helper.to_log_entry()
             _LOGGER.info(log_entry.log_str)
 
-    def queue_finished_cb(self, helper: ProcedureWrapper):
-        if helper.proc_type == TcProcedureType.DEFAULT:
-            def_proc = helper.to_def_procedure()
-            _LOGGER.info(
-                f"Queue handling finished for service {def_proc.service} and "
-                f"op code {def_proc.op_code}"
-            )
+    def queue_finished_cb(self, info: ProcedureWrapper):
+        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, helper: ProcedureWrapper, wrapper: FeedWrapper):
+    def feed_cb(self, info: ProcedureWrapper, wrapper: FeedWrapper):
         q = self.queue_helper
         q.queue_wrapper = wrapper.queue_wrapper
-        if helper.proc_type == TcProcedureType.DEFAULT:
-            def_proc = helper.to_def_procedure()
-            service = def_proc.service
-            op_code = def_proc.op_code
-            pus_tc.pack_pus_telecommands(q, service, op_code)
+        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)
 
 
 def main():

satrs-example/pyclient/pus_tc.py

@@ -1,50 +1,85 @@
 import datetime
+import logging
 
 from spacepackets.ccsds import CdsShortTimestamp
 from spacepackets.ecss import PusTelecommand
-from tmtccmd.config import CoreServiceList
+from tmtccmd.config import CmdTreeNode
 from tmtccmd.tmtc import DefaultPusQueueHelper
 from tmtccmd.pus.s11_tc_sched import create_time_tagged_cmd
 from tmtccmd.pus.tc.s3_fsfw_hk import create_request_one_hk_command
 
 from common import (
     EXAMPLE_PUS_APID,
-    HkOpCodes,
     make_addressable_id,
     RequestTargetId,
     AcsHkIds,
 )
 
+_LOGGER = logging.getLogger(__name__)
 
-def pack_pus_telecommands(q: DefaultPusQueueHelper, service: str, op_code: str):
-    if (
-        service == CoreServiceList.SERVICE_17
-        or service == CoreServiceList.SERVICE_17_ALT
-    ):
-        if op_code == "ping":
+
+def create_cmd_definition_tree() -> CmdTreeNode:
+
+    root_node = CmdTreeNode.root_node()
+
+    test_node = CmdTreeNode("test", "Test Node")
+    test_node.add_child(CmdTreeNode("ping", "Send PUS ping TC"))
+    test_node.add_child(CmdTreeNode("trigger_event", "Send PUS test to trigger event"))
+    root_node.add_child(test_node)
+
+    scheduler_node = CmdTreeNode("scheduler", "Scheduler Node")
+    scheduler_node.add_child(
+        CmdTreeNode(
+            "schedule_ping_10_secs_ahead", "Schedule Ping to execute in 10 seconds"
+        )
+    )
+    root_node.add_child(scheduler_node)
+
+    acs_node = CmdTreeNode("acs", "ACS Subsystem Node")
+    mgm_node = CmdTreeNode("mgms", "MGM devices node")
+    mgm_node.add_child(CmdTreeNode("one_shot_hk", "Request one shot HK"))
+    acs_node.add_child(mgm_node)
+    root_node.add_child(acs_node)
+
+    return root_node
+
+
+def pack_pus_telecommands(q: DefaultPusQueueHelper, cmd_path: str):
+    # It should always be at least the root path "/", so we split of the empty portion left of it.
+    cmd_path_list = cmd_path.split("/")[1:]
+    if len(cmd_path_list) == 0:
+        _LOGGER.warning("empty command path")
+        return
+    if cmd_path_list[0] == "test":
+        assert len(cmd_path_list) >= 2
+        if cmd_path_list[1] == "ping":
             q.add_log_cmd("Sending PUS ping telecommand")
             return q.add_pus_tc(PusTelecommand(service=17, subservice=1))
-        elif op_code == "trigger_event":
+        elif cmd_path_list[1] == "trigger_event":
             q.add_log_cmd("Triggering test event")
             return q.add_pus_tc(PusTelecommand(service=17, subservice=128))
-    if service == CoreServiceList.SERVICE_11:
-        q.add_log_cmd("Sending PUS scheduled TC telecommand")
-        crt_time = CdsShortTimestamp.from_now()
-        time_stamp = crt_time + datetime.timedelta(seconds=10)
-        time_stamp = time_stamp.pack()
-        return q.add_pus_tc(
-            create_time_tagged_cmd(
-                time_stamp,
-                PusTelecommand(service=17, subservice=1),
-                apid=EXAMPLE_PUS_APID,
-            )
-        )
-    if service == CoreServiceList.SERVICE_3:
-        if op_code in HkOpCodes.GENERATE_ONE_SHOT:
-            q.add_log_cmd("Sending HK one shot request")
-            q.add_pus_tc(
-                create_request_one_hk_command(
-                    make_addressable_id(RequestTargetId.ACS, AcsHkIds.MGM_SET)
+    if cmd_path_list[0] == "scheduler":
+        assert len(cmd_path_list) >= 2
+        if cmd_path_list[1] == "schedule_ping_10_secs_ahead":
+            q.add_log_cmd("Sending PUS scheduled TC telecommand")
+            crt_time = CdsShortTimestamp.from_now()
+            time_stamp = crt_time + datetime.timedelta(seconds=10)
+            time_stamp = time_stamp.pack()
+            return q.add_pus_tc(
+                create_time_tagged_cmd(
+                    time_stamp,
+                    PusTelecommand(service=17, subservice=1),
+                    apid=EXAMPLE_PUS_APID,
                 )
             )
-        pass
+    if cmd_path_list[0] == "acs":
+        assert len(cmd_path_list) >= 2
+        if cmd_path_list[1] == "mgm":
+            assert len(cmd_path_list) >= 3
+            if cmd_path_list[2] == "one_shot_hk":
+                q.add_log_cmd("Sending HK one shot request")
+                q.add_pus_tc(
+                    create_request_one_hk_command(
+                        make_addressable_id(RequestTargetId.ACS, AcsHkIds.MGM_SET)
+                    )
+                )

satrs-example/pyclient/requirements.txt

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

satrs-example/src/main.rs

@@ -29,7 +29,7 @@ use satrs_core::event_man::{
 };
 use satrs_core::events::EventU32;
 use satrs_core::hk::HkRequest;
-use satrs_core::pool::{LocalPool, PoolCfg};
+use satrs_core::pool::{PoolProviderMemInPlace, StaticMemoryPool, StaticPoolConfig};
 use satrs_core::pus::event_man::{
     DefaultPusMgmtBackendProvider, EventReporter, EventRequest, EventRequestWithToken,
     PusEventDispatcher,
@@ -42,7 +42,9 @@ use satrs_core::pus::test::PusService17TestHandler;
 use satrs_core::pus::verification::{
     TcStateStarted, VerificationReporterCfg, VerificationReporterWithSender, VerificationToken,
 };
-use satrs_core::pus::{MpscTcInStoreReceiver, MpscTmInStoreSender};
+use satrs_core::pus::{
+    EcssTcInSharedStoreConverter, MpscTcReceiver, MpscTmInStoreSender, PusServiceHelper,
+};
 use satrs_core::seq_count::{CcsdsSimpleSeqCountProvider, SequenceCountProviderCore};
 use satrs_core::spacepackets::ecss::tm::{PusTmCreator, PusTmZeroCopyWriter};
 use satrs_core::spacepackets::{
@@ -66,7 +68,7 @@ use std::time::Duration;
 fn main() {
     setup_logger().expect("setting up logging with fern failed");
     println!("Running OBSW example");
-    let tm_pool = LocalPool::new(PoolCfg::new(vec![
+    let tm_pool = StaticMemoryPool::new(StaticPoolConfig::new(vec![
         (30, 32),
         (15, 64),
         (15, 128),
@@ -74,9 +76,9 @@ fn main() {
         (15, 1024),
         (15, 2048),
     ]));
-    let shared_tm_store = SharedTmStore::new(Box::new(tm_pool));
+    let shared_tm_store = SharedTmStore::new(tm_pool);
     let tm_store_event = shared_tm_store.clone();
-    let tc_pool = LocalPool::new(PoolCfg::new(vec![
+    let tc_pool = StaticMemoryPool::new(StaticPoolConfig::new(vec![
         (30, 32),
         (15, 64),
         (15, 128),
@@ -85,8 +87,16 @@ fn main() {
         (15, 2048),
     ]));
     let tc_store = TcStore {
-        pool: Arc::new(RwLock::new(Box::new(tc_pool))),
+        pool: Arc::new(RwLock::new(tc_pool)),
     };
+    let sched_tc_pool = StaticMemoryPool::new(StaticPoolConfig::new(vec![
+        (30, 32),
+        (15, 64),
+        (15, 128),
+        (15, 256),
+        (15, 1024),
+        (15, 2048),
+    ]));
 
     let seq_count_provider = CcsdsSimpleSeqCountProvider::new();
     let mut msg_counter_map: HashMap<u8, u16> = HashMap::new();
@@ -172,18 +182,18 @@ fn main() {
         shared_tm_store.clone(),
         tm_funnel_tx.clone(),
     );
-    let test_srv_receiver = MpscTcInStoreReceiver::new(
+    let test_srv_receiver = MpscTcReceiver::new(
         TcReceiverId::PusTest as ChannelId,
         "PUS_17_TC_RECV",
         pus_test_rx,
     );
-    let pus17_handler = PusService17TestHandler::new(
+    let pus17_handler = PusService17TestHandler::new(PusServiceHelper::new(
         Box::new(test_srv_receiver),
-        tc_store.pool.clone(),
         Box::new(test_srv_tm_sender),
         PUS_APID,
         verif_reporter.clone(),
-    );
+        EcssTcInSharedStoreConverter::new(tc_store.pool.clone(), 2048),
+    ));
     let mut pus_17_wrapper = Service17CustomWrapper {
         pus17_handler,
         test_srv_event_sender,
@@ -195,7 +205,7 @@ fn main() {
         shared_tm_store.clone(),
         tm_funnel_tx.clone(),
     );
-    let sched_srv_receiver = MpscTcInStoreReceiver::new(
+    let sched_srv_receiver = MpscTcReceiver::new(
         TcReceiverId::PusSched as ChannelId,
         "PUS_11_TC_RECV",
         pus_sched_rx,
@@ -203,15 +213,18 @@ fn main() {
     let scheduler = PusScheduler::new_with_current_init_time(Duration::from_secs(5))
         .expect("Creating PUS Scheduler failed");
     let pus_11_handler = PusService11SchedHandler::new(
-        Box::new(sched_srv_receiver),
-        tc_store.pool.clone(),
-        Box::new(sched_srv_tm_sender),
-        PUS_APID,
-        verif_reporter.clone(),
+        PusServiceHelper::new(
+            Box::new(sched_srv_receiver),
+            Box::new(sched_srv_tm_sender),
+            PUS_APID,
+            verif_reporter.clone(),
+            EcssTcInSharedStoreConverter::new(tc_store.pool.clone(), 2048),
+        ),
         scheduler,
     );
     let mut pus_11_wrapper = Pus11Wrapper {
         pus_11_handler,
+        sched_tc_pool,
         tc_source_wrapper,
     };
 
@@ -221,17 +234,19 @@ fn main() {
         shared_tm_store.clone(),
         tm_funnel_tx.clone(),
     );
-    let event_srv_receiver = MpscTcInStoreReceiver::new(
+    let event_srv_receiver = MpscTcReceiver::new(
         TcReceiverId::PusEvent as ChannelId,
         "PUS_5_TC_RECV",
         pus_event_rx,
     );
     let pus_5_handler = PusService5EventHandler::new(
-        Box::new(event_srv_receiver),
-        tc_store.pool.clone(),
-        Box::new(event_srv_tm_sender),
-        PUS_APID,
-        verif_reporter.clone(),
+        PusServiceHelper::new(
+            Box::new(event_srv_receiver),
+            Box::new(event_srv_tm_sender),
+            PUS_APID,
+            verif_reporter.clone(),
+            EcssTcInSharedStoreConverter::new(tc_store.pool.clone(), 2048),
+        ),
         event_request_tx,
     );
     let mut pus_5_wrapper = Pus5Wrapper { pus_5_handler };
@@ -242,17 +257,17 @@ fn main() {
         shared_tm_store.clone(),
         tm_funnel_tx.clone(),
     );
-    let action_srv_receiver = MpscTcInStoreReceiver::new(
+    let action_srv_receiver = MpscTcReceiver::new(
         TcReceiverId::PusAction as ChannelId,
         "PUS_8_TC_RECV",
         pus_action_rx,
     );
     let pus_8_handler = PusService8ActionHandler::new(
         Box::new(action_srv_receiver),
-        tc_store.pool.clone(),
         Box::new(action_srv_tm_sender),
         PUS_APID,
         verif_reporter.clone(),
+        EcssTcInSharedStoreConverter::new(tc_store.pool.clone(), 2048),
         request_map.clone(),
     );
     let mut pus_8_wrapper = Pus8Wrapper { pus_8_handler };
@@ -264,13 +279,13 @@ fn main() {
         tm_funnel_tx.clone(),
     );
     let hk_srv_receiver =
-        MpscTcInStoreReceiver::new(TcReceiverId::PusHk as ChannelId, "PUS_8_TC_RECV", pus_hk_rx);
+        MpscTcReceiver::new(TcReceiverId::PusHk as ChannelId, "PUS_8_TC_RECV", pus_hk_rx);
     let pus_3_handler = PusService3HkHandler::new(
         Box::new(hk_srv_receiver),
-        tc_store.pool.clone(),
         Box::new(hk_srv_tm_sender),
         PUS_APID,
         verif_reporter.clone(),
+        EcssTcInSharedStoreConverter::new(tc_store.pool.clone(), 2048),
         request_map,
     );
     let mut pus_3_wrapper = Pus3Wrapper { pus_3_handler };

satrs-example/src/pus/action.rs

@@ -1,12 +1,11 @@
 use crate::requests::{ActionRequest, Request, RequestWithToken};
 use log::{error, warn};
-use satrs_core::pool::{SharedPool, StoreAddr};
 use satrs_core::pus::verification::{
-    FailParams, StdVerifReporterWithSender, TcStateAccepted, VerificationToken,
+    FailParams, TcStateAccepted, VerificationReporterWithSender, VerificationToken,
 };
 use satrs_core::pus::{
-    EcssTcReceiver, EcssTmSender, PusPacketHandlerResult, PusPacketHandlingError, PusServiceBase,
-    PusServiceHandler,
+    EcssTcInMemConverter, EcssTcInSharedStoreConverter, EcssTcReceiver, EcssTmSender,
+    PusPacketHandlerResult, PusPacketHandlingError, PusServiceBase, PusServiceHelper,
 };
 use satrs_core::spacepackets::ecss::tc::PusTcReader;
 use satrs_core::spacepackets::ecss::PusPacket;
@@ -14,34 +13,32 @@ use satrs_example::{tmtc_err, TargetIdWithApid};
 use std::collections::HashMap;
 use std::sync::mpsc::Sender;
 
-pub struct PusService8ActionHandler {
-    psb: PusServiceBase,
+pub struct PusService8ActionHandler<TcInMemConverter: EcssTcInMemConverter> {
+    service_helper: PusServiceHelper<TcInMemConverter>,
     request_handlers: HashMap<TargetIdWithApid, Sender<RequestWithToken>>,
 }
 
-impl PusService8ActionHandler {
+impl<TcInMemConverter: EcssTcInMemConverter> PusService8ActionHandler<TcInMemConverter> {
     pub fn new(
         tc_receiver: Box<dyn EcssTcReceiver>,
-        shared_tc_pool: SharedPool,
         tm_sender: Box<dyn EcssTmSender>,
         tm_apid: u16,
-        verification_handler: StdVerifReporterWithSender,
+        verification_handler: VerificationReporterWithSender,
+        tc_in_mem_converter: TcInMemConverter,
         request_handlers: HashMap<TargetIdWithApid, Sender<RequestWithToken>>,
     ) -> Self {
         Self {
-            psb: PusServiceBase::new(
+            service_helper: PusServiceHelper::new(
                 tc_receiver,
-                shared_tc_pool,
                 tm_sender,
                 tm_apid,
                 verification_handler,
+                tc_in_mem_converter,
             ),
             request_handlers,
         }
     }
-}
 
-impl PusService8ActionHandler {
     fn handle_action_request_with_id(
         &self,
         token: VerificationToken<TcStateAccepted>,
@@ -50,7 +47,8 @@ impl PusService8ActionHandler {
     ) -> Result<(), PusPacketHandlingError> {
         let user_data = tc.user_data();
         if user_data.len() < 8 {
-            self.psb()
+            self.service_helper
+                .common
                 .verification_handler
                 .borrow_mut()
                 .start_failure(
@@ -79,7 +77,8 @@ impl PusService8ActionHandler {
         } else {
             let mut fail_data: [u8; 4] = [0; 4];
             fail_data.copy_from_slice(&target_id.target.to_be_bytes());
-            self.psb()
+            self.service_helper
+                .common
                 .verification_handler
                 .borrow_mut()
                 .start_failure(
@@ -97,37 +96,32 @@ impl PusService8ActionHandler {
         }
         Ok(())
     }
-}
 
-impl PusServiceHandler for PusService8ActionHandler {
-    fn psb_mut(&mut self) -> &mut PusServiceBase {
-        &mut self.psb
-    }
-    fn psb(&self) -> &PusServiceBase {
-        &self.psb
-    }
-
-    fn handle_one_tc(
-        &mut self,
-        addr: StoreAddr,
-        token: VerificationToken<TcStateAccepted>,
-    ) -> Result<PusPacketHandlerResult, PusPacketHandlingError> {
-        self.copy_tc_to_buf(addr)?;
-        let (tc, _) = PusTcReader::new(&self.psb().pus_buf).unwrap();
+    fn handle_one_tc(&mut self) -> Result<PusPacketHandlerResult, PusPacketHandlingError> {
+        let possible_packet = self.service_helper.retrieve_and_accept_next_packet()?;
+        if possible_packet.is_none() {
+            return Ok(PusPacketHandlerResult::Empty);
+        }
+        let ecss_tc_and_token = possible_packet.unwrap();
+        self.service_helper
+            .tc_in_mem_converter
+            .cache_ecss_tc_in_memory(&ecss_tc_and_token.tc_in_memory)?;
+        let tc = PusTcReader::new(self.service_helper.tc_in_mem_converter.tc_slice_raw())?.0;
         let subservice = tc.subservice();
         let mut partial_error = None;
-        let time_stamp = self.psb().get_current_timestamp(&mut partial_error);
+        let time_stamp = PusServiceBase::get_current_timestamp(&mut partial_error);
         match subservice {
             128 => {
-                self.handle_action_request_with_id(token, &tc, &time_stamp)?;
+                self.handle_action_request_with_id(ecss_tc_and_token.token, &tc, &time_stamp)?;
             }
             _ => {
                 let fail_data = [subservice];
-                self.psb_mut()
+                self.service_helper
+                    .common
                     .verification_handler
                     .get_mut()
                     .start_failure(
-                        token,
+                        ecss_tc_and_token.token,
                         FailParams::new(
                             Some(&time_stamp),
                             &tmtc_err::INVALID_PUS_SUBSERVICE,
@@ -148,12 +142,12 @@ impl PusServiceHandler for PusService8ActionHandler {
 }
 
 pub struct Pus8Wrapper {
-    pub(crate) pus_8_handler: PusService8ActionHandler,
+    pub(crate) pus_8_handler: PusService8ActionHandler<EcssTcInSharedStoreConverter>,
 }
 
 impl Pus8Wrapper {
     pub fn handle_next_packet(&mut self) -> bool {
-        match self.pus_8_handler.handle_next_packet() {
+        match self.pus_8_handler.handle_one_tc() {
             Ok(result) => match result {
                 PusPacketHandlerResult::RequestHandled => {}
                 PusPacketHandlerResult::RequestHandledPartialSuccess(e) => {

satrs-example/src/pus/event.rs

@@ -1,14 +1,14 @@
 use log::{error, warn};
 use satrs_core::pus::event_srv::PusService5EventHandler;
-use satrs_core::pus::{PusPacketHandlerResult, PusServiceHandler};
+use satrs_core::pus::{EcssTcInSharedStoreConverter, PusPacketHandlerResult};
 
 pub struct Pus5Wrapper {
-    pub pus_5_handler: PusService5EventHandler,
+    pub pus_5_handler: PusService5EventHandler<EcssTcInSharedStoreConverter>,
 }
 
 impl Pus5Wrapper {
     pub fn handle_next_packet(&mut self) -> bool {
-        match self.pus_5_handler.handle_next_packet() {
+        match self.pus_5_handler.handle_one_tc() {
             Ok(result) => match result {
                 PusPacketHandlerResult::RequestHandled => {}
                 PusPacketHandlerResult::RequestHandledPartialSuccess(e) => {

satrs-example/src/pus/hk.rs

@@ -1,72 +1,63 @@
 use crate::requests::{Request, RequestWithToken};
 use log::{error, warn};
 use satrs_core::hk::{CollectionIntervalFactor, HkRequest};
-use satrs_core::pool::{SharedPool, StoreAddr};
-use satrs_core::pus::verification::{
-    FailParams, StdVerifReporterWithSender, TcStateAccepted, VerificationToken,
-};
+use satrs_core::pus::verification::{FailParams, StdVerifReporterWithSender};
 use satrs_core::pus::{
-    EcssTcReceiver, EcssTmSender, PusPacketHandlerResult, PusPacketHandlingError, PusServiceBase,
-    PusServiceHandler,
+    EcssTcInMemConverter, EcssTcInSharedStoreConverter, EcssTcReceiver, EcssTmSender,
+    PusPacketHandlerResult, PusPacketHandlingError, PusServiceBase, PusServiceHelper,
 };
-use satrs_core::spacepackets::ecss::tc::PusTcReader;
 use satrs_core::spacepackets::ecss::{hk, PusPacket};
 use satrs_example::{hk_err, tmtc_err, TargetIdWithApid};
 use std::collections::HashMap;
 use std::sync::mpsc::Sender;
 
-pub struct PusService3HkHandler {
-    psb: PusServiceBase,
+pub struct PusService3HkHandler<TcInMemConverter: EcssTcInMemConverter> {
+    psb: PusServiceHelper<TcInMemConverter>,
     request_handlers: HashMap<TargetIdWithApid, Sender<RequestWithToken>>,
 }
 
-impl PusService3HkHandler {
+impl<TcInMemConverter: EcssTcInMemConverter> PusService3HkHandler<TcInMemConverter> {
     pub fn new(
         tc_receiver: Box<dyn EcssTcReceiver>,
-        shared_tc_pool: SharedPool,
         tm_sender: Box<dyn EcssTmSender>,
         tm_apid: u16,
         verification_handler: StdVerifReporterWithSender,
+        tc_in_mem_converter: TcInMemConverter,
         request_handlers: HashMap<TargetIdWithApid, Sender<RequestWithToken>>,
     ) -> Self {
         Self {
-            psb: PusServiceBase::new(
+            psb: PusServiceHelper::new(
                 tc_receiver,
-                shared_tc_pool,
                 tm_sender,
                 tm_apid,
                 verification_handler,
+                tc_in_mem_converter,
             ),
             request_handlers,
         }
     }
-}
 
-impl PusServiceHandler for PusService3HkHandler {
-    fn psb_mut(&mut self) -> &mut PusServiceBase {
-        &mut self.psb
-    }
-    fn psb(&self) -> &PusServiceBase {
-        &self.psb
-    }
-
-    fn handle_one_tc(
-        &mut self,
-        addr: StoreAddr,
-        token: VerificationToken<TcStateAccepted>,
-    ) -> Result<PusPacketHandlerResult, PusPacketHandlingError> {
-        self.copy_tc_to_buf(addr)?;
-        let (tc, _) = PusTcReader::new(&self.psb().pus_buf).unwrap();
+    fn handle_one_tc(&mut self) -> Result<PusPacketHandlerResult, PusPacketHandlingError> {
+        let possible_packet = self.psb.retrieve_and_accept_next_packet()?;
+        if possible_packet.is_none() {
+            return Ok(PusPacketHandlerResult::Empty);
+        }
+        let ecss_tc_and_token = possible_packet.unwrap();
+        let tc = self
+            .psb
+            .tc_in_mem_converter
+            .convert_ecss_tc_in_memory_to_reader(&ecss_tc_and_token.tc_in_memory)?;
         let subservice = tc.subservice();
         let mut partial_error = None;
-        let time_stamp = self.psb().get_current_timestamp(&mut partial_error);
+        let time_stamp = PusServiceBase::get_current_timestamp(&mut partial_error);
         let user_data = tc.user_data();
         if user_data.is_empty() {
             self.psb
+                .common
                 .verification_handler
                 .borrow_mut()
                 .start_failure(
-                    token,
+                    ecss_tc_and_token.token,
                     FailParams::new(Some(&time_stamp), &tmtc_err::NOT_ENOUGH_APP_DATA, None),
                 )
                 .expect("Sending start failure TM failed");
@@ -81,9 +72,13 @@ impl PusServiceHandler for PusService3HkHandler {
                 &hk_err::UNIQUE_ID_MISSING
             };
             self.psb
+                .common
                 .verification_handler
                 .borrow_mut()
-                .start_failure(token, FailParams::new(Some(&time_stamp), err, None))
+                .start_failure(
+                    ecss_tc_and_token.token,
+                    FailParams::new(Some(&time_stamp), err, None),
+                )
                 .expect("Sending start failure TM failed");
             return Err(PusPacketHandlingError::NotEnoughAppData(
                 "Expected at least 8 bytes of app data".into(),
@@ -93,10 +88,11 @@ impl PusServiceHandler for PusService3HkHandler {
         let unique_id = u32::from_be_bytes(tc.user_data()[0..4].try_into().unwrap());
         if !self.request_handlers.contains_key(&target_id) {
             self.psb
+                .common
                 .verification_handler
                 .borrow_mut()
                 .start_failure(
-                    token,
+                    ecss_tc_and_token.token,
                     FailParams::new(Some(&time_stamp), &hk_err::UNKNOWN_TARGET_ID, None),
                 )
                 .expect("Sending start failure TM failed");
@@ -107,7 +103,11 @@ impl PusServiceHandler for PusService3HkHandler {
         let send_request = |target: TargetIdWithApid, request: HkRequest| {
             let sender = self.request_handlers.get(&target).unwrap();
             sender
-                .send(RequestWithToken::new(target, Request::Hk(request), token))
+                .send(RequestWithToken::new(
+                    target,
+                    Request::Hk(request),
+                    ecss_tc_and_token.token,
+                ))
                 .unwrap_or_else(|_| panic!("Sending HK request {request:?} failed"));
         };
         if subservice == hk::Subservice::TcEnableHkGeneration as u8 {
@@ -119,10 +119,11 @@ impl PusServiceHandler for PusService3HkHandler {
         } else if subservice == hk::Subservice::TcModifyHkCollectionInterval as u8 {
             if user_data.len() < 12 {
                 self.psb
+                    .common
                     .verification_handler
                     .borrow_mut()
                     .start_failure(
-                        token,
+                        ecss_tc_and_token.token,
                         FailParams::new(
                             Some(&time_stamp),
                             &hk_err::COLLECTION_INTERVAL_MISSING,
@@ -147,12 +148,12 @@ impl PusServiceHandler for PusService3HkHandler {
 }
 
 pub struct Pus3Wrapper {
-    pub(crate) pus_3_handler: PusService3HkHandler,
+    pub(crate) pus_3_handler: PusService3HkHandler<EcssTcInSharedStoreConverter>,
 }
 
 impl Pus3Wrapper {
     pub fn handle_next_packet(&mut self) -> bool {
-        match self.pus_3_handler.handle_next_packet() {
+        match self.pus_3_handler.handle_one_tc() {
             Ok(result) => match result {
                 PusPacketHandlerResult::RequestHandled => {}
                 PusPacketHandlerResult::RequestHandledPartialSuccess(e) => {

satrs-example/src/pus/mod.rs

@@ -1,8 +1,7 @@
 use crate::tmtc::MpscStoreAndSendError;
 use log::warn;
-use satrs_core::pool::StoreAddr;
 use satrs_core::pus::verification::{FailParams, StdVerifReporterWithSender};
-use satrs_core::pus::{PusPacketHandlerResult, TcAddrWithToken};
+use satrs_core::pus::{EcssTcAndToken, PusPacketHandlerResult, TcInMemory};
 use satrs_core::spacepackets::ecss::tc::PusTcReader;
 use satrs_core::spacepackets::ecss::PusServiceId;
 use satrs_core::spacepackets::time::cds::TimeProvider;
@@ -17,11 +16,11 @@ pub mod scheduler;
 pub mod test;
 
 pub struct PusTcMpscRouter {
-    pub test_service_receiver: Sender<TcAddrWithToken>,
-    pub event_service_receiver: Sender<TcAddrWithToken>,
-    pub sched_service_receiver: Sender<TcAddrWithToken>,
-    pub hk_service_receiver: Sender<TcAddrWithToken>,
-    pub action_service_receiver: Sender<TcAddrWithToken>,
+    pub test_service_receiver: Sender<EcssTcAndToken>,
+    pub event_service_receiver: Sender<EcssTcAndToken>,
+    pub sched_service_receiver: Sender<EcssTcAndToken>,
+    pub hk_service_receiver: Sender<EcssTcAndToken>,
+    pub action_service_receiver: Sender<EcssTcAndToken>,
 }
 
 pub struct PusReceiver {
@@ -70,7 +69,7 @@ impl PusReceiver {
 impl PusReceiver {
     pub fn handle_tc_packet(
         &mut self,
-        store_addr: StoreAddr,
+        tc_in_memory: TcInMemory,
         service: u8,
         pus_tc: &PusTcReader,
     ) -> Result<PusPacketHandlerResult, MpscStoreAndSendError> {
@@ -84,22 +83,33 @@ impl PusReceiver {
         match service {
             Ok(standard_service) => match standard_service {
                 PusServiceId::Test => {
-                    self.pus_router
-                        .test_service_receiver
-                        .send((store_addr, accepted_token.into()))?;
+                    self.pus_router.test_service_receiver.send(EcssTcAndToken {
+                        tc_in_memory,
+                        token: Some(accepted_token.into()),
+                    })?
+                }
+                PusServiceId::Housekeeping => {
+                    self.pus_router.hk_service_receiver.send(EcssTcAndToken {
+                        tc_in_memory,
+                        token: Some(accepted_token.into()),
+                    })?
+                }
+                PusServiceId::Event => {
+                    self.pus_router
+                        .event_service_receiver
+                        .send(EcssTcAndToken {
+                            tc_in_memory,
+                            token: Some(accepted_token.into()),
+                        })?
+                }
+                PusServiceId::Scheduling => {
+                    self.pus_router
+                        .sched_service_receiver
+                        .send(EcssTcAndToken {
+                            tc_in_memory,
+                            token: Some(accepted_token.into()),
+                        })?
                 }
-                PusServiceId::Housekeeping => self
-                    .pus_router
-                    .hk_service_receiver
-                    .send((store_addr, accepted_token.into()))?,
-                PusServiceId::Event => self
-                    .pus_router
-                    .event_service_receiver
-                    .send((store_addr, accepted_token.into()))?,
-                PusServiceId::Scheduling => self
-                    .pus_router
-                    .sched_service_receiver
-                    .send((store_addr, accepted_token.into()))?,
                 _ => {
                     let result = self.verif_reporter.start_failure(
                         accepted_token,

satrs-example/src/pus/scheduler.rs

@@ -1,50 +1,54 @@
 use crate::tmtc::PusTcSource;
 use log::{error, info, warn};
-use satrs_core::pus::scheduler::TcInfo;
+use satrs_core::pool::{PoolProviderMemInPlace, StaticMemoryPool};
+use satrs_core::pus::scheduler::{PusScheduler, TcInfo};
 use satrs_core::pus::scheduler_srv::PusService11SchedHandler;
-use satrs_core::pus::{PusPacketHandlerResult, PusServiceHandler};
+use satrs_core::pus::{EcssTcInSharedStoreConverter, PusPacketHandlerResult};
 
 pub struct Pus11Wrapper {
-    pub pus_11_handler: PusService11SchedHandler,
+    pub pus_11_handler: PusService11SchedHandler<EcssTcInSharedStoreConverter, PusScheduler>,
+    pub sched_tc_pool: StaticMemoryPool,
     pub tc_source_wrapper: PusTcSource,
 }
 
 impl Pus11Wrapper {
     pub fn release_tcs(&mut self) {
-        let releaser = |enabled: bool, info: &TcInfo| -> bool {
+        let releaser = |enabled: bool, _info: &TcInfo, tc: &[u8]| -> bool {
             if enabled {
+                // Transfer TC from scheduler TC pool to shared TC pool.
+                let released_tc_addr = self
+                    .tc_source_wrapper
+                    .tc_store
+                    .pool
+                    .write()
+                    .expect("locking pool failed")
+                    .add(tc)
+                    .expect("adding TC to shared pool failed");
+
                 self.tc_source_wrapper
                     .tc_source
-                    .send(info.addr())
+                    .send(released_tc_addr)
                     .expect("sending TC to TC source failed");
             }
             true
         };
 
-        let mut pool = self
-            .tc_source_wrapper
-            .tc_store
-            .pool
-            .write()
-            .expect("error locking pool");
-
         self.pus_11_handler
             .scheduler_mut()
             .update_time_from_now()
             .unwrap();
-        if let Ok(released_tcs) = self
+        let released_tcs = self
             .pus_11_handler
             .scheduler_mut()
-            .release_telecommands(releaser, pool.as_mut())
-        {
-            if released_tcs > 0 {
-                info!("{released_tcs} TC(s) released from scheduler");
-            }
+            .release_telecommands(releaser, &mut self.sched_tc_pool)
+            .expect("releasing TCs failed");
+        if released_tcs > 0 {
+            info!("{released_tcs} TC(s) released from scheduler");
         }
     }
 
     pub fn handle_next_packet(&mut self) -> bool {
-        match self.pus_11_handler.handle_next_packet() {
+        match self.pus_11_handler.handle_one_tc(&mut self.sched_tc_pool) {
             Ok(result) => match result {
                 PusPacketHandlerResult::RequestHandled => {}
                 PusPacketHandlerResult::RequestHandledPartialSuccess(e) => {

satrs-example/src/pus/test.rs

@@ -1,24 +1,24 @@
 use log::{info, warn};
-use satrs_core::events::EventU32;
 use satrs_core::params::Params;
 use satrs_core::pus::test::PusService17TestHandler;
 use satrs_core::pus::verification::FailParams;
-use satrs_core::pus::{PusPacketHandlerResult, PusServiceHandler};
+use satrs_core::pus::{EcssTcInMemConverter, PusPacketHandlerResult};
 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::{events::EventU32, pus::EcssTcInSharedStoreConverter};
 use satrs_example::{tmtc_err, TEST_EVENT};
 use std::sync::mpsc::Sender;
 
 pub struct Service17CustomWrapper {
-    pub pus17_handler: PusService17TestHandler,
+    pub pus17_handler: PusService17TestHandler<EcssTcInSharedStoreConverter>,
     pub test_srv_event_sender: Sender<(EventU32, Option<Params>)>,
 }
 
 impl Service17CustomWrapper {
     pub fn handle_next_packet(&mut self) -> bool {
-        let res = self.pus17_handler.handle_next_packet();
+        let res = self.pus17_handler.handle_one_tc();
         if res.is_err() {
             warn!("PUS17 handler failed with error {:?}", res.unwrap_err());
             return true;
@@ -38,9 +38,13 @@ impl Service17CustomWrapper {
                 warn!("PUS17: Subservice {subservice} not implemented")
             }
             PusPacketHandlerResult::CustomSubservice(subservice, token) => {
-                let psb_mut = self.pus17_handler.psb_mut();
-                let buf = psb_mut.pus_buf;
-                let (tc, _) = PusTcReader::new(&buf).unwrap();
+                let (tc, _) = PusTcReader::new(
+                    self.pus17_handler
+                        .service_helper
+                        .tc_in_mem_converter
+                        .tc_slice_raw(),
+                )
+                .unwrap();
                 let time_stamper = TimeProvider::from_now_with_u16_days().unwrap();
                 let mut stamp_buf: [u8; 7] = [0; 7];
                 time_stamper.write_to_bytes(&mut stamp_buf).unwrap();
@@ -49,12 +53,17 @@ impl Service17CustomWrapper {
                     self.test_srv_event_sender
                         .send((TEST_EVENT.into(), None))
                         .expect("Sending test event failed");
-                    let start_token = psb_mut
+                    let start_token = self
+                        .pus17_handler
+                        .service_helper
+                        .common
                         .verification_handler
                         .get_mut()
                         .start_success(token, Some(&stamp_buf))
                         .expect("Error sending start success");
-                    psb_mut
+                    self.pus17_handler
+                        .service_helper
+                        .common
                         .verification_handler
                         .get_mut()
                         .completion_success(start_token, Some(&stamp_buf))
@@ -62,7 +71,8 @@ impl Service17CustomWrapper {
                 } else {
                     let fail_data = [tc.subservice()];
                     self.pus17_handler
-                        .psb_mut()
+                        .service_helper
+                        .common
                         .verification_handler
                         .get_mut()
                         .start_failure(

satrs-example/src/tmtc.rs

@@ -1,12 +1,11 @@
 use log::warn;
-use satrs_core::pus::ReceivesEcssPusTc;
+use satrs_core::pus::{EcssTcAndToken, ReceivesEcssPusTc};
 use satrs_core::spacepackets::SpHeader;
 use std::sync::mpsc::{Receiver, SendError, Sender, TryRecvError};
 use thiserror::Error;
 
 use crate::pus::PusReceiver;
-use satrs_core::pool::{SharedPool, StoreAddr, StoreError};
-use satrs_core::pus::TcAddrWithToken;
+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;
@@ -35,14 +34,14 @@ pub enum MpscStoreAndSendError {
     #[error("Store error: {0}")]
     Store(#[from] StoreError),
     #[error("TC send error: {0}")]
-    TcSend(#[from] SendError<TcAddrWithToken>),
+    TcSend(#[from] SendError<EcssTcAndToken>),
     #[error("TMTC send error: {0}")]
     TmTcSend(#[from] SendError<StoreAddr>),
 }
 
 #[derive(Clone)]
 pub struct TcStore {
-    pub pool: SharedPool,
+    pub pool: SharedStaticMemoryPool,
 }
 
 impl TcStore {
@@ -103,7 +102,6 @@ impl TmtcTask {
     }
 
     pub fn periodic_operation(&mut self) {
-        //while self.poll_tc() {}
         self.poll_tc();
     }
 
@@ -123,7 +121,11 @@ impl TmtcTask {
                 match PusTcReader::new(&self.tc_buf) {
                     Ok((pus_tc, _)) => {
                         self.pus_receiver
-                            .handle_tc_packet(addr, pus_tc.service(), &pus_tc)
+                            .handle_tc_packet(
+                                satrs_core::pus::TcInMemory::StoreAddr(addr),
+                                pus_tc.service(),
+                                &pus_tc,
+                            )
                             .ok();
                         true
                     }

satrs-example/src/udp.rs

@@ -3,7 +3,7 @@ use std::{net::SocketAddr, sync::mpsc::Receiver};
 use log::{info, warn};
 use satrs_core::{
     hal::std::udp_server::{ReceiveResult, UdpTcServer},
-    pool::{SharedPool, StoreAddr},
+    pool::{PoolProviderMemInPlaceWithGuards, SharedStaticMemoryPool, StoreAddr},
     tmtc::CcsdsError,
 };
 
@@ -12,7 +12,7 @@ use crate::tmtc::MpscStoreAndSendError;
 pub struct UdpTmtcServer {
     pub udp_tc_server: UdpTcServer<CcsdsError<MpscStoreAndSendError>>,
     pub tm_rx: Receiver<StoreAddr>,
-    pub tm_store: SharedPool,
+    pub tm_store: SharedStaticMemoryPool,
 }
 impl UdpTmtcServer {
     pub fn periodic_operation(&mut self) {