refactored PUS handlers

satrs-core/src/pus/event_srv.rs

@@ -1,12 +1,10 @@
 use crate::events::EventU32;
-use crate::pool::{SharedPool, StoreAddr};
+use crate::pool::SharedPool;
 use crate::pus::event_man::{EventRequest, EventRequestWithToken};
-use crate::pus::verification::{
-    StdVerifReporterWithSender, TcStateAccepted, TcStateToken, VerificationToken,
-};
+use crate::pus::verification::{StdVerifReporterWithSender, TcStateToken};
 use crate::pus::{
     EcssTcReceiver, EcssTmSender, PartialPusHandlingError, PusPacketHandlerResult,
-    PusPacketHandlingError, PusServiceBase, PusServiceHandler,
+    PusPacketHandlingError, PusServiceBaseWithStore,
 };
 use alloc::boxed::Box;
 use spacepackets::ecss::event::Subservice;
@@ -15,7 +13,7 @@ use spacepackets::ecss::PusPacket;
 use std::sync::mpsc::Sender;
 
 pub struct PusService5EventHandler {
-    psb: PusServiceBase,
+    psb: PusServiceBaseWithStore,
     event_request_tx: Sender<EventRequestWithToken>,
 }
 
@@ -29,7 +27,7 @@ impl PusService5EventHandler {
         event_request_tx: Sender<EventRequestWithToken>,
     ) -> Self {
         Self {
-            psb: PusServiceBase::new(
+            psb: PusServiceBaseWithStore::new(
                 tc_receiver,
                 shared_tc_store,
                 tm_sender,
@@ -39,22 +37,14 @@ impl PusService5EventHandler {
             event_request_tx,
         }
     }
-}
 
-impl PusServiceHandler for PusService5EventHandler {
-    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)?;
+    pub fn handle_one_tc(&mut self) -> Result<PusPacketHandlerResult, PusPacketHandlingError> {
+        let possible_packet = self.psb.retrieve_next_packet()?;
+        if possible_packet.is_none() {
+            return Ok(PusPacketHandlerResult::Empty);
+        }
+        let (addr, token) = possible_packet.unwrap();
+        self.psb.copy_tc_to_buf(addr)?;
         let (tc, _) = PusTcReader::new(&self.psb.pus_buf)?;
         let subservice = tc.subservice();
         let srv = Subservice::try_from(subservice);
@@ -107,7 +97,7 @@ impl PusServiceHandler for PusService5EventHandler {
             Ok(PusPacketHandlerResult::RequestHandled)
         };
         let mut partial_error = None;
-        let time_stamp = self.psb().get_current_timestamp(&mut partial_error);
+        let time_stamp = self.psb.get_current_timestamp(&mut partial_error);
         match srv.unwrap() {
             Subservice::TmInfoReport
             | Subservice::TmLowSeverityReport

satrs-core/src/pus/mod.rs

@@ -637,7 +637,7 @@ pub mod std_mod {
     /// Base class for handlers which can handle PUS TC packets. Right now, the verification
     /// reporter is constrained to the [StdVerifReporterWithSender] and the service handler
     /// relies on TMTC packets being exchanged via a [SharedPool].
-    pub struct PusServiceBase {
+    pub struct PusServiceBaseWithStore {
         pub tc_receiver: Box<dyn EcssTcReceiver>,
         pub shared_tc_store: SharedPool,
         pub tm_sender: Box<dyn EcssTmSender>,
@@ -649,7 +649,7 @@ pub mod std_mod {
         pub pus_size: usize,
     }
 
-    impl PusServiceBase {
+    impl PusServiceBaseWithStore {
         pub fn new(
             tc_receiver: Box<dyn EcssTcReceiver>,
             shared_tc_store: SharedPool,
@@ -688,32 +688,24 @@ pub mod std_mod {
             let mut dummy = None;
             self.get_current_timestamp(&mut dummy)
         }
-    }
 
-    pub trait PusServiceHandler {
-        fn psb_mut(&mut self) -> &mut PusServiceBase;
-        fn psb(&self) -> &PusServiceBase;
-        fn handle_one_tc(
-            &mut self,
-            addr: StoreAddr,
-            token: VerificationToken<TcStateAccepted>,
-        ) -> Result<PusPacketHandlerResult, PusPacketHandlingError>;
-
-        fn copy_tc_to_buf(&mut self, addr: StoreAddr) -> Result<(), PusPacketHandlingError> {
+        pub fn copy_tc_to_buf(&mut self, addr: StoreAddr) -> Result<(), PusPacketHandlingError> {
             // Keep locked section as short as possible.
-            let psb_mut = self.psb_mut();
-            let mut tc_pool = psb_mut
+            let mut tc_pool = self
                 .shared_tc_store
                 .write()
                 .map_err(|_| PusPacketHandlingError::EcssTmtc(EcssTmtcError::StoreLock))?;
             let tc_guard = tc_pool.read_with_guard(addr);
             let tc_raw = tc_guard.read().unwrap();
-            psb_mut.pus_buf[0..tc_raw.len()].copy_from_slice(tc_raw);
+            self.pus_buf[0..tc_raw.len()].copy_from_slice(tc_raw);
             Ok(())
         }
 
-        fn handle_next_packet(&mut self) -> Result<PusPacketHandlerResult, PusPacketHandlingError> {
-            match self.psb().tc_receiver.recv_tc() {
+        pub fn retrieve_next_packet(
+            &mut self,
+        ) -> Result<Option<(StoreAddr, VerificationToken<TcStateAccepted>)>, PusPacketHandlingError>
+        {
+            match self.tc_receiver.recv_tc() {
                 Ok(ReceivedTcWrapper { store_addr, token }) => {
                     if token.is_none() {
                         return Err(PusPacketHandlingError::InvalidVerificationToken);
@@ -721,11 +713,11 @@ pub mod std_mod {
                     let token = token.unwrap();
                     let accepted_token = VerificationToken::<TcStateAccepted>::try_from(token)
                         .map_err(|_| PusPacketHandlingError::InvalidVerificationToken)?;
-                    self.handle_one_tc(store_addr, accepted_token)
+                    Ok(Some((store_addr, accepted_token)))
                 }
                 Err(e) => match e {
                     TryRecvTmtcError::Error(e) => Err(PusPacketHandlingError::EcssTmtc(e)),
-                    TryRecvTmtcError::Empty => Ok(PusPacketHandlerResult::Empty),
+                    TryRecvTmtcError::Empty => Ok(None),
                 },
             }
         }

satrs-core/src/pus/scheduler_srv.rs

@@ -1,9 +1,9 @@
-use crate::pool::{SharedPool, StoreAddr};
+use crate::pool::SharedPool;
 use crate::pus::scheduler::PusScheduler;
-use crate::pus::verification::{StdVerifReporterWithSender, TcStateAccepted, VerificationToken};
+use crate::pus::verification::StdVerifReporterWithSender;
 use crate::pus::{
-    EcssTcReceiver, EcssTmSender, PusPacketHandlerResult, PusPacketHandlingError, PusServiceBase,
-    PusServiceHandler,
+    EcssTcReceiver, EcssTmSender, PusPacketHandlerResult, PusPacketHandlingError,
+    PusServiceBaseWithStore,
 };
 use spacepackets::ecss::tc::PusTcReader;
 use spacepackets::ecss::{scheduling, PusPacket};
@@ -19,7 +19,7 @@ use std::boxed::Box;
 /// [Self::scheduler] and [Self::scheduler_mut] function and then use the scheduler API to release
 /// telecommands when applicable.
 pub struct PusService11SchedHandler {
-    psb: PusServiceBase,
+    psb: PusServiceBaseWithStore,
     scheduler: PusScheduler,
 }
 
@@ -33,7 +33,7 @@ impl PusService11SchedHandler {
         scheduler: PusScheduler,
     ) -> Self {
         Self {
-            psb: PusServiceBase::new(
+            psb: PusServiceBaseWithStore::new(
                 tc_receiver,
                 shared_tc_store,
                 tm_sender,
@@ -51,22 +51,14 @@ impl PusService11SchedHandler {
     pub fn scheduler(&self) -> &PusScheduler {
         &self.scheduler
     }
-}
 
-impl PusServiceHandler for PusService11SchedHandler {
-    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)?;
+    pub fn handle_one_tc(&mut self) -> Result<PusPacketHandlerResult, PusPacketHandlingError> {
+        let possible_packet = self.psb.retrieve_next_packet()?;
+        if possible_packet.is_none() {
+            return Ok(PusPacketHandlerResult::Empty);
+        }
+        let (addr, token) = possible_packet.unwrap();
+        self.psb.copy_tc_to_buf(addr)?;
         let (tc, _) = PusTcReader::new(&self.psb.pus_buf)?;
         let subservice = tc.subservice();
         let std_service = scheduling::Subservice::try_from(subservice);
@@ -77,7 +69,7 @@ impl PusServiceHandler for PusService11SchedHandler {
             ));
         }
         let mut partial_error = None;
-        let time_stamp = self.psb().get_current_timestamp(&mut partial_error);
+        let time_stamp = self.psb.get_current_timestamp(&mut partial_error);
         match std_service.unwrap() {
             scheduling::Subservice::TcEnableScheduling => {
                 let start_token = self

satrs-core/src/pus/test.rs

@@ -1,8 +1,8 @@
-use crate::pool::{SharedPool, StoreAddr};
-use crate::pus::verification::{StdVerifReporterWithSender, TcStateAccepted, VerificationToken};
+use crate::pool::SharedPool;
+use crate::pus::verification::StdVerifReporterWithSender;
 use crate::pus::{
     EcssTcReceiver, EcssTmSender, PartialPusHandlingError, PusPacketHandlerResult,
-    PusPacketHandlingError, PusServiceBase, PusServiceHandler, PusTmWrapper,
+    PusPacketHandlingError, PusServiceBaseWithStore, PusTmWrapper,
 };
 use spacepackets::ecss::tc::PusTcReader;
 use spacepackets::ecss::tm::{PusTmCreator, PusTmSecondaryHeader};
@@ -13,7 +13,7 @@ use std::boxed::Box;
 /// This is a helper class for [std] environments to handle generic PUS 17 (test service) packets.
 /// This handler only processes ping requests and generates a ping reply for them accordingly.
 pub struct PusService17TestHandler {
-    psb: PusServiceBase,
+    pub psb: PusServiceBaseWithStore,
 }
 
 impl PusService17TestHandler {
@@ -25,7 +25,7 @@ impl PusService17TestHandler {
         verification_handler: StdVerifReporterWithSender,
     ) -> Self {
         Self {
-            psb: PusServiceBase::new(
+            psb: PusServiceBaseWithStore::new(
                 tc_receiver,
                 shared_tc_store,
                 tm_sender,
@@ -34,29 +34,21 @@ impl PusService17TestHandler {
             ),
         }
     }
-}
 
-impl PusServiceHandler for PusService17TestHandler {
-    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)?;
+    pub fn handle_one_tc(&mut self) -> Result<PusPacketHandlerResult, PusPacketHandlingError> {
+        let possible_packet = self.psb.retrieve_next_packet()?;
+        if possible_packet.is_none() {
+            return Ok(PusPacketHandlerResult::Empty);
+        }
+        let (addr, token) = possible_packet.unwrap();
+        self.psb.copy_tc_to_buf(addr)?;
         let (tc, _) = PusTcReader::new(&self.psb.pus_buf)?;
         if tc.service() != 17 {
             return Err(PusPacketHandlingError::WrongService(tc.service()));
         }
         if tc.subservice() == 1 {
             let mut partial_error = None;
-            let time_stamp = self.psb().get_current_timestamp(&mut partial_error);
+            let time_stamp = self.psb.get_current_timestamp(&mut partial_error);
             let result = self
                 .psb
                 .verification_handler
@@ -114,7 +106,7 @@ mod tests {
     use crate::pus::verification::{
         RequestId, StdVerifReporterWithSender, VerificationReporterCfg,
     };
-    use crate::pus::{MpscTcInStoreReceiver, MpscTmInStoreSender, PusServiceHandler};
+    use crate::pus::{MpscTcInStoreReceiver, MpscTmInStoreSender};
     use crate::tmtc::tm_helper::SharedTmStore;
     use spacepackets::ecss::tc::{PusTcCreator, PusTcSecondaryHeader};
     use spacepackets::ecss::tm::PusTmReader;
@@ -165,7 +157,7 @@ mod tests {
         drop(tc_pool);
         // Send accepted TC to test service handler.
         test_srv_tc_tx.send((addr, token.into())).unwrap();
-        let result = pus_17_handler.handle_next_packet();
+        let result = pus_17_handler.handle_one_tc();
         assert!(result.is_ok());
         // We should see 4 replies in the TM queue now: Acceptance TM, Start TM, ping reply and
         // Completion TM
@@ -174,7 +166,7 @@ mod tests {
         let mut tm_addr = next_msg.unwrap();
         let tm_pool = tm_pool_shared.read().unwrap();
         let tm_raw = tm_pool.read(&tm_addr).unwrap();
-        let (tm, _) = PusTmReader::new(&tm_raw, 0).unwrap();
+        let (tm, _) = PusTmReader::new(tm_raw, 0).unwrap();
         assert_eq!(tm.service(), 1);
         assert_eq!(tm.subservice(), 1);
         let req_id = RequestId::from_bytes(tm.user_data()).expect("generating request ID failed");
@@ -186,7 +178,7 @@ mod tests {
         tm_addr = next_msg.unwrap();
         let tm_raw = tm_pool.read(&tm_addr).unwrap();
         // Is generated with CDS short timestamp.
-        let (tm, _) = PusTmReader::new(&tm_raw, 7).unwrap();
+        let (tm, _) = PusTmReader::new(tm_raw, 7).unwrap();
         assert_eq!(tm.service(), 1);
         assert_eq!(tm.subservice(), 3);
         let req_id = RequestId::from_bytes(tm.user_data()).expect("generating request ID failed");
@@ -198,7 +190,7 @@ mod tests {
         tm_addr = next_msg.unwrap();
         let tm_raw = tm_pool.read(&tm_addr).unwrap();
         // Is generated with CDS short timestamp.
-        let (tm, _) = PusTmReader::new(&tm_raw, 7).unwrap();
+        let (tm, _) = PusTmReader::new(tm_raw, 7).unwrap();
         assert_eq!(tm.service(), 17);
         assert_eq!(tm.subservice(), 2);
         assert!(tm.user_data().is_empty());
@@ -209,7 +201,7 @@ mod tests {
         tm_addr = next_msg.unwrap();
         let tm_raw = tm_pool.read(&tm_addr).unwrap();
         // Is generated with CDS short timestamp.
-        let (tm, _) = PusTmReader::new(&tm_raw, 7).unwrap();
+        let (tm, _) = PusTmReader::new(tm_raw, 7).unwrap();
         assert_eq!(tm.service(), 1);
         assert_eq!(tm.subservice(), 7);
         let req_id = RequestId::from_bytes(tm.user_data()).expect("generating request ID failed");

satrs-example/src/pus/action.rs

@@ -1,12 +1,12 @@
 use crate::requests::{ActionRequest, Request, RequestWithToken};
 use log::{error, warn};
-use satrs_core::pool::{SharedPool, StoreAddr};
+use satrs_core::pool::SharedPool;
 use satrs_core::pus::verification::{
     FailParams, StdVerifReporterWithSender, TcStateAccepted, VerificationToken,
 };
 use satrs_core::pus::{
-    EcssTcReceiver, EcssTmSender, PusPacketHandlerResult, PusPacketHandlingError, PusServiceBase,
-    PusServiceHandler,
+    EcssTcReceiver, EcssTmSender, PusPacketHandlerResult, PusPacketHandlingError,
+    PusServiceBaseWithStore,
 };
 use satrs_core::spacepackets::ecss::tc::PusTcReader;
 use satrs_core::spacepackets::ecss::PusPacket;
@@ -16,7 +16,7 @@ use std::collections::HashMap;
 use std::sync::mpsc::Sender;
 
 pub struct PusService8ActionHandler {
-    psb: PusServiceBase,
+    psb: PusServiceBaseWithStore,
     request_handlers: HashMap<TargetId, Sender<RequestWithToken>>,
 }
 
@@ -30,7 +30,7 @@ impl PusService8ActionHandler {
         request_handlers: HashMap<TargetId, Sender<RequestWithToken>>,
     ) -> Self {
         Self {
-            psb: PusServiceBase::new(
+            psb: PusServiceBaseWithStore::new(
                 tc_receiver,
                 shared_tc_pool,
                 tm_sender,
@@ -51,7 +51,7 @@ impl PusService8ActionHandler {
     ) -> Result<(), PusPacketHandlingError> {
         let user_data = tc.user_data();
         if user_data.len() < 8 {
-            self.psb()
+            self.psb
                 .verification_handler
                 .borrow_mut()
                 .start_failure(
@@ -79,7 +79,7 @@ impl PusService8ActionHandler {
         } else {
             let mut fail_data: [u8; 4] = [0; 4];
             fail_data.copy_from_slice(&target_id.to_be_bytes());
-            self.psb()
+            self.psb
                 .verification_handler
                 .borrow_mut()
                 .start_failure(
@@ -97,33 +97,25 @@ 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.psb.retrieve_next_packet()?;
+        if possible_packet.is_none() {
+            return Ok(PusPacketHandlerResult::Empty);
+        }
+        let (addr, token) = possible_packet.unwrap();
+        self.psb.copy_tc_to_buf(addr)?;
+        let (tc, _) = PusTcReader::new(&self.psb.pus_buf).unwrap();
         let subservice = tc.subservice();
         let mut partial_error = None;
-        let time_stamp = self.psb().get_current_timestamp(&mut partial_error);
+        let time_stamp = self.psb.get_current_timestamp(&mut partial_error);
         match subservice {
             128 => {
                 self.handle_action_request_with_id(token, &tc, &time_stamp)?;
             }
             _ => {
                 let fail_data = [subservice];
-                self.psb_mut()
+                self.psb
                     .verification_handler
                     .get_mut()
                     .start_failure(
@@ -153,7 +145,7 @@ pub struct Pus8Wrapper {
 
 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,6 +1,6 @@
 use log::{error, warn};
 use satrs_core::pus::event_srv::PusService5EventHandler;
-use satrs_core::pus::{PusPacketHandlerResult, PusServiceHandler};
+use satrs_core::pus::PusPacketHandlerResult;
 
 pub struct Pus5Wrapper {
     pub pus_5_handler: PusService5EventHandler,
@@ -8,7 +8,7 @@ pub struct Pus5Wrapper {
 
 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,13 +1,11 @@
 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::pool::SharedPool;
+use satrs_core::pus::verification::{FailParams, StdVerifReporterWithSender};
 use satrs_core::pus::{
-    EcssTcReceiver, EcssTmSender, PusPacketHandlerResult, PusPacketHandlingError, PusServiceBase,
-    PusServiceHandler,
+    EcssTcReceiver, EcssTmSender, PusPacketHandlerResult, PusPacketHandlingError,
+    PusServiceBaseWithStore,
 };
 use satrs_core::spacepackets::ecss::tc::PusTcReader;
 use satrs_core::spacepackets::ecss::{hk, PusPacket};
@@ -17,7 +15,7 @@ use std::collections::HashMap;
 use std::sync::mpsc::Sender;
 
 pub struct PusService3HkHandler {
-    psb: PusServiceBase,
+    psb: PusServiceBaseWithStore,
     request_handlers: HashMap<TargetId, Sender<RequestWithToken>>,
 }
 
@@ -31,7 +29,7 @@ impl PusService3HkHandler {
         request_handlers: HashMap<TargetId, Sender<RequestWithToken>>,
     ) -> Self {
         Self {
-            psb: PusServiceBase::new(
+            psb: PusServiceBaseWithStore::new(
                 tc_receiver,
                 shared_tc_pool,
                 tm_sender,
@@ -41,26 +39,18 @@ impl PusService3HkHandler {
             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_next_packet()?;
+        if possible_packet.is_none() {
+            return Ok(PusPacketHandlerResult::Empty);
+        }
+        let (addr, token) = possible_packet.unwrap();
+        self.psb.copy_tc_to_buf(addr)?;
+        let (tc, _) = PusTcReader::new(&self.psb.pus_buf).unwrap();
         let subservice = tc.subservice();
         let mut partial_error = None;
-        let time_stamp = self.psb().get_current_timestamp(&mut partial_error);
+        let time_stamp = self.psb.get_current_timestamp(&mut partial_error);
         let user_data = tc.user_data();
         if user_data.is_empty() {
             self.psb
@@ -168,7 +158,7 @@ pub struct Pus3Wrapper {
 
 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/scheduler.rs

@@ -2,7 +2,7 @@ use crate::tmtc::PusTcSource;
 use log::{error, info, warn};
 use satrs_core::pus::scheduler::TcInfo;
 use satrs_core::pus::scheduler_srv::PusService11SchedHandler;
-use satrs_core::pus::{PusPacketHandlerResult, PusServiceHandler};
+use satrs_core::pus::PusPacketHandlerResult;
 
 pub struct Pus11Wrapper {
     pub pus_11_handler: PusService11SchedHandler,
@@ -44,7 +44,7 @@ impl Pus11Wrapper {
     }
 
     pub fn handle_next_packet(&mut self) -> bool {
-        match self.pus_11_handler.handle_next_packet() {
+        match self.pus_11_handler.handle_one_tc() {
             Ok(result) => match result {
                 PusPacketHandlerResult::RequestHandled => {}
                 PusPacketHandlerResult::RequestHandledPartialSuccess(e) => {

satrs-example/src/pus/test.rs

@@ -3,7 +3,7 @@ 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::PusPacketHandlerResult;
 use satrs_core::spacepackets::ecss::tc::PusTcReader;
 use satrs_core::spacepackets::ecss::PusPacket;
 use satrs_core::spacepackets::time::cds::TimeProvider;
@@ -18,7 +18,7 @@ pub struct Service17CustomWrapper {
 
 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,7 +38,7 @@ impl Service17CustomWrapper {
                 warn!("PUS17: Subservice {subservice} not implemented")
             }
             PusPacketHandlerResult::CustomSubservice(subservice, token) => {
-                let psb_mut = self.pus17_handler.psb_mut();
+                let psb_mut = &mut self.pus17_handler.psb;
                 let buf = psb_mut.pus_buf;
                 let (tc, _) = PusTcReader::new(&buf).unwrap();
                 let time_stamper = TimeProvider::from_now_with_u16_days().unwrap();
@@ -62,7 +62,7 @@ impl Service17CustomWrapper {
                 } else {
                     let fail_data = [tc.subservice()];
                     self.pus17_handler
-                        .psb_mut()
+                        .psb
                         .verification_handler
                         .get_mut()
                         .start_failure(