start new CCSDS scheduler

2025-10-20 12:06:18 +02:00
parent 06e713a557
commit d7b8a8c1d1
6 changed files with 226 additions and 132 deletions
--- a/satrs-example/src/pus/scheduler.rs
+++ b/satrs-example/src/pus/scheduler.rs
@@ -5,7 +5,7 @@ use crate::pus::create_verification_reporter;
 use crate::tmtc::sender::TmTcSender;
 use log::info;
 use satrs::pool::{PoolProvider, StaticMemoryPool};
-use satrs::pus::scheduler::{PusScheduler, TcInfo};
+use satrs::pus::scheduler::{PusSchedulerAlloc, TcInfo};
 use satrs::pus::scheduler_srv::PusSchedServiceHandler;
 use satrs::pus::verification::VerificationReporter;
 use satrs::pus::{
@@ -86,7 +86,7 @@ pub struct SchedulingServiceWrapper {
        TmTcSender,
        EcssTcCacher,
        VerificationReporter,
-        PusScheduler,
+        PusSchedulerAlloc,
    >,
    pub sched_tc_pool: StaticMemoryPool,
    pub releaser_buf: [u8; 4096],
@@ -179,7 +179,7 @@ pub fn create_scheduler_service(
    pus_sched_rx: mpsc::Receiver<EcssTcAndToken>,
    sched_tc_pool: StaticMemoryPool,
 ) -> SchedulingServiceWrapper {
-    let scheduler = PusScheduler::new_with_current_init_time(Duration::from_secs(5))
+    let scheduler = PusSchedulerAlloc::new_with_current_init_time(Duration::from_secs(5))
        .expect("Creating PUS Scheduler failed");
    let pus_11_handler = PusSchedServiceHandler::new(
        PusServiceHelper::new(
--- a/satrs/src/ccsds/mod.rs
+++ b/satrs/src/ccsds/mod.rs
@@ -0,0 +1 @@
+pub mod scheduler;
--- a/satrs/src/ccsds/scheduler.rs
+++ b/satrs/src/ccsds/scheduler.rs
@@ -0,0 +1,129 @@
+use core::{hash::Hash, time::Duration};
+
+#[cfg(feature = "alloc")]
+pub use alloc_mod::*;
+use spacepackets::{
+    ByteConversionError, PacketId, PacketSequenceControl,
+    time::{TimestampError, UnixTime},
+};
+
+#[derive(Debug, Clone, PartialEq, Eq, thiserror::Error)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
+pub enum ScheduleError {
+    /// The release time is within the time-margin added on top of the current time.
+    /// The first parameter is the current time, the second one the time margin, and the third one
+    /// the release time.
+    #[error("release time in margin")]
+    ReleaseTimeInTimeMargin {
+        current_time: UnixTime,
+        time_margin: Duration,
+        release_time: UnixTime,
+    },
+    /// Nested time-tagged commands are not allowed.
+    #[error("nested scheduled tc")]
+    NestedScheduledTc,
+    #[error("tc data empty")]
+    TcDataEmpty,
+    #[error("timestamp error: {0}")]
+    TimestampError(#[from] TimestampError),
+    #[error("wrong subservice number {0}")]
+    WrongSubservice(u8),
+    #[error("wrong service number {0}")]
+    WrongService(u8),
+    #[error("byte conversion error: {0}")]
+    ByteConversionError(#[from] ByteConversionError),
+}
+
+#[derive(Debug, PartialEq, Eq, Clone)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
+pub struct CcsdsPacketId {
+    pub packet_id: PacketId,
+    pub psc: PacketSequenceControl,
+    pub crc16: u16,
+}
+
+impl Hash for CcsdsPacketId {
+    fn hash<H: core::hash::Hasher>(&self, state: &mut H) {
+        self.packet_id.hash(state);
+        self.psc.raw().hash(state);
+        self.crc16.hash(state);
+    }
+}
+
+pub mod alloc_mod {
+    use core::time::Duration;
+    #[cfg(feature = "std")]
+    use std::time::SystemTimeError;
+
+    use spacepackets::time::UnixTime;
+
+    use crate::ccsds::scheduler::CcsdsPacketId;
+
+    pub struct CcsdsScheduler {
+        tc_map: alloc::collections::BTreeMap<
+            UnixTime,
+            alloc::vec::Vec<(CcsdsPacketId, alloc::vec::Vec<u8>)>,
+        >,
+        packet_limit: usize,
+        pub(crate) current_time: UnixTime,
+        time_margin: Duration,
+        enabled: bool,
+    }
+
+    impl CcsdsScheduler {
+        pub fn new(current_time: UnixTime, packet_limit: usize, time_margin: Duration) -> Self {
+            Self {
+                tc_map: alloc::collections::BTreeMap::new(),
+                packet_limit,
+                current_time,
+                time_margin,
+                enabled: true,
+            }
+        }
+
+        /// Like [Self::new], but sets the `init_current_time` parameter to the current system time.
+        #[cfg(feature = "std")]
+        pub fn new_with_current_init_time(
+            packet_limit: usize,
+            time_margin: Duration,
+        ) -> Result<Self, SystemTimeError> {
+            Ok(Self::new(UnixTime::now()?, packet_limit, time_margin))
+        }
+
+        pub fn num_of_entries(&self) -> usize {
+            self.tc_map
+                .values()
+                .map(|v| v.iter().map(|(_, v)| v.len()).sum::<usize>())
+                .sum()
+        }
+
+        #[inline]
+        pub fn enable(&mut self) {
+            self.enabled = true;
+        }
+
+        #[inline]
+        pub fn disable(&mut self) {
+            self.enabled = false;
+        }
+
+        #[inline]
+        pub fn update_time(&mut self, current_time: UnixTime) {
+            self.current_time = current_time;
+        }
+
+        #[inline]
+        pub fn current_time(&self) -> &UnixTime {
+            &self.current_time
+        }
+
+        // TODO: Implementation
+        pub fn insert_telecommand(
+            &mut self,
+            packet_id: CcsdsPacketId,
+            packet: alloc::vec::Vec<u8>,
+            release_time: UnixTime,
+        ) {
+        }
+    }
+}
--- a/satrs/src/lib.rs
+++ b/satrs/src/lib.rs
@@ -51,6 +51,7 @@ pub mod scheduling;
 pub mod subsystem;
 pub mod time;
 pub mod tmtc;
+pub mod ccsds;

 pub use spacepackets;

--- a/satrs/src/pus/scheduler.rs
+++ b/satrs/src/pus/scheduler.rs
@@ -3,7 +3,7 @@
 //! The core data structure of this module is the [PusScheduler]. This structure can be used
 //! to perform the scheduling of telecommands like specified in the ECSS standard.
 use arbitrary_int::{u11, u14};
-use core::fmt::{Debug, Display, Formatter};
+use core::fmt::Debug;
 use core::time::Duration;
 #[cfg(feature = "serde")]
 use serde::{Deserialize, Serialize};
@@ -12,8 +12,6 @@ use spacepackets::ecss::tc::{GenericPusTcSecondaryHeader, IsPusTelecommand, PusT
 use spacepackets::ecss::{PusError, PusPacket, WritablePusPacket};
 use spacepackets::time::{CcsdsTimeProvider, TimeReader, TimeWriter, TimestampError, UnixTime};
 use spacepackets::{ByteConversionError, CcsdsPacket};
-#[cfg(feature = "std")]
-use std::error::Error;

 use crate::pool::{PoolError, PoolProvider};
 #[cfg(feature = "alloc")]
@@ -144,107 +142,39 @@ impl<TimeProvider: CcsdsTimeProvider + Clone> TimeWindow<TimeProvider> {
    }
 }

-#[derive(Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq, thiserror::Error)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 pub enum ScheduleError {
-    PusError(PusError),
+    #[error("pus error: {0}")]
+    PusError(#[from] PusError),
    /// The release time is within the time-margin added on top of the current time.
    /// The first parameter is the current time, the second one the time margin, and the third one
    /// the release time.
+    #[error("release time in margin")]
    ReleaseTimeInTimeMargin {
        current_time: UnixTime,
        time_margin: Duration,
        release_time: UnixTime,
    },
    /// Nested time-tagged commands are not allowed.
+    #[error("nested scheduled tc")]
    NestedScheduledTc,
-    StoreError(PoolError),
+    #[error("store error")]
+    Pool(#[from] PoolError),
+    #[error("tc data empty")]
    TcDataEmpty,
-    TimestampError(TimestampError),
+    #[error("timestamp error: {0}")]
+    TimestampError(#[from] TimestampError),
+    #[error("wrong subservice number {0}")]
    WrongSubservice(u8),
+    #[error("wrong service number {0}")]
    WrongService(u8),
-    ByteConversionError(ByteConversionError),
-}
-
-impl Display for ScheduleError {
-    fn fmt(&self, f: &mut Formatter<'_>) -> core::fmt::Result {
-        match self {
-            ScheduleError::PusError(e) => {
-                write!(f, "Pus Error: {e}")
-            }
-            ScheduleError::ReleaseTimeInTimeMargin {
-                current_time,
-                time_margin,
-                release_time,
-            } => {
-                write!(
-                    f,
-                    "time margin too short, current time: {current_time:?}, time margin: {time_margin:?}, release time: {release_time:?}"
-                )
-            }
-            ScheduleError::NestedScheduledTc => {
-                write!(f, "nested scheduling is not allowed")
-            }
-            ScheduleError::StoreError(e) => {
-                write!(f, "pus scheduling: {e}")
-            }
-            ScheduleError::TcDataEmpty => {
-                write!(f, "empty TC data field")
-            }
-            ScheduleError::TimestampError(e) => {
-                write!(f, "pus scheduling: {e}")
-            }
-            ScheduleError::WrongService(srv) => {
-                write!(f, "pus scheduling: wrong service number {srv}")
-            }
-            ScheduleError::WrongSubservice(subsrv) => {
-                write!(f, "pus scheduling: wrong subservice number {subsrv}")
-            }
-            ScheduleError::ByteConversionError(e) => {
-                write!(f, "pus scheduling: {e}")
-            }
-        }
-    }
-}
-
-impl From<PusError> for ScheduleError {
-    fn from(e: PusError) -> Self {
-        Self::PusError(e)
-    }
-}
-
-impl From<PoolError> for ScheduleError {
-    fn from(e: PoolError) -> Self {
-        Self::StoreError(e)
-    }
-}
-
-impl From<TimestampError> for ScheduleError {
-    fn from(e: TimestampError) -> Self {
-        Self::TimestampError(e)
-    }
-}
-impl From<ByteConversionError> for ScheduleError {
-    fn from(e: ByteConversionError) -> Self {
-        Self::ByteConversionError(e)
-    }
-}
-
-#[cfg(feature = "std")]
-impl Error for ScheduleError {
-    fn source(&self) -> Option<&(dyn Error + 'static)> {
-        match self {
-            ScheduleError::PusError(e) => Some(e),
-            ScheduleError::StoreError(e) => Some(e),
-            ScheduleError::TimestampError(e) => Some(e),
-            ScheduleError::ByteConversionError(e) => Some(e),
-            _ => None,
-        }
-    }
+    #[error("byte conversion error: {0}")]
+    ByteConversionError(#[from] ByteConversionError),
 }

 /// Generic trait for scheduler objects which are able to schedule ECSS PUS C packets.
-pub trait PusSchedulerProvider {
+pub trait PusScheduler {
    type TimeProvider: CcsdsTimeProvider + TimeReader;

    fn reset(&mut self, store: &mut (impl PoolProvider + ?Sized)) -> Result<(), PoolError>;
@@ -401,7 +331,7 @@ pub mod alloc_mod {
    ///
    /// Currently, sub-schedules and groups are not supported.
    #[derive(Debug)]
-    pub struct PusScheduler {
+    pub struct PusSchedulerAlloc {
        // TODO: Use MonotonicTime from tai-time crate instead of UnixTime and cache leap seconds.
        // TODO: Introduce optional limit of commands stored in the TC map. If a limit is set,
        // there will be a check for each insertion whether the map is full, making the memory
@@ -411,7 +341,8 @@ pub mod alloc_mod {
        time_margin: Duration,
        enabled: bool,
    }
-    impl PusScheduler {
+
+    impl PusSchedulerAlloc {
        /// Create a new PUS scheduler.
        ///
        /// # Arguments
@@ -423,7 +354,7 @@ pub mod alloc_mod {
        /// * `tc_buf_size` - Buffer for temporary storage of telecommand packets. This buffer
        ///   should be large enough to accomodate the largest expected TC packets.
        pub fn new(init_current_time: UnixTime, time_margin: Duration) -> Self {
-            PusScheduler {
+            PusSchedulerAlloc {
                tc_map: Default::default(),
                current_time: init_current_time,
                time_margin,
@@ -445,10 +376,12 @@ pub mod alloc_mod {
            num_entries
        }

+        #[inline]
        pub fn update_time(&mut self, current_time: UnixTime) {
            self.current_time = current_time;
        }

+        #[inline]
        pub fn current_time(&self) -> &UnixTime {
            &self.current_time
        }
@@ -792,7 +725,7 @@ pub mod alloc_mod {
        }
    }

-    impl PusSchedulerProvider for PusScheduler {
+    impl PusScheduler for PusSchedulerAlloc {
        type TimeProvider = cds::CdsTime;

        /// This will disable the scheduler and clear the schedule as specified in 6.11.4.4.
@@ -948,7 +881,8 @@ mod tests {

    #[test]
    fn test_enable_api() {
-        let mut scheduler = PusScheduler::new(UnixTime::new_only_secs(0), Duration::from_secs(5));
+        let mut scheduler =
+            PusSchedulerAlloc::new(UnixTime::new_only_secs(0), Duration::from_secs(5));
        assert!(scheduler.is_enabled());
        scheduler.disable();
        assert!(!scheduler.is_enabled());
@@ -962,7 +896,8 @@ mod tests {
            vec![(10, 32), (5, 64)],
            false,
        ));
-        let mut scheduler = PusScheduler::new(UnixTime::new_only_secs(0), Duration::from_secs(5));
+        let mut scheduler =
+            PusSchedulerAlloc::new(UnixTime::new_only_secs(0), Duration::from_secs(5));

        let mut buf: [u8; 32] = [0; 32];
        let tc_info_0 = ping_tc_to_store(&mut pool, &mut buf, u14::new(0), &[]);
@@ -1004,7 +939,8 @@ mod tests {

    #[test]
    fn insert_multi_with_same_time() {
-        let mut scheduler = PusScheduler::new(UnixTime::new_only_secs(0), Duration::from_secs(5));
+        let mut scheduler =
+            PusSchedulerAlloc::new(UnixTime::new_only_secs(0), Duration::from_secs(5));

        scheduler
            .insert_unwrapped_and_stored_tc(
@@ -1063,7 +999,8 @@ mod tests {

    #[test]
    fn test_time_update() {
-        let mut scheduler = PusScheduler::new(UnixTime::new_only_secs(0), Duration::from_secs(5));
+        let mut scheduler =
+            PusSchedulerAlloc::new(UnixTime::new_only_secs(0), Duration::from_secs(5));
        let time = UnixTime::new(1, 2_000_000);
        scheduler.update_time(time);
        assert_eq!(scheduler.current_time(), &time);
@@ -1117,7 +1054,8 @@ mod tests {
            vec![(10, 32), (5, 64)],
            false,
        ));
-        let mut scheduler = PusScheduler::new(UnixTime::new_only_secs(0), Duration::from_secs(5));
+        let mut scheduler =
+            PusSchedulerAlloc::new(UnixTime::new_only_secs(0), Duration::from_secs(5));

        let mut buf: [u8; 32] = [0; 32];
        let tc_info_0 = ping_tc_to_store(&mut pool, &mut buf, u14::ZERO, &[]);
@@ -1185,7 +1123,8 @@ mod tests {
            vec![(10, 32), (5, 64)],
            false,
        ));
-        let mut scheduler = PusScheduler::new(UnixTime::new_only_secs(0), Duration::from_secs(5));
+        let mut scheduler =
+            PusSchedulerAlloc::new(UnixTime::new_only_secs(0), Duration::from_secs(5));

        let mut buf: [u8; 32] = [0; 32];
        let tc_info_0 = ping_tc_to_store(&mut pool, &mut buf, u14::ZERO, &[]);
@@ -1245,7 +1184,8 @@ mod tests {
            vec![(10, 32), (5, 64)],
            false,
        ));
-        let mut scheduler = PusScheduler::new(UnixTime::new_only_secs(0), Duration::from_secs(5));
+        let mut scheduler =
+            PusSchedulerAlloc::new(UnixTime::new_only_secs(0), Duration::from_secs(5));

        scheduler.disable();

@@ -1310,7 +1250,8 @@ mod tests {

    #[test]
    fn insert_unwrapped_tc() {
-        let mut scheduler = PusScheduler::new(UnixTime::new_only_secs(0), Duration::from_secs(5));
+        let mut scheduler =
+            PusSchedulerAlloc::new(UnixTime::new_only_secs(0), Duration::from_secs(5));

        let mut pool = StaticMemoryPool::new(StaticPoolConfig::new_from_subpool_cfg_tuples(
            vec![(10, 32), (5, 64)],
@@ -1360,7 +1301,8 @@ mod tests {

    #[test]
    fn insert_wrapped_tc() {
-        let mut scheduler = PusScheduler::new(UnixTime::new_only_secs(0), Duration::from_secs(5));
+        let mut scheduler =
+            PusSchedulerAlloc::new(UnixTime::new_only_secs(0), Duration::from_secs(5));

        let mut pool = StaticMemoryPool::new(StaticPoolConfig::new_from_subpool_cfg_tuples(
            vec![(10, 32), (5, 64)],
@@ -1412,7 +1354,8 @@ mod tests {

    #[test]
    fn insert_wrong_service() {
-        let mut scheduler = PusScheduler::new(UnixTime::new_only_secs(0), Duration::from_secs(5));
+        let mut scheduler =
+            PusSchedulerAlloc::new(UnixTime::new_only_secs(0), Duration::from_secs(5));

        let mut pool = StaticMemoryPool::new(StaticPoolConfig::new_from_subpool_cfg_tuples(
            vec![(10, 32), (5, 64)],
@@ -1437,7 +1380,8 @@ mod tests {

    #[test]
    fn insert_wrong_subservice() {
-        let mut scheduler = PusScheduler::new(UnixTime::new_only_secs(0), Duration::from_secs(5));
+        let mut scheduler =
+            PusSchedulerAlloc::new(UnixTime::new_only_secs(0), Duration::from_secs(5));

        let mut pool = StaticMemoryPool::new(StaticPoolConfig::new_from_subpool_cfg_tuples(
            vec![(10, 32), (5, 64)],
@@ -1462,7 +1406,8 @@ mod tests {

    #[test]
    fn insert_wrapped_tc_faulty_app_data() {
-        let mut scheduler = PusScheduler::new(UnixTime::new_only_secs(0), Duration::from_secs(5));
+        let mut scheduler =
+            PusSchedulerAlloc::new(UnixTime::new_only_secs(0), Duration::from_secs(5));
        let mut pool = StaticMemoryPool::new(StaticPoolConfig::new_from_subpool_cfg_tuples(
            vec![(10, 32), (5, 64)],
            false,
@@ -1479,7 +1424,8 @@ mod tests {

    #[test]
    fn insert_doubly_wrapped_time_tagged_cmd() {
-        let mut scheduler = PusScheduler::new(UnixTime::new_only_secs(0), Duration::from_secs(5));
+        let mut scheduler =
+            PusSchedulerAlloc::new(UnixTime::new_only_secs(0), Duration::from_secs(5));
        let mut pool = StaticMemoryPool::new(StaticPoolConfig::new_from_subpool_cfg_tuples(
            vec![(10, 32), (5, 64)],
            false,
@@ -1497,7 +1443,7 @@ mod tests {

    #[test]
    fn test_ctor_from_current() {
-        let scheduler = PusScheduler::new_with_current_init_time(Duration::from_secs(5))
+        let scheduler = PusSchedulerAlloc::new_with_current_init_time(Duration::from_secs(5))
            .expect("creation from current time failed");
        let current_time = scheduler.current_time;
        assert!(current_time.as_secs() > 0);
@@ -1505,7 +1451,8 @@ mod tests {

    #[test]
    fn test_update_from_current() {
-        let mut scheduler = PusScheduler::new(UnixTime::new_only_secs(0), Duration::from_secs(5));
+        let mut scheduler =
+            PusSchedulerAlloc::new(UnixTime::new_only_secs(0), Duration::from_secs(5));
        assert_eq!(scheduler.current_time.as_secs(), 0);
        scheduler
            .update_time_from_now()
@@ -1515,7 +1462,8 @@ mod tests {

    #[test]
    fn release_time_within_time_margin() {
-        let mut scheduler = PusScheduler::new(UnixTime::new_only_secs(0), Duration::from_secs(5));
+        let mut scheduler =
+            PusSchedulerAlloc::new(UnixTime::new_only_secs(0), Duration::from_secs(5));

        let mut pool = StaticMemoryPool::new(StaticPoolConfig::new_from_subpool_cfg_tuples(
            vec![(10, 32), (5, 64)],
@@ -1548,7 +1496,8 @@ mod tests {
            vec![(10, 32), (5, 64)],
            false,
        ));
-        let mut scheduler = PusScheduler::new(UnixTime::new_only_secs(0), Duration::from_secs(5));
+        let mut scheduler =
+            PusSchedulerAlloc::new(UnixTime::new_only_secs(0), Duration::from_secs(5));
        let mut buf: [u8; 32] = [0; 32];
        let tc_info_0 = ping_tc_to_store(&mut pool, &mut buf, u14::ZERO, &[]);
        scheduler
@@ -1585,7 +1534,8 @@ mod tests {
            vec![(10, 32), (5, 64)],
            false,
        ));
-        let mut scheduler = PusScheduler::new(UnixTime::new_only_secs(0), Duration::from_secs(5));
+        let mut scheduler =
+            PusSchedulerAlloc::new(UnixTime::new_only_secs(0), Duration::from_secs(5));
        let mut buf: [u8; 32] = [0; 32];
        let tc_info_0 = ping_tc_to_store(&mut pool, &mut buf, u14::ZERO, &[]);
        scheduler
@@ -1611,7 +1561,8 @@ mod tests {
            vec![(10, 32), (5, 64)],
            false,
        ));
-        let mut scheduler = PusScheduler::new(UnixTime::new_only_secs(0), Duration::from_secs(5));
+        let mut scheduler =
+            PusSchedulerAlloc::new(UnixTime::new_only_secs(0), Duration::from_secs(5));
        let mut buf: [u8; 32] = [0; 32];
        let tc_info_0 = ping_tc_to_store(&mut pool, &mut buf, u14::ZERO, &[]);
        scheduler
@@ -1632,7 +1583,8 @@ mod tests {
            vec![(10, 32), (5, 64)],
            false,
        ));
-        let mut scheduler = PusScheduler::new(UnixTime::new_only_secs(0), Duration::from_secs(5));
+        let mut scheduler =
+            PusSchedulerAlloc::new(UnixTime::new_only_secs(0), Duration::from_secs(5));
        let mut buf: [u8; 32] = [0; 32];
        let tc_info_0 = ping_tc_to_store(&mut pool, &mut buf, u14::ZERO, &[]);
        scheduler
@@ -1653,7 +1605,8 @@ mod tests {
            vec![(10, 32), (5, 64)],
            false,
        ));
-        let mut scheduler = PusScheduler::new(UnixTime::new_only_secs(0), Duration::from_secs(5));
+        let mut scheduler =
+            PusSchedulerAlloc::new(UnixTime::new_only_secs(0), Duration::from_secs(5));
        let mut buf: [u8; 32] = [0; 32];
        let tc_info_0 = ping_tc_to_store(&mut pool, &mut buf, u14::ZERO, &[]);
        scheduler
@@ -1695,7 +1648,8 @@ mod tests {

    #[test]
    fn insert_full_store_test() {
-        let mut scheduler = PusScheduler::new(UnixTime::new_only_secs(0), Duration::from_secs(5));
+        let mut scheduler =
+            PusSchedulerAlloc::new(UnixTime::new_only_secs(0), Duration::from_secs(5));

        let mut pool = StaticMemoryPool::new(StaticPoolConfig::new_from_subpool_cfg_tuples(
            vec![(1, 64)],
@@ -1711,7 +1665,7 @@ mod tests {
        assert!(insert_res.is_err());
        let err = insert_res.unwrap_err();
        match err {
-            ScheduleError::StoreError(e) => match e {
+            ScheduleError::Pool(e) => match e {
                PoolError::StoreFull(_) => {}
                _ => panic!("unexpected store error {e}"),
            },
@@ -1721,7 +1675,7 @@ mod tests {

    fn insert_command_with_release_time(
        pool: &mut StaticMemoryPool,
-        scheduler: &mut PusScheduler,
+        scheduler: &mut PusSchedulerAlloc,
        seq_count: u14,
        release_secs: u64,
    ) -> TcInfo {
@@ -1740,7 +1694,8 @@ mod tests {
            vec![(10, 32), (5, 64)],
            false,
        ));
-        let mut scheduler = PusScheduler::new(UnixTime::new_only_secs(0), Duration::from_secs(5));
+        let mut scheduler =
+            PusSchedulerAlloc::new(UnixTime::new_only_secs(0), Duration::from_secs(5));
        let tc_info_0 = insert_command_with_release_time(&mut pool, &mut scheduler, u14::ZERO, 50);
        let tc_info_1 = insert_command_with_release_time(&mut pool, &mut scheduler, u14::ZERO, 100);
        assert_eq!(scheduler.num_scheduled_telecommands(), 2);
@@ -1772,7 +1727,8 @@ mod tests {
            vec![(10, 32), (5, 64)],
            false,
        ));
-        let mut scheduler = PusScheduler::new(UnixTime::new_only_secs(0), Duration::from_secs(5));
+        let mut scheduler =
+            PusSchedulerAlloc::new(UnixTime::new_only_secs(0), Duration::from_secs(5));
        let _ = insert_command_with_release_time(&mut pool, &mut scheduler, u14::ZERO, 50);
        let tc_info_1 = insert_command_with_release_time(&mut pool, &mut scheduler, u14::ZERO, 100);
        let tc_info_2 = insert_command_with_release_time(&mut pool, &mut scheduler, u14::ZERO, 150);
@@ -1807,7 +1763,8 @@ mod tests {
            vec![(10, 32), (5, 64)],
            false,
        ));
-        let mut scheduler = PusScheduler::new(UnixTime::new_only_secs(0), Duration::from_secs(5));
+        let mut scheduler =
+            PusSchedulerAlloc::new(UnixTime::new_only_secs(0), Duration::from_secs(5));
        let tc_info_0 = insert_command_with_release_time(&mut pool, &mut scheduler, u14::ZERO, 50);
        let tc_info_1 = insert_command_with_release_time(&mut pool, &mut scheduler, u14::ZERO, 100);
        let _ = insert_command_with_release_time(&mut pool, &mut scheduler, u14::ZERO, 150);
@@ -1842,7 +1799,8 @@ mod tests {
            vec![(10, 32), (5, 64)],
            false,
        ));
-        let mut scheduler = PusScheduler::new(UnixTime::new_only_secs(0), Duration::from_secs(5));
+        let mut scheduler =
+            PusSchedulerAlloc::new(UnixTime::new_only_secs(0), Duration::from_secs(5));
        let _ = insert_command_with_release_time(&mut pool, &mut scheduler, u14::ZERO, 50);
        let tc_info_1 = insert_command_with_release_time(&mut pool, &mut scheduler, u14::ZERO, 100);
        let tc_info_2 = insert_command_with_release_time(&mut pool, &mut scheduler, u14::ZERO, 150);
@@ -1883,7 +1841,8 @@ mod tests {
            vec![(10, 32), (5, 64)],
            false,
        ));
-        let mut scheduler = PusScheduler::new(UnixTime::new_only_secs(0), Duration::from_secs(5));
+        let mut scheduler =
+            PusSchedulerAlloc::new(UnixTime::new_only_secs(0), Duration::from_secs(5));
        insert_command_with_release_time(&mut pool, &mut scheduler, u14::ZERO, 50);
        insert_command_with_release_time(&mut pool, &mut scheduler, u14::ZERO, 100);
        assert_eq!(scheduler.num_scheduled_telecommands(), 2);
@@ -1912,7 +1871,8 @@ mod tests {
            vec![(10, 32), (5, 64)],
            false,
        ));
-        let mut scheduler = PusScheduler::new(UnixTime::new_only_secs(0), Duration::from_secs(5));
+        let mut scheduler =
+            PusSchedulerAlloc::new(UnixTime::new_only_secs(0), Duration::from_secs(5));
        insert_command_with_release_time(&mut pool, &mut scheduler, u14::ZERO, 50);
        let cmd_0_to_delete =
            insert_command_with_release_time(&mut pool, &mut scheduler, u14::ZERO, 100);
@@ -1939,7 +1899,8 @@ mod tests {
            vec![(10, 32), (5, 64)],
            false,
        ));
-        let mut scheduler = PusScheduler::new(UnixTime::new_only_secs(0), Duration::from_secs(5));
+        let mut scheduler =
+            PusSchedulerAlloc::new(UnixTime::new_only_secs(0), Duration::from_secs(5));
        let cmd_0_to_delete =
            insert_command_with_release_time(&mut pool, &mut scheduler, u14::ZERO, 50);
        let cmd_1_to_delete =
@@ -1967,7 +1928,8 @@ mod tests {
            vec![(10, 32), (5, 64)],
            false,
        ));
-        let mut scheduler = PusScheduler::new(UnixTime::new_only_secs(0), Duration::from_secs(5));
+        let mut scheduler =
+            PusSchedulerAlloc::new(UnixTime::new_only_secs(0), Duration::from_secs(5));
        let cmd_out_of_range_0 =
            insert_command_with_release_time(&mut pool, &mut scheduler, u14::ZERO, 50);
        let cmd_0_to_delete =
@@ -2005,7 +1967,8 @@ mod tests {
            vec![(10, 32), (5, 64)],
            false,
        ));
-        let mut scheduler = PusScheduler::new(UnixTime::new_only_secs(0), Duration::from_secs(5));
+        let mut scheduler =
+            PusSchedulerAlloc::new(UnixTime::new_only_secs(0), Duration::from_secs(5));

        let mut buf: [u8; 32] = [0; 32];
        let tc_info_0 = ping_tc_to_store(&mut pool, &mut buf, u14::ZERO, &[]);
--- a/satrs/src/pus/scheduler_srv.rs
+++ b/satrs/src/pus/scheduler_srv.rs
@@ -1,4 +1,4 @@
-use super::scheduler::PusSchedulerProvider;
+use super::scheduler::PusScheduler;
 use super::verification::{VerificationReporter, VerificationReportingProvider};
 use super::{
    CacheAndReadRawEcssTc, DirectPusPacketHandlerResult, EcssTcInSharedPoolCacher, EcssTcReceiver,
@@ -26,11 +26,11 @@ pub struct PusSchedServiceHandler<
    TmSender: EcssTmSender,
    TcInMemConverter: CacheAndReadRawEcssTc,
    VerificationReporter: VerificationReportingProvider,
-    PusScheduler: PusSchedulerProvider,
+    PusSchedulerInstance: PusScheduler,
 > {
    pub service_helper:
        PusServiceHelper<TcReceiver, TmSender, TcInMemConverter, VerificationReporter>,
-    scheduler: PusScheduler,
+    scheduler: PusSchedulerInstance,
 }

 impl<
@@ -38,7 +38,7 @@ impl<
    TmSender: EcssTmSender,
    TcInMemConverter: CacheAndReadRawEcssTc,
    VerificationReporter: VerificationReportingProvider,
-    Scheduler: PusSchedulerProvider,
+    Scheduler: PusScheduler,
 > PusSchedServiceHandler<TcReceiver, TmSender, TcInMemConverter, VerificationReporter, Scheduler>
 {
    pub fn new(
@@ -254,7 +254,7 @@ mod tests {
    use crate::pus::{DirectPusPacketHandlerResult, MpscTcReceiver, PusPacketHandlingError};
    use crate::pus::{
        EcssTcInSharedPoolCacher,
-        scheduler::{self, PusSchedulerProvider, TcInfo},
+        scheduler::{self, PusScheduler, TcInfo},
        tests::PusServiceHandlerWithSharedStoreCommon,
        verification::{RequestId, TcStateAccepted, VerificationToken},
    };
@@ -349,7 +349,7 @@ mod tests {
        inserted_tcs: VecDeque<TcInfo>,
    }

-    impl PusSchedulerProvider for TestScheduler {
+    impl PusScheduler for TestScheduler {
        type TimeProvider = cds::CdsTime;

        fn reset(