this works!

satrs-example/src/main.rs

@@ -89,7 +89,7 @@ fn main() {
     let tc_store = TcStore {
         pool: Arc::new(RwLock::new(tc_pool)),
     };
-    let tc_sched_pool = StaticMemoryPool::new(StaticPoolConfig::new(vec![
+    let sched_tc_pool = StaticMemoryPool::new(StaticPoolConfig::new(vec![
         (30, 32),
         (15, 64),
         (15, 128),
@@ -220,11 +220,11 @@ fn main() {
             verif_reporter.clone(),
             EcssTcInSharedStoreConverter::new(tc_store.pool.clone(), 2048),
         ),
-        tc_sched_pool,
         scheduler,
     );
     let mut pus_11_wrapper = Pus11Wrapper {
         pus_11_handler,
+        sched_tc_pool,
         tc_source_wrapper,
     };
 

satrs-example/src/pus/scheduler.rs

@@ -1,30 +1,30 @@
 use crate::tmtc::PusTcSource;
 use log::{error, info, warn};
 use satrs_core::pool::{PoolProviderMemInPlace, StaticMemoryPool};
-use satrs_core::pus::scheduler::{PusScheduler, PusSchedulerInterface, TcInfo};
+use satrs_core::pus::scheduler::{PusScheduler, TcInfo};
 use satrs_core::pus::scheduler_srv::PusService11SchedHandler;
 use satrs_core::pus::{EcssTcInSharedStoreConverter, PusPacketHandlerResult};
 
 pub struct Pus11Wrapper {
-    pub pus_11_handler:
-        PusService11SchedHandler<EcssTcInSharedStoreConverter, StaticMemoryPool, PusScheduler>,
+    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, tc: &[u8]| -> bool {
-            // 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");
-
             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(released_tc_addr)
@@ -37,40 +37,18 @@ impl Pus11Wrapper {
             .scheduler_mut()
             .update_time_from_now()
             .unwrap();
-        let sched_is_enabled = self.pus_11_handler.scheduler().is_enabled();
-
-        // We have to implement some boilerplate ourself, because the borrow checker falls over
-        // multiple borrows of the same object.
-        let tcs_to_release = self.pus_11_handler.scheduler().telecommands_to_release();
-        let mut released_tcs = 0;
-        let mut tcs_to_delete = Vec::new();
-        for tc in tcs_to_release {
-            for info in tc.1 {
-                let tc = self
-                    .pus_11_handler
-                    .sched_tc_pool
-                    .read(&info.addr())
-                    .expect("reading pool failed");
-                let should_delete = releaser(sched_is_enabled, info, tc);
-                released_tcs += 1;
-                if should_delete && !sched_is_enabled {
-                    tcs_to_delete.push(info.addr());
-                }
-            }
-        }
-        for addr in tcs_to_delete {
-            self.pus_11_handler
-                .sched_tc_pool
-                .delete(addr)
-                .expect("deleting TC from pool failed");
-        }
+        let released_tcs = self
+            .pus_11_handler
+            .scheduler_mut()
+            .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_one_tc() {
+        match self.pus_11_handler.handle_one_tc(&mut self.sched_tc_pool) {
             Ok(result) => match result {
                 PusPacketHandlerResult::RequestHandled => {}
                 PusPacketHandlerResult::RequestHandledPartialSuccess(e) => {