diff --git a/.gitignore b/.gitignore
index 10a3411..70a1972 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,4 +1,5 @@
 /target
+/Cargo.lock
 
 /.idea/*
 !/.idea/runConfigurations
diff --git a/.gitmodules b/.gitmodules
index 36a814b..e69de29 100644
--- a/.gitmodules
+++ b/.gitmodules
@@ -1,3 +0,0 @@
-[submodule "spacepackets"]
-	path = spacepackets
-	url = https://egit.irs.uni-stuttgart.de/rust/spacepackets.git
diff --git a/.idea/runConfigurations/Docs.xml b/.idea/runConfigurations/Docs.xml
index c4efeaa..43ef045 100644
--- a/.idea/runConfigurations/Docs.xml
+++ b/.idea/runConfigurations/Docs.xml
@@ -1,12 +1,13 @@
 <component name="ProjectRunConfigurationManager">
   <configuration default="false" name="Docs" type="CargoCommandRunConfiguration" factoryName="Cargo Command">
-    <option name="command" value="doc" />
+    <option name="command" value="doc --all-features" />
     <option name="workingDirectory" value="file://$PROJECT_DIR$" />
     <option name="channel" value="DEFAULT" />
     <option name="requiredFeatures" value="true" />
     <option name="allFeatures" value="false" />
     <option name="emulateTerminal" value="false" />
     <option name="withSudo" value="false" />
+    <option name="buildTarget" value="REMOTE" />
     <option name="backtrace" value="SHORT" />
     <envs />
     <option name="isRedirectInput" value="false" />
diff --git a/.idea/runConfigurations/Run_obsw_example.xml b/.idea/runConfigurations/Run_obsw_example.xml
index ed323c9..df610ba 100644
--- a/.idea/runConfigurations/Run_obsw_example.xml
+++ b/.idea/runConfigurations/Run_obsw_example.xml
@@ -1,6 +1,6 @@
 <component name="ProjectRunConfigurationManager">
   <configuration default="false" name="Run obsw example" type="CargoCommandRunConfiguration" factoryName="Cargo Command">
-    <option name="command" value="run --package fsrc-example --bin obsw" />
+    <option name="command" value="run -p satrs-example --bin satrs-example" />
     <option name="workingDirectory" value="file://$PROJECT_DIR$" />
     <option name="channel" value="DEFAULT" />
     <option name="requiredFeatures" value="true" />
diff --git a/.idea/runConfigurations/Run_obsw_client_example.xml b/.idea/runConfigurations/Run_obsw_simple_client.xml
similarity index 84%
rename from .idea/runConfigurations/Run_obsw_client_example.xml
rename to .idea/runConfigurations/Run_obsw_simple_client.xml
index dc85ad6..4679680 100644
--- a/.idea/runConfigurations/Run_obsw_client_example.xml
+++ b/.idea/runConfigurations/Run_obsw_simple_client.xml
@@ -1,5 +1,5 @@
 <component name="ProjectRunConfigurationManager">
-  <configuration default="false" name="Run obsw client example" type="CargoCommandRunConfiguration" factoryName="Cargo Command">
+  <configuration default="false" name="Run obsw simple client" type="CargoCommandRunConfiguration" factoryName="Cargo Command">
     <option name="command" value="run --package fsrc-example --bin client" />
     <option name="workingDirectory" value="file://$PROJECT_DIR$" />
     <option name="channel" value="DEFAULT" />
diff --git a/.idea/runConfigurations/Run_spacepackets.xml b/.idea/runConfigurations/Run_spacepackets.xml
deleted file mode 100644
index 32f8a84..0000000
--- a/.idea/runConfigurations/Run_spacepackets.xml
+++ /dev/null
@@ -1,19 +0,0 @@
-<component name="ProjectRunConfigurationManager">
-  <configuration default="false" name="Run spacepackets" type="CargoCommandRunConfiguration" factoryName="Cargo Command">
-    <option name="command" value="run --package spacepackets --bin spacepackets" />
-    <option name="workingDirectory" value="file://$PROJECT_DIR$" />
-    <option name="channel" value="DEFAULT" />
-    <option name="requiredFeatures" value="true" />
-    <option name="allFeatures" value="false" />
-    <option name="emulateTerminal" value="false" />
-    <option name="withSudo" value="false" />
-    <option name="buildTarget" value="REMOTE" />
-    <option name="backtrace" value="SHORT" />
-    <envs />
-    <option name="isRedirectInput" value="false" />
-    <option name="redirectInputPath" value="" />
-    <method v="2">
-      <option name="CARGO.BUILD_TASK_PROVIDER" enabled="true" />
-    </method>
-  </configuration>
-</component>
\ No newline at end of file
diff --git a/.idea/runConfigurations/Test_spacepackets.xml b/.idea/runConfigurations/Test_satrs_core.xml
similarity index 71%
rename from .idea/runConfigurations/Test_spacepackets.xml
rename to .idea/runConfigurations/Test_satrs_core.xml
index aa53e5d..fe5e4da 100644
--- a/.idea/runConfigurations/Test_spacepackets.xml
+++ b/.idea/runConfigurations/Test_satrs_core.xml
@@ -1,12 +1,13 @@
 <component name="ProjectRunConfigurationManager">
-  <configuration default="false" name="Test spacepackets" type="CargoCommandRunConfiguration" factoryName="Cargo Command">
-    <option name="command" value="test -p spacepackets" />
+  <configuration default="false" name="Test satrs-core" type="CargoCommandRunConfiguration" factoryName="Cargo Command">
+    <option name="command" value="test -p satrs-core --all-features" />
     <option name="workingDirectory" value="file://$PROJECT_DIR$" />
     <option name="channel" value="DEFAULT" />
     <option name="requiredFeatures" value="true" />
     <option name="allFeatures" value="true" />
     <option name="emulateTerminal" value="false" />
     <option name="withSudo" value="false" />
+    <option name="buildTarget" value="REMOTE" />
     <option name="backtrace" value="SHORT" />
     <envs />
     <option name="isRedirectInput" value="false" />
diff --git a/Cargo.toml b/Cargo.toml
index 66610da..c9d35a8 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,7 +1,11 @@
 [workspace]
 
 members = [
-    "fsrc-core",
-    "spacepackets",
-    "fsrc-example"
+    "satrs-core",
+    "satrs-mib",
+    "satrs-example",
+]
+
+exclude = [
+    "satrs-example-stm32f3-disco",
 ]
diff --git a/NOTICE b/NOTICE
index 58b61d9..717a583 100644
--- a/NOTICE
+++ b/NOTICE
@@ -1,3 +1 @@
-Workspace for the Flight Software Rust Components (FSRC) development.
-
-This software contains code developed at the University of Stuttgart.
\ No newline at end of file
+This software contains code developed at the University of Stuttgart's Institute of Space Systems.
diff --git a/README.md b/README.md
index ce87c7a..d044075 100644
--- a/README.md
+++ b/README.md
@@ -1,5 +1,34 @@
-Rust Flight Software Framework Launchpad
+sat-rs launchpad
 =========
 
-This is the prototyping repository for the initial version of a
-Rust Flight Software Framework.
+This is the prototyping repository for the initial version of the sat-rs framework.
+
+Its primary goal is to provide re-usable components to write on-board software for remote
+systems like rovers or satellites. It is specifically written for the special requirements
+for these systems.
+
+# Overview
+
+This project currently contains following crates:
+
+* [`satrs-core`](https://egit.irs.uni-stuttgart.de/rust/satrs-launchpad/src/branch/main/satrs-core):
+   Core components of sat-rs.
+* [`satrs-example`](https://egit.irs.uni-stuttgart.de/rust/satrs-launchpad/src/branch/main/satrs-example):
+   Example of a simple example on-board software using various sat-rs components which can be run
+   on a host computer or on any system with a standard runtime like a Raspberry Pi.
+* [`satrs-mib`](https://egit.irs.uni-stuttgart.de/rust/satrs-launchpad/src/branch/main/satrs-mib):
+   Components to build a mission information base from the on-board software directly.
+* [`satrs-example-stm32f3-disco`](https://egit.irs.uni-stuttgart.de/rust/satrs-example-stm32f3-disco):
+   Example of a simple example on-board software using sat-rs components on a bare-metal system
+   with constrained resources.
+
+Each project has its own `CHANGELOG.md`.
+
+# Related projects
+ 
+ In addition to the crates in this repository, the sat-rs project also maintains other libraries.
+
+ * [`spacepackets`](https://egit.irs.uni-stuttgart.de/rust/spacepackets): Basic ECSS and CCSDS
+   packet protocol implementations. This repository is re-exported in the
+   [`satrs-core`](https://egit.irs.uni-stuttgart.de/rust/satrs-launchpad/src/branch/main/satrs-core)
+   crate.
diff --git a/archive.rs b/archive.rs
deleted file mode 100644
index a9bdce0..0000000
--- a/archive.rs
+++ /dev/null
@@ -1,82 +0,0 @@
-
-/*
-pub mod deku {
-    pub use ccsds_spacepacket::PrimaryHeader as SpHeader;
-    use crate::sp::{self, PacketId, PacketSequenceCtrl};
-    use crate::sp::{CcsdsPrimaryHeader, PacketType, SequenceFlags};
-
-    impl CcsdsPrimaryHeader for SpHeader {
-        fn from_composite_fields(packet_id: PacketId, psc: PacketSequenceCtrl, data_len: u16, version: Option<u8>) -> Self {
-            let mut version_to_set = 0b000;
-            if let Some(version) = version {
-                version_to_set = version;
-            }
-            let packet_type = match packet_id.ptype {
-                PacketType::Tm => ccsds_spacepacket::types::PacketType::Data,
-                PacketType::Tc => ccsds_spacepacket::types::PacketType::Command
-            };
-            let sec_header_flag = match packet_id.sec_header_flag {
-                true => ccsds_spacepacket::types::SecondaryHeaderFlag::Present,
-                false => ccsds_spacepacket::types::SecondaryHeaderFlag::NotPresent
-            };
-            let sequence_flags = match psc.seq_flags {
-                SequenceFlags::ContinuationSegment => ccsds_spacepacket::types::SeqFlag::Continuation,
-                SequenceFlags::FirstSegment => ccsds_spacepacket::types::SeqFlag::FirstSegment,
-                SequenceFlags::LastSegment => ccsds_spacepacket::types::SeqFlag::LastSegment,
-                SequenceFlags::Unsegmented => ccsds_spacepacket::types::SeqFlag::Unsegmented
-            };
-            SpHeader {
-                version: version_to_set,
-                packet_type,
-                sec_header_flag,
-                app_proc_id: packet_id.apid,
-                sequence_flags,
-                sequence_count: psc.ssc,
-                data_length: data_len
-            }
-        }
-
-        #[inline]
-        fn version(&self) -> u8 {
-            self.version
-        }
-
-        #[inline]
-        fn packet_id(&self) -> PacketId {
-            PacketId {
-                ptype: PacketType::try_from(self.packet_type as u8).unwrap(),
-                apid: self.app_proc_id,
-                sec_header_flag: self.sec_header_flag as u8 != 0
-            }
-        }
-
-        #[inline]
-        fn psc(&self) -> PacketSequenceCtrl {
-            PacketSequenceCtrl {
-                seq_flags: SequenceFlags::try_from(self.sequence_flags as u8).unwrap(),
-                ssc: self.sequence_count
-            }
-        }
-
-        #[inline]
-        fn data_len(&self) -> u16 {
-            self.data_length
-        }
-    }
-
-    sph_from_other!(SpHeader, sp::srd::SpHeader);
-    sph_from_other!(SpHeader, sp::zc::SpHeader);
-}
-*/
-
-/*
-#[test]
-fn test_deser_to_raw_packed_deku() {
-    let sp_header = SpHeader::tc(0x42, 12).expect("Error creating SP header");
-    // TODO: Wait with these tests until KubOS merged
-    //       https://github.com/KubOS-Preservation-Group/ccsds-spacepacket/pull/14
-    let _deku_header =
-        deku::SpHeader::try_from(sp_header).expect("Error creating Deku Sp Header");
-    // deku_header.to_bytes().unwrap();
-}
- */
diff --git a/fsrc-core/Cargo.toml b/fsrc-core/Cargo.toml
deleted file mode 100644
index 8188273..0000000
--- a/fsrc-core/Cargo.toml
+++ /dev/null
@@ -1,43 +0,0 @@
-[package]
-name = "fsrc-core"
-version = "0.1.0"
-edition = "2021"
-
-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
-
-[dependencies]
-delegate = "0.8.0"
-hashbrown = "0.12.3"
-
-[dependencies.num-traits]
-version = "0.2"
-default-features = false
-
-[dependencies.downcast-rs]
-version = "1.2.0"
-default-features = false
-
-[dependencies.bus]
-version = "2.2.3"
-optional = true
-
-[dependencies.crossbeam-channel]
-version= "0.5"
-default-features = false
-
-[dependencies.spacepackets]
-path = "../spacepackets"
-
-[dev-dependencies]
-serde = "1.0.143"
-zerocopy = "0.6.1"
-once_cell = "1.13.1"
-
-[dev-dependencies.postcard]
-version = "1.0.1"
-
-[features]
-default = ["std"]
-std = ["downcast-rs/std", "alloc", "bus", "postcard/use-std", "crossbeam-channel/std"]
-alloc = []
-
diff --git a/fsrc-core/src/event_man.rs b/fsrc-core/src/event_man.rs
deleted file mode 100644
index 83e4543..0000000
--- a/fsrc-core/src/event_man.rs
+++ /dev/null
@@ -1,318 +0,0 @@
-//! [Event][crate::events::Event] management and forwarding
-use crate::events::{Event, EventRaw, GroupId};
-use alloc::boxed::Box;
-use alloc::vec;
-use alloc::vec::Vec;
-use hashbrown::HashMap;
-
-#[derive(PartialEq, Eq, Hash, Copy, Clone)]
-enum ListenerType {
-    Single(EventRaw),
-    Group(GroupId),
-}
-
-pub trait EventListener {
-    type Error;
-
-    fn id(&self) -> u32;
-    fn send_to(&mut self, event: Event) -> Result<(), Self::Error>;
-}
-
-struct Listener<E> {
-    ltype: ListenerType,
-    dest: Box<dyn EventListener<Error = E>>,
-}
-
-pub trait ReceivesAllEvent {
-    fn receive(&mut self) -> Option<Event>;
-}
-
-pub struct EventManager<E> {
-    listeners: HashMap<ListenerType, Vec<Listener<E>>>,
-    event_receiver: Box<dyn ReceivesAllEvent>,
-}
-
-pub enum HandlerResult {
-    Empty,
-    Handled(u32, Event),
-}
-
-impl<E> EventManager<E> {
-    pub fn new(event_receiver: Box<dyn ReceivesAllEvent>) -> Self {
-        EventManager {
-            listeners: HashMap::new(),
-            event_receiver,
-        }
-    }
-    pub fn subscribe_single(
-        &mut self,
-        event: Event,
-        dest: impl EventListener<Error = E> + 'static,
-    ) {
-        self.update_listeners(ListenerType::Single(event.raw()), dest);
-    }
-
-    pub fn subscribe_group(
-        &mut self,
-        group_id: GroupId,
-        dest: impl EventListener<Error = E> + 'static,
-    ) {
-        self.update_listeners(ListenerType::Group(group_id), dest);
-    }
-
-    fn update_listeners(
-        &mut self,
-        key: ListenerType,
-        dest: impl EventListener<Error = E> + 'static,
-    ) {
-        if !self.listeners.contains_key(&key) {
-            self.listeners.insert(
-                key,
-                vec![Listener {
-                    ltype: key,
-                    dest: Box::new(dest),
-                }],
-            );
-        } else {
-            let vec = self.listeners.get_mut(&key).unwrap();
-            // To prevent double insertions
-            for entry in vec.iter() {
-                if entry.ltype == key && entry.dest.id() == dest.id() {
-                    return;
-                }
-            }
-            vec.push(Listener {
-                ltype: key,
-                dest: Box::new(dest),
-            });
-        }
-    }
-
-    pub fn try_event_handling(&mut self) -> Result<HandlerResult, E> {
-        let mut err_status = None;
-        let mut num_recipients = 0;
-        let mut send_handler = |event, llist: &mut Vec<Listener<E>>| {
-            for listener in llist.iter_mut() {
-                if let Err(e) = listener.dest.send_to(event) {
-                    err_status = Some(Err(e));
-                } else {
-                    num_recipients += 1;
-                }
-            }
-        };
-        if let Some(event) = self.event_receiver.receive() {
-            let single_key = ListenerType::Single(event.raw());
-            if self.listeners.contains_key(&single_key) {
-                send_handler(event, self.listeners.get_mut(&single_key).unwrap());
-            }
-            let group_key = ListenerType::Group(event.group_id());
-            if self.listeners.contains_key(&group_key) {
-                send_handler(event, self.listeners.get_mut(&group_key).unwrap());
-            }
-            if let Some(err) = err_status {
-                return err;
-            }
-            return Ok(HandlerResult::Handled(num_recipients, event));
-        }
-        Ok(HandlerResult::Empty)
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::{EventListener, HandlerResult, ReceivesAllEvent};
-    use crate::event_man::EventManager;
-    use crate::events::{Event, Severity};
-    use alloc::boxed::Box;
-    use std::sync::mpsc::{channel, Receiver, SendError, Sender};
-    use std::thread;
-    use std::time::Duration;
-
-    struct EventReceiver {
-        mpsc_receiver: Receiver<Event>,
-    }
-    impl ReceivesAllEvent for EventReceiver {
-        fn receive(&mut self) -> Option<Event> {
-            self.mpsc_receiver.try_recv().ok()
-        }
-    }
-
-    #[derive(Clone)]
-    struct MpscEventSenderQueue {
-        id: u32,
-        mpsc_sender: Sender<Event>,
-    }
-
-    impl EventListener for MpscEventSenderQueue {
-        type Error = SendError<Event>;
-
-        fn id(&self) -> u32 {
-            self.id
-        }
-        fn send_to(&mut self, event: Event) -> Result<(), Self::Error> {
-            self.mpsc_sender.send(event)
-        }
-    }
-
-    fn check_next_event(expected: Event, receiver: &Receiver<Event>) {
-        for _ in 0..5 {
-            if let Ok(event) = receiver.try_recv() {
-                assert_eq!(event, expected);
-                break;
-            }
-            thread::sleep(Duration::from_millis(1));
-        }
-    }
-
-    fn check_handled_event(res: HandlerResult, expected: Event, expected_num_sent: u32) {
-        assert!(matches!(res, HandlerResult::Handled { .. }));
-        if let HandlerResult::Handled(num_recipients, event) = res {
-            assert_eq!(event, expected);
-            assert_eq!(num_recipients, expected_num_sent);
-        }
-    }
-
-    #[test]
-    fn test_basic() {
-        let (event_sender, manager_queue) = channel();
-        let event_man_receiver = EventReceiver {
-            mpsc_receiver: manager_queue,
-        };
-        let mut event_man: EventManager<SendError<Event>> =
-            EventManager::new(Box::new(event_man_receiver));
-        let event_grp_0 = Event::new(Severity::INFO, 0, 0).unwrap();
-        let event_grp_1_0 = Event::new(Severity::HIGH, 1, 0).unwrap();
-        let (single_event_sender, single_event_receiver) = channel();
-        let single_event_listener = MpscEventSenderQueue {
-            id: 0,
-            mpsc_sender: single_event_sender,
-        };
-        event_man.subscribe_single(event_grp_0, single_event_listener);
-        let (group_event_sender_0, group_event_receiver_0) = channel();
-        let group_event_listener = MpscEventSenderQueue {
-            id: 1,
-            mpsc_sender: group_event_sender_0,
-        };
-        event_man.subscribe_group(event_grp_1_0.group_id(), group_event_listener);
-
-        // Test event with one listener
-        event_sender
-            .send(event_grp_0)
-            .expect("Sending single error failed");
-        let res = event_man.try_event_handling();
-        assert!(res.is_ok());
-        check_handled_event(res.unwrap(), event_grp_0, 1);
-        check_next_event(event_grp_0, &single_event_receiver);
-
-        // Test event which is sent to all group listeners
-        event_sender
-            .send(event_grp_1_0)
-            .expect("Sending group error failed");
-        let res = event_man.try_event_handling();
-        assert!(res.is_ok());
-        check_handled_event(res.unwrap(), event_grp_1_0, 1);
-        check_next_event(event_grp_1_0, &group_event_receiver_0);
-    }
-
-    /// Test listening for multiple groups
-    #[test]
-    fn test_multi_group() {
-        let (event_sender, manager_queue) = channel();
-        let event_man_receiver = EventReceiver {
-            mpsc_receiver: manager_queue,
-        };
-        let mut event_man: EventManager<SendError<Event>> =
-            EventManager::new(Box::new(event_man_receiver));
-        let res = event_man.try_event_handling();
-        assert!(res.is_ok());
-        let hres = res.unwrap();
-        assert!(matches!(hres, HandlerResult::Empty));
-
-        let event_grp_0 = Event::new(Severity::INFO, 0, 0).unwrap();
-        let event_grp_1_0 = Event::new(Severity::HIGH, 1, 0).unwrap();
-        let (event_grp_0_sender, event_grp_0_receiver) = channel();
-        let event_grp_0_and_1_listener = MpscEventSenderQueue {
-            id: 0,
-            mpsc_sender: event_grp_0_sender,
-        };
-        event_man.subscribe_group(event_grp_0.group_id(), event_grp_0_and_1_listener.clone());
-        event_man.subscribe_group(event_grp_1_0.group_id(), event_grp_0_and_1_listener);
-
-        event_sender
-            .send(event_grp_0)
-            .expect("Sending Event Group 0 failed");
-        event_sender
-            .send(event_grp_1_0)
-            .expect("Sendign Event Group 1 failed");
-        let res = event_man.try_event_handling();
-        assert!(res.is_ok());
-        check_handled_event(res.unwrap(), event_grp_0, 1);
-        let res = event_man.try_event_handling();
-        assert!(res.is_ok());
-        check_handled_event(res.unwrap(), event_grp_1_0, 1);
-
-        check_next_event(event_grp_0, &event_grp_0_receiver);
-        check_next_event(event_grp_1_0, &event_grp_0_receiver);
-    }
-
-    /// Test listening to the same event from multiple listeners. Also test listening
-    /// to both group and single events from one listener
-    #[test]
-    fn test_listening_to_same_event_and_multi_type() {
-        let (event_sender, manager_queue) = channel();
-        let event_man_receiver = EventReceiver {
-            mpsc_receiver: manager_queue,
-        };
-        let mut event_man: EventManager<SendError<Event>> =
-            EventManager::new(Box::new(event_man_receiver));
-        let event_0 = Event::new(Severity::INFO, 0, 5).unwrap();
-        let event_1 = Event::new(Severity::HIGH, 1, 0).unwrap();
-        let (event_0_tx_0, event_0_rx_0) = channel();
-        let (event_0_tx_1, event_0_rx_1) = channel();
-        let event_listener_0 = MpscEventSenderQueue {
-            id: 0,
-            mpsc_sender: event_0_tx_0,
-        };
-        let event_listener_1 = MpscEventSenderQueue {
-            id: 1,
-            mpsc_sender: event_0_tx_1,
-        };
-        event_man.subscribe_single(event_0, event_listener_0.clone());
-        event_man.subscribe_single(event_0, event_listener_1);
-        event_sender
-            .send(event_0)
-            .expect("Triggering Event 0 failed");
-        let res = event_man.try_event_handling();
-        assert!(res.is_ok());
-        check_handled_event(res.unwrap(), event_0, 2);
-        check_next_event(event_0, &event_0_rx_0);
-        check_next_event(event_0, &event_0_rx_1);
-        event_man.subscribe_group(event_1.group_id(), event_listener_0.clone());
-        event_sender
-            .send(event_0)
-            .expect("Triggering Event 0 failed");
-        event_sender
-            .send(event_1)
-            .expect("Triggering Event 1 failed");
-
-        // 3 Events messages will be sent now
-        let res = event_man.try_event_handling();
-        assert!(res.is_ok());
-        check_handled_event(res.unwrap(), event_0, 2);
-        let res = event_man.try_event_handling();
-        assert!(res.is_ok());
-        check_handled_event(res.unwrap(), event_1, 1);
-        // Both the single event and the group event should arrive now
-        check_next_event(event_0, &event_0_rx_0);
-        check_next_event(event_1, &event_0_rx_0);
-
-        // Double insertion should be detected, result should remain the same
-        event_man.subscribe_group(event_1.group_id(), event_listener_0);
-        event_sender
-            .send(event_1)
-            .expect("Triggering Event 1 failed");
-        let res = event_man.try_event_handling();
-        assert!(res.is_ok());
-        check_handled_event(res.unwrap(), event_1, 1);
-    }
-}
diff --git a/fsrc-core/src/events.rs b/fsrc-core/src/events.rs
deleted file mode 100644
index be351b9..0000000
--- a/fsrc-core/src/events.rs
+++ /dev/null
@@ -1,132 +0,0 @@
-//! Event support module
-
-pub type GroupId = u16;
-pub type UniqueId = u16;
-pub type EventRaw = u32;
-
-#[derive(Copy, Clone, PartialEq, Eq, Debug)]
-pub enum Severity {
-    INFO = 1,
-    LOW = 2,
-    MEDIUM = 3,
-    HIGH = 4,
-}
-
-impl TryFrom<u8> for Severity {
-    type Error = ();
-
-    fn try_from(value: u8) -> Result<Self, Self::Error> {
-        match value {
-            x if x == Severity::INFO as u8 => Ok(Severity::INFO),
-            x if x == Severity::LOW as u8 => Ok(Severity::LOW),
-            x if x == Severity::MEDIUM as u8 => Ok(Severity::MEDIUM),
-            x if x == Severity::HIGH as u8 => Ok(Severity::HIGH),
-            _ => Err(()),
-        }
-    }
-}
-
-#[derive(Copy, Clone, Debug, PartialEq, Eq)]
-pub struct Event {
-    severity: Severity,
-    group_id: GroupId,
-    unique_id: UniqueId,
-}
-
-impl Event {
-    /// Generate an event. The raw representation of an event has 32 bits.
-    /// If the passed group ID is invalid (too large), None wil be returned
-    ///
-    /// # Parameter
-    ///
-    /// * `severity`: Each event has a [severity][Severity]. The raw value of the severity will
-    ///        be stored inside the uppermost 3 bits of the raw event ID
-    /// * `group_id`: Related events can be grouped using a group ID. The group ID will occupy the
-    ///        next 13 bits after the severity. Therefore, the size is limited by dec 8191 hex 0x1FFF.
-    /// * `unique_id`: Each event has a unique 16 bit ID occupying the last 16 bits of the
-    ///       raw event ID
-    pub fn new(severity: Severity, group_id: GroupId, unique_id: UniqueId) -> Option<Event> {
-        if group_id > (2u16.pow(13) - 1) {
-            return None;
-        }
-        Some(Event {
-            severity,
-            group_id,
-            unique_id,
-        })
-    }
-
-    /// Retrieve the severity of an event. Returns None if that severity bit field of the raw event
-    /// ID is invalid
-    pub fn severity(&self) -> Severity {
-        self.severity
-    }
-
-    pub fn group_id(&self) -> GroupId {
-        self.group_id
-    }
-
-    pub fn unique_id(&self) -> UniqueId {
-        self.unique_id
-    }
-
-    pub fn raw(&self) -> EventRaw {
-        (((self.severity as u32) << 29) as u32
-            | ((self.group_id as u32) << 16) as u32
-            | self.unique_id as u32) as EventRaw
-    }
-}
-
-impl TryFrom<EventRaw> for Event {
-    type Error = ();
-
-    fn try_from(raw: u32) -> Result<Self, Self::Error> {
-        let severity: Option<Severity> = (((raw >> 29) & 0b111) as u8).try_into().ok();
-        if severity.is_none() {
-            return Err(());
-        }
-        let group_id = ((raw >> 16) & 0x1FFF) as u16;
-        let unique_id = (raw & 0xFFFF) as u16;
-        Event::new(severity.unwrap(), group_id, unique_id).ok_or(())
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::Event;
-    use crate::events::Severity;
-
-    #[test]
-    fn test_events() {
-        let event = Event::new(Severity::INFO, 0, 0).unwrap();
-        assert_eq!(event.severity(), Severity::INFO);
-        assert_eq!(event.unique_id(), 0);
-        assert_eq!(event.group_id(), 0);
-
-        let raw_event = event.raw();
-        assert_eq!(raw_event, 0x20000000);
-        let conv_from_raw = Event::try_from(raw_event);
-        assert!(conv_from_raw.is_ok());
-        let opt_event = conv_from_raw.ok();
-        assert!(opt_event.is_some());
-        let event = opt_event.unwrap();
-        assert_eq!(event.severity(), Severity::INFO);
-        assert_eq!(event.unique_id(), 0);
-        assert_eq!(event.group_id(), 0);
-
-        let event = Event::new(Severity::HIGH, 0x1FFF, 0xFFFF).unwrap();
-        assert_eq!(event.severity(), Severity::HIGH);
-        assert_eq!(event.group_id(), 0x1FFF);
-        assert_eq!(event.unique_id(), 0xFFFF);
-        let raw_event = event.raw();
-        assert_eq!(raw_event, 0x9FFFFFFF);
-        let conv_from_raw = Event::try_from(raw_event);
-        assert!(conv_from_raw.is_ok());
-        let opt_event = conv_from_raw.ok();
-        assert!(opt_event.is_some());
-        let event = opt_event.unwrap();
-        assert_eq!(event.severity(), Severity::HIGH);
-        assert_eq!(event.group_id(), 0x1FFF);
-        assert_eq!(event.unique_id(), 0xFFFF);
-    }
-}
diff --git a/fsrc-core/src/lib.rs b/fsrc-core/src/lib.rs
deleted file mode 100644
index 02298a0..0000000
--- a/fsrc-core/src/lib.rs
+++ /dev/null
@@ -1,29 +0,0 @@
-//! # Core components of the Flight Software Rust Crate (FSRC) collection
-//!
-//! This is a collection of Rust crates which can be used to build On-Board Software for remote
-//! systems like satellites of rovers. It has special support for space tailored protocols
-//! like the ones provided by CCSDS and ECSS.
-//!
-//! The crates can generally be used in a `no_std` environment, but some crates expect that the
-//! [alloc](https://doc.rust-lang.org/alloc) crate is available to allow boxed trait objects.
-//! These are used to supply user code to the crates.
-#![no_std]
-#[cfg(feature = "alloc")]
-extern crate alloc;
-#[cfg(any(feature = "std", test))]
-extern crate std;
-
-pub mod error;
-#[cfg(feature = "alloc")]
-pub mod event_man;
-pub mod events;
-#[cfg(feature = "std")]
-pub mod executable;
-pub mod hal;
-pub mod objects;
-#[cfg(feature = "alloc")]
-pub mod pool;
-pub mod pus;
-pub mod tmtc;
-
-extern crate downcast_rs;
diff --git a/fsrc-core/src/pus/mod.rs b/fsrc-core/src/pus/mod.rs
deleted file mode 100644
index fb3a317..0000000
--- a/fsrc-core/src/pus/mod.rs
+++ /dev/null
@@ -1,7 +0,0 @@
-//! All PUS support modules
-//!
-//! Currenty includes:
-//!
-//!  1. PUS Verification Service 1 module inside [verification]. Requires [alloc] support.
-#[cfg(feature = "alloc")]
-pub mod verification;
diff --git a/fsrc-core/src/pus/verification.rs b/fsrc-core/src/pus/verification.rs
deleted file mode 100644
index 4af6ad6..0000000
--- a/fsrc-core/src/pus/verification.rs
+++ /dev/null
@@ -1,1631 +0,0 @@
-//! # PUS Verification Service 1 Module
-//!
-//! This module allows packaging and sending PUS Service 1 packets. It is conforming to section
-//! 8 of the PUS standard ECSS-E-ST-70-41C.
-//!
-//! The core object to report TC verification progress is the [VerificationReporter]. It exposes
-//! an API which uses type-state programming to avoid calling the verification steps in
-//! an invalid order.
-//!
-//! # Examples
-//!
-//! Basic single-threaded example where a full success sequence for a given ping telecommand is
-//! executed. Note that the verification part could also be done in a separate thread.
-//!
-//! ```
-//! use std::sync::{Arc, RwLock};
-//! use std::time::Duration;
-//! use fsrc_core::pool::{LocalPool, PoolCfg, PoolProvider, SharedPool};
-//! use fsrc_core::pus::verification::{CrossbeamVerifSender, VerificationReporterCfg, VerificationReporterWithSender};
-//! use spacepackets::ecss::PusPacket;
-//! use spacepackets::SpHeader;
-//! use spacepackets::tc::{PusTc, PusTcSecondaryHeader};
-//! use spacepackets::tm::PusTm;
-//!
-//! const EMPTY_STAMP: [u8; 7] = [0; 7];
-//! const TEST_APID: u16 = 0x02;
-//!
-//! let pool_cfg = PoolCfg::new(vec![(10, 32), (10, 64), (10, 128), (10, 1024)]);
-//! let shared_tm_pool: SharedPool = Arc::new(RwLock::new(Box::new(LocalPool::new(pool_cfg.clone()))));
-//! let (verif_tx, verif_rx) = crossbeam_channel::bounded(10);
-//! let sender = CrossbeamVerifSender::new(shared_tm_pool.clone(), verif_tx);
-//! let cfg = VerificationReporterCfg::new(TEST_APID, 1, 2, 8);
-//! let mut  reporter = VerificationReporterWithSender::new(cfg , Box::new(sender));
-//!
-//! let mut sph = SpHeader::tc(TEST_APID, 0, 0).unwrap();
-//! let tc_header = PusTcSecondaryHeader::new_simple(17, 1);
-//! let pus_tc_0 = PusTc::new(&mut sph, tc_header, None, true);
-//! let init_token = reporter.add_tc(&pus_tc_0);
-//!
-//! // Complete success sequence for a telecommand
-//! let accepted_token = reporter.acceptance_success(init_token, &EMPTY_STAMP).unwrap();
-//! let started_token = reporter.start_success(accepted_token, &EMPTY_STAMP).unwrap();
-//! reporter.completion_success(started_token, &EMPTY_STAMP).unwrap();
-//!
-//! // Verify it arrives correctly on receiver end
-//! let mut tm_buf: [u8; 1024] = [0; 1024];
-//! let mut packet_idx = 0;
-//! while packet_idx < 3 {
-//!     let addr = verif_rx.recv_timeout(Duration::from_millis(10)).unwrap();
-//!     let tm_len;
-//!     {
-//!         let mut rg = shared_tm_pool.write().expect("Error locking shared pool");
-//!         let store_guard = rg.read_with_guard(addr);
-//!         let slice = store_guard.read().expect("Error reading TM slice");
-//!         tm_len = slice.len();
-//!         tm_buf[0..tm_len].copy_from_slice(slice);
-//!     }
-//!     let (pus_tm, _) = PusTm::new_from_raw_slice(&tm_buf[0..tm_len], 7)
-//!        .expect("Error reading verification TM");
-//!     if packet_idx == 0 {
-//!         assert_eq!(pus_tm.subservice(), 1);
-//!     } else if packet_idx == 1 {
-//!         assert_eq!(pus_tm.subservice(), 3);
-//!     } else if packet_idx == 2 {
-//!         assert_eq!(pus_tm.subservice(), 7);
-//!     }
-//!     packet_idx += 1;
-//! }
-//! ```
-//!
-//! The [integration test](https://egit.irs.uni-stuttgart.de/rust/fsrc-launchpad/src/branch/main/fsrc-core/tests/verification_test.rs)
-//! for the verification module contains examples how this module could be used in a more complex
-//! context involving multiple threads
-use alloc::boxed::Box;
-use alloc::vec;
-use alloc::vec::Vec;
-use core::fmt::{Display, Formatter};
-use core::hash::{Hash, Hasher};
-use core::marker::PhantomData;
-use core::mem::size_of;
-use delegate::delegate;
-use downcast_rs::{impl_downcast, Downcast};
-use spacepackets::ecss::{EcssEnumeration, PusError};
-use spacepackets::tc::PusTc;
-use spacepackets::time::TimestampError;
-use spacepackets::tm::{PusTm, PusTmSecondaryHeader};
-use spacepackets::{ByteConversionError, SizeMissmatch, SpHeader};
-use spacepackets::{CcsdsPacket, PacketId, PacketSequenceCtrl};
-
-#[cfg(feature = "std")]
-pub use stdmod::{
-    CrossbeamVerifSender, MpscVerifSender, SharedStdVerifReporterWithSender,
-    StdVerifReporterWithSender, StdVerifSenderError,
-};
-
-/// This is a request identifier as specified in 5.4.11.2 c. of the PUS standard
-/// This field equivalent to the first two bytes of the CCSDS space packet header.
-#[derive(Debug, Eq, Copy, Clone)]
-pub struct RequestId {
-    version_number: u8,
-    packet_id: PacketId,
-    psc: PacketSequenceCtrl,
-}
-
-impl Display for RequestId {
-    fn fmt(&self, f: &mut Formatter<'_>) -> core::fmt::Result {
-        write!(f, "{:#08x}", self.raw())
-    }
-}
-
-impl Hash for RequestId {
-    fn hash<H: Hasher>(&self, state: &mut H) {
-        self.raw().hash(state);
-    }
-}
-
-// Implement manually to satisfy derive_hash_xor_eq lint
-impl PartialEq for RequestId {
-    fn eq(&self, other: &Self) -> bool {
-        self.version_number == other.version_number
-            && self.packet_id == other.packet_id
-            && self.psc == other.psc
-    }
-}
-
-impl RequestId {
-    pub const SIZE_AS_BYTES: usize = size_of::<u32>();
-
-    pub fn raw(&self) -> u32 {
-        ((self.version_number as u32) << 29)
-            | ((self.packet_id.raw() as u32) << 16)
-            | self.psc.raw() as u32
-    }
-
-    pub fn to_bytes(&self, buf: &mut [u8]) {
-        let raw = self.raw();
-        buf.copy_from_slice(raw.to_be_bytes().as_slice());
-    }
-
-    pub fn from_bytes(buf: &[u8]) -> Option<Self> {
-        if buf.len() < 4 {
-            return None;
-        }
-        let raw = u32::from_be_bytes(buf[0..Self::SIZE_AS_BYTES].try_into().unwrap());
-        Some(Self {
-            version_number: ((raw >> 29) & 0b111) as u8,
-            packet_id: PacketId::from(((raw >> 16) & 0xffff) as u16),
-            psc: PacketSequenceCtrl::from((raw & 0xffff) as u16),
-        })
-    }
-}
-impl RequestId {
-    /// This allows extracting the request ID from a given PUS telecommand.
-    pub fn new(tc: &PusTc) -> Self {
-        RequestId {
-            version_number: tc.ccsds_version(),
-            packet_id: tc.packet_id(),
-            psc: tc.psc(),
-        }
-    }
-}
-
-/// Generic error type which is also able to wrap a user send error with the user supplied type E.
-#[derive(Debug, Clone)]
-pub enum VerificationError<E> {
-    /// Errors related to sending the verification telemetry to a TM recipient
-    SendError(E),
-    /// Errors related to the time stamp format of the telemetry
-    TimestampError(TimestampError),
-    /// Errors related to byte conversion, for example unsufficient buffer size for given data
-    ByteConversionError(ByteConversionError),
-    /// Errors related to PUS packet format
-    PusError(PusError),
-}
-
-impl<E> From<ByteConversionError> for VerificationError<E> {
-    fn from(e: ByteConversionError) -> Self {
-        VerificationError::ByteConversionError(e)
-    }
-}
-
-/// If a verification operation fails, the passed token will be returned as well. This allows
-/// re-trying the operation at a later point.
-#[derive(Debug, Clone)]
-pub struct VerificationErrorWithToken<E, T>(VerificationError<E>, VerificationToken<T>);
-
-/// Generic trait for a user supplied sender object. This sender object is responsible for sending
-/// PUS Service 1 Verification Telemetry to a verification TM recipient. The [Downcast] trait
-/// is implemented to allow passing the sender as a boxed trait object and still retrieve the
-/// concrete type at a later point.
-pub trait VerificationSender<E>: Downcast + Send {
-    fn send_verification_tm(&mut self, tm: PusTm) -> Result<(), VerificationError<E>>;
-}
-
-impl_downcast!(VerificationSender<E>);
-
-/// Support token to allow type-state programming. This prevents calling the verification
-/// steps in an invalid order.
-#[derive(Debug, Clone, Copy, Eq, PartialEq)]
-pub struct VerificationToken<STATE> {
-    state: PhantomData<STATE>,
-    req_id: RequestId,
-}
-
-#[derive(Copy, Clone, Debug, Eq, PartialEq)]
-pub struct StateNone;
-#[derive(Copy, Clone, Debug, Eq, PartialEq)]
-pub struct StateAccepted;
-#[derive(Copy, Clone, Debug, Eq, PartialEq)]
-pub struct StateStarted;
-
-impl<STATE> VerificationToken<STATE> {
-    fn new(req_id: RequestId) -> VerificationToken<StateNone> {
-        VerificationToken {
-            state: PhantomData,
-            req_id,
-        }
-    }
-
-    pub fn req_id(&self) -> RequestId {
-        self.req_id
-    }
-}
-
-pub struct VerificationReporterCfg {
-    pub apid: u16,
-    pub dest_id: u16,
-    pub step_field_width: usize,
-    pub fail_code_field_width: usize,
-    pub max_fail_data_len: usize,
-}
-
-impl VerificationReporterCfg {
-    /// Create a new configuration for the verification reporter. This includes following parameters:
-    ///
-    /// 1. Destination ID and APID, which could remain constant after construction. These parameters
-    ///    can be tweaked in the reporter after construction.
-    /// 2. Maximum expected field sizes. The parameters of this configuration struct will be used
-    ///    to determine required maximum buffer sizes and there will be no addition allocation or
-    ///    configurable buffer parameters after [VerificationReporter] construction.
-    ///
-    /// This means the user has supply the maximum expected field sizes of verification messages
-    /// before constructing the reporter.
-    pub fn new(
-        apid: u16,
-        step_field_width: usize,
-        fail_code_field_width: usize,
-        max_fail_data_len: usize,
-    ) -> Self {
-        Self {
-            apid,
-            dest_id: 0,
-            step_field_width,
-            fail_code_field_width,
-            max_fail_data_len,
-        }
-    }
-}
-
-/// Composite helper struct to pass failure parameters to the [VerificationReporter]
-pub struct FailParams<'a> {
-    time_stamp: &'a [u8],
-    failure_code: &'a dyn EcssEnumeration,
-    failure_data: Option<&'a [u8]>,
-}
-
-impl<'a> FailParams<'a> {
-    pub fn new(
-        time_stamp: &'a [u8],
-        failure_code: &'a impl EcssEnumeration,
-        failure_data: Option<&'a [u8]>,
-    ) -> Self {
-        Self {
-            time_stamp,
-            failure_code,
-            failure_data,
-        }
-    }
-}
-
-/// Composite helper struct to pass step failure parameters to the [VerificationReporter]
-pub struct FailParamsWithStep<'a> {
-    bp: FailParams<'a>,
-    step: &'a dyn EcssEnumeration,
-}
-
-impl<'a> FailParamsWithStep<'a> {
-    pub fn new(
-        time_stamp: &'a [u8],
-        step: &'a impl EcssEnumeration,
-        failure_code: &'a impl EcssEnumeration,
-        failure_data: Option<&'a [u8]>,
-    ) -> Self {
-        Self {
-            bp: FailParams::new(time_stamp, failure_code, failure_data),
-            step,
-        }
-    }
-}
-
-/// Primary verification handler. It provides an API to send PUS 1 verification telemetry packets
-/// and verify the various steps of telecommand handling as specified in the PUS standard.
-pub struct VerificationReporter {
-    pub apid: u16,
-    pub dest_id: u16,
-    msg_count: u16,
-    source_data_buf: Vec<u8>,
-}
-
-impl VerificationReporter {
-    pub fn new(cfg: VerificationReporterCfg) -> Self {
-        Self {
-            apid: cfg.apid,
-            dest_id: cfg.dest_id,
-            msg_count: 0,
-            source_data_buf: vec![
-                0;
-                RequestId::SIZE_AS_BYTES
-                    + cfg.step_field_width as usize
-                    + cfg.fail_code_field_width as usize
-                    + cfg.max_fail_data_len
-            ],
-        }
-    }
-
-    pub fn allowed_source_data_len(&self) -> usize {
-        self.source_data_buf.capacity()
-    }
-
-    /// Initialize verification handling by passing a TC reference. This returns a token required
-    /// to call the acceptance functions
-    pub fn add_tc(&mut self, pus_tc: &PusTc) -> VerificationToken<StateNone> {
-        self.add_tc_with_req_id(RequestId::new(pus_tc))
-    }
-
-    /// Same as [Self::add_tc] but pass a request ID instead of the direct telecommand.
-    /// This can be useful if the executing thread does not have full access to the telecommand.
-    pub fn add_tc_with_req_id(&mut self, req_id: RequestId) -> VerificationToken<StateNone> {
-        VerificationToken::<StateNone>::new(req_id)
-    }
-
-    /// Package and send a PUS TM\[1, 1\] packet, see 8.1.2.1 of the PUS standard
-    pub fn acceptance_success<E>(
-        &mut self,
-        token: VerificationToken<StateNone>,
-        sender: &mut (impl VerificationSender<E> + ?Sized),
-        time_stamp: &[u8],
-    ) -> Result<VerificationToken<StateAccepted>, VerificationErrorWithToken<E, StateNone>> {
-        let tm = self
-            .create_pus_verif_success_tm(
-                1,
-                1,
-                &token.req_id,
-                time_stamp,
-                None::<&dyn EcssEnumeration>,
-            )
-            .map_err(|e| VerificationErrorWithToken(e, token))?;
-        sender
-            .send_verification_tm(tm)
-            .map_err(|e| VerificationErrorWithToken(e, token))?;
-        self.msg_count += 1;
-        Ok(VerificationToken {
-            state: PhantomData,
-            req_id: token.req_id,
-        })
-    }
-
-    /// Package and send a PUS TM\[1, 2\] packet, see 8.1.2.2 of the PUS standard
-    pub fn acceptance_failure<E>(
-        &mut self,
-        token: VerificationToken<StateNone>,
-        sender: &mut (impl VerificationSender<E> + ?Sized),
-        params: FailParams,
-    ) -> Result<(), VerificationErrorWithToken<E, StateNone>> {
-        let tm = self
-            .create_pus_verif_fail_tm(1, 2, &token.req_id, None::<&dyn EcssEnumeration>, &params)
-            .map_err(|e| VerificationErrorWithToken(e, token))?;
-        sender
-            .send_verification_tm(tm)
-            .map_err(|e| VerificationErrorWithToken(e, token))?;
-        self.msg_count += 1;
-        Ok(())
-    }
-
-    /// Package and send a PUS TM\[1, 3\] packet, see 8.1.2.3 of the PUS standard.
-    ///
-    /// Requires a token previously acquired by calling [Self::acceptance_success].
-    pub fn start_success<E>(
-        &mut self,
-        token: VerificationToken<StateAccepted>,
-        sender: &mut (impl VerificationSender<E> + ?Sized),
-        time_stamp: &[u8],
-    ) -> Result<VerificationToken<StateStarted>, VerificationErrorWithToken<E, StateAccepted>> {
-        let tm = self
-            .create_pus_verif_success_tm(
-                1,
-                3,
-                &token.req_id,
-                time_stamp,
-                None::<&dyn EcssEnumeration>,
-            )
-            .map_err(|e| VerificationErrorWithToken(e, token))?;
-        sender
-            .send_verification_tm(tm)
-            .map_err(|e| VerificationErrorWithToken(e, token))?;
-        self.msg_count += 1;
-        Ok(VerificationToken {
-            state: PhantomData,
-            req_id: token.req_id,
-        })
-    }
-
-    /// Package and send a PUS TM\[1, 4\] packet, see 8.1.2.4 of the PUS standard.
-    ///
-    /// Requires a token previously acquired by calling [Self::acceptance_success]. It consumes
-    /// the token because verification handling is done.
-    pub fn start_failure<E>(
-        &mut self,
-        token: VerificationToken<StateAccepted>,
-        sender: &mut (impl VerificationSender<E> + ?Sized),
-        params: FailParams,
-    ) -> Result<(), VerificationErrorWithToken<E, StateAccepted>> {
-        let tm = self
-            .create_pus_verif_fail_tm(1, 4, &token.req_id, None::<&dyn EcssEnumeration>, &params)
-            .map_err(|e| VerificationErrorWithToken(e, token))?;
-        sender
-            .send_verification_tm(tm)
-            .map_err(|e| VerificationErrorWithToken(e, token))?;
-        self.msg_count += 1;
-        Ok(())
-    }
-
-    /// Package and send a PUS TM\[1, 5\] packet, see 8.1.2.5 of the PUS standard.
-    ///
-    /// Requires a token previously acquired by calling [Self::start_success].
-    pub fn step_success<E>(
-        &mut self,
-        token: &VerificationToken<StateStarted>,
-        sender: &mut (impl VerificationSender<E> + ?Sized),
-        time_stamp: &[u8],
-        step: impl EcssEnumeration,
-    ) -> Result<(), VerificationError<E>> {
-        let tm = self.create_pus_verif_success_tm(1, 5, &token.req_id, time_stamp, Some(&step))?;
-        sender.send_verification_tm(tm)?;
-        self.msg_count += 1;
-        Ok(())
-    }
-
-    /// Package and send a PUS TM\[1, 6\] packet, see 8.1.2.6 of the PUS standard.
-    ///
-    /// Requires a token previously acquired by calling [Self::start_success]. It consumes the
-    /// token because verification handling is done.
-    pub fn step_failure<E>(
-        &mut self,
-        token: VerificationToken<StateStarted>,
-        sender: &mut (impl VerificationSender<E> + ?Sized),
-        params: FailParamsWithStep,
-    ) -> Result<(), VerificationErrorWithToken<E, StateStarted>> {
-        let tm = self
-            .create_pus_verif_fail_tm(1, 6, &token.req_id, Some(params.step), &params.bp)
-            .map_err(|e| VerificationErrorWithToken(e, token))?;
-        sender
-            .send_verification_tm(tm)
-            .map_err(|e| VerificationErrorWithToken(e, token))?;
-        self.msg_count += 1;
-        Ok(())
-    }
-
-    /// Package and send a PUS TM\[1, 7\] packet, see 8.1.2.7 of the PUS standard.
-    ///
-    /// Requires a token previously acquired by calling [Self::start_success]. It consumes the
-    /// token because verification handling is done.
-    pub fn completion_success<E>(
-        &mut self,
-        token: VerificationToken<StateStarted>,
-        sender: &mut (impl VerificationSender<E> + ?Sized),
-        time_stamp: &[u8],
-    ) -> Result<(), VerificationErrorWithToken<E, StateStarted>> {
-        let tm = self
-            .create_pus_verif_success_tm(
-                1,
-                7,
-                &token.req_id,
-                time_stamp,
-                None::<&dyn EcssEnumeration>,
-            )
-            .map_err(|e| VerificationErrorWithToken(e, token))?;
-        sender
-            .send_verification_tm(tm)
-            .map_err(|e| VerificationErrorWithToken(e, token))?;
-        self.msg_count += 1;
-        Ok(())
-    }
-
-    /// Package and send a PUS TM\[1, 8\] packet, see 8.1.2.8 of the PUS standard.
-    ///
-    /// Requires a token previously acquired by calling [Self::start_success]. It consumes the
-    /// token because verification handling is done.
-    pub fn completion_failure<E>(
-        &mut self,
-        token: VerificationToken<StateStarted>,
-        sender: &mut (impl VerificationSender<E> + ?Sized),
-        params: FailParams,
-    ) -> Result<(), VerificationErrorWithToken<E, StateStarted>> {
-        let tm = self
-            .create_pus_verif_fail_tm(1, 8, &token.req_id, None::<&dyn EcssEnumeration>, &params)
-            .map_err(|e| VerificationErrorWithToken(e, token))?;
-        sender
-            .send_verification_tm(tm)
-            .map_err(|e| VerificationErrorWithToken(e, token))?;
-        self.msg_count += 1;
-        Ok(())
-    }
-
-    fn create_pus_verif_success_tm<'a, E>(
-        &'a mut self,
-        service: u8,
-        subservice: u8,
-        req_id: &RequestId,
-        time_stamp: &'a [u8],
-        step: Option<&(impl EcssEnumeration + ?Sized)>,
-    ) -> Result<PusTm, VerificationError<E>> {
-        let mut source_data_len = size_of::<u32>();
-        if let Some(step) = step {
-            source_data_len += step.byte_width() as usize;
-        }
-        self.source_buffer_large_enough(source_data_len)?;
-        let mut idx = 0;
-        req_id.to_bytes(&mut self.source_data_buf[0..RequestId::SIZE_AS_BYTES]);
-        idx += RequestId::SIZE_AS_BYTES;
-        if let Some(step) = step {
-            // Size check was done beforehand
-            step.to_bytes(&mut self.source_data_buf[idx..idx + step.byte_width() as usize])
-                .unwrap();
-        }
-        let mut sp_header = SpHeader::tm(self.apid, 0, 0).unwrap();
-        Ok(self.create_pus_verif_tm_base(
-            service,
-            subservice,
-            &mut sp_header,
-            time_stamp,
-            source_data_len,
-        ))
-    }
-
-    fn create_pus_verif_fail_tm<'a, E>(
-        &'a mut self,
-        service: u8,
-        subservice: u8,
-        req_id: &RequestId,
-        step: Option<&(impl EcssEnumeration + ?Sized)>,
-        params: &'a FailParams,
-    ) -> Result<PusTm, VerificationError<E>> {
-        let mut idx = 0;
-        let mut source_data_len =
-            RequestId::SIZE_AS_BYTES + params.failure_code.byte_width() as usize;
-        if let Some(step) = step {
-            source_data_len += step.byte_width() as usize;
-        }
-        if let Some(failure_data) = params.failure_data {
-            source_data_len += failure_data.len();
-        }
-        self.source_buffer_large_enough(source_data_len)?;
-        req_id.to_bytes(&mut self.source_data_buf[0..RequestId::SIZE_AS_BYTES]);
-        idx += RequestId::SIZE_AS_BYTES;
-        if let Some(step) = step {
-            // Size check done beforehand
-            step.to_bytes(&mut self.source_data_buf[idx..idx + step.byte_width() as usize])
-                .unwrap();
-            idx += step.byte_width() as usize;
-        }
-        params.failure_code.to_bytes(
-            &mut self.source_data_buf[idx..idx + params.failure_code.byte_width() as usize],
-        )?;
-        idx += params.failure_code.byte_width() as usize;
-        if let Some(failure_data) = params.failure_data {
-            self.source_data_buf[idx..idx + failure_data.len()].copy_from_slice(failure_data);
-        }
-        let mut sp_header = SpHeader::tm(self.apid, 0, 0).unwrap();
-        Ok(self.create_pus_verif_tm_base(
-            service,
-            subservice,
-            &mut sp_header,
-            params.time_stamp,
-            source_data_len,
-        ))
-    }
-
-    fn source_buffer_large_enough<E>(&self, len: usize) -> Result<(), VerificationError<E>> {
-        if len > self.source_data_buf.capacity() {
-            return Err(VerificationError::ByteConversionError(
-                ByteConversionError::ToSliceTooSmall(SizeMissmatch {
-                    found: self.source_data_buf.capacity(),
-                    expected: len,
-                }),
-            ));
-        }
-        Ok(())
-    }
-
-    fn create_pus_verif_tm_base<'a>(
-        &'a mut self,
-        service: u8,
-        subservice: u8,
-        sp_header: &mut SpHeader,
-        time_stamp: &'a [u8],
-        source_data_len: usize,
-    ) -> PusTm {
-        let tm_sec_header = PusTmSecondaryHeader::new(
-            service,
-            subservice,
-            self.msg_count,
-            self.dest_id,
-            time_stamp,
-        );
-        PusTm::new(
-            sp_header,
-            tm_sec_header,
-            Some(&self.source_data_buf[0..source_data_len]),
-            true,
-        )
-    }
-}
-
-/// Helper object which caches the sender passed as a trait object. Provides the same
-/// API as [VerificationReporter] but without the explicit sender arguments.
-pub struct VerificationReporterWithSender<E> {
-    reporter: VerificationReporter,
-    pub sender: Box<dyn VerificationSender<E>>,
-}
-
-impl<E: 'static> VerificationReporterWithSender<E> {
-    pub fn new(cfg: VerificationReporterCfg, sender: Box<dyn VerificationSender<E>>) -> Self {
-        Self::new_from_reporter(VerificationReporter::new(cfg), sender)
-    }
-
-    pub fn new_from_reporter(
-        reporter: VerificationReporter,
-        sender: Box<dyn VerificationSender<E>>,
-    ) -> Self {
-        Self { reporter, sender }
-    }
-
-    delegate! {
-        to self.reporter {
-            pub fn add_tc(&mut self, pus_tc: &PusTc) -> VerificationToken<StateNone>;
-            pub fn add_tc_with_req_id(&mut self, req_id: RequestId) -> VerificationToken<StateNone>;
-        }
-    }
-
-    pub fn acceptance_success(
-        &mut self,
-        token: VerificationToken<StateNone>,
-        time_stamp: &[u8],
-    ) -> Result<VerificationToken<StateAccepted>, VerificationErrorWithToken<E, StateNone>> {
-        self.reporter
-            .acceptance_success(token, self.sender.as_mut(), time_stamp)
-    }
-
-    pub fn acceptance_failure(
-        &mut self,
-        token: VerificationToken<StateNone>,
-        params: FailParams,
-    ) -> Result<(), VerificationErrorWithToken<E, StateNone>> {
-        self.reporter
-            .acceptance_failure(token, self.sender.as_mut(), params)
-    }
-
-    pub fn start_success(
-        &mut self,
-        token: VerificationToken<StateAccepted>,
-        time_stamp: &[u8],
-    ) -> Result<VerificationToken<StateStarted>, VerificationErrorWithToken<E, StateAccepted>> {
-        self.reporter
-            .start_success(token, self.sender.as_mut(), time_stamp)
-    }
-
-    pub fn start_failure(
-        &mut self,
-        token: VerificationToken<StateAccepted>,
-        params: FailParams,
-    ) -> Result<(), VerificationErrorWithToken<E, StateAccepted>> {
-        self.reporter
-            .start_failure(token, self.sender.as_mut(), params)
-    }
-
-    pub fn step_success(
-        &mut self,
-        token: &VerificationToken<StateStarted>,
-        time_stamp: &[u8],
-        step: impl EcssEnumeration,
-    ) -> Result<(), VerificationError<E>> {
-        self.reporter
-            .step_success(token, self.sender.as_mut(), time_stamp, step)
-    }
-
-    pub fn step_failure(
-        &mut self,
-        token: VerificationToken<StateStarted>,
-        params: FailParamsWithStep,
-    ) -> Result<(), VerificationErrorWithToken<E, StateStarted>> {
-        self.reporter
-            .step_failure(token, self.sender.as_mut(), params)
-    }
-
-    pub fn completion_success(
-        &mut self,
-        token: VerificationToken<StateStarted>,
-        time_stamp: &[u8],
-    ) -> Result<(), VerificationErrorWithToken<E, StateStarted>> {
-        self.reporter
-            .completion_success(token, self.sender.as_mut(), time_stamp)
-    }
-
-    pub fn completion_failure(
-        &mut self,
-        token: VerificationToken<StateStarted>,
-        params: FailParams,
-    ) -> Result<(), VerificationErrorWithToken<E, StateStarted>> {
-        self.reporter
-            .completion_failure(token, self.sender.as_mut(), params)
-    }
-}
-
-#[cfg(feature = "std")]
-mod stdmod {
-    use crate::pool::{ShareablePoolProvider, SharedPool, StoreAddr, StoreError};
-    use crate::pus::verification::{
-        VerificationError, VerificationReporterWithSender, VerificationSender,
-    };
-    use delegate::delegate;
-    use spacepackets::tm::PusTm;
-    use std::sync::{mpsc, Arc, Mutex, RwLockWriteGuard};
-
-    pub type StdVerifReporterWithSender = VerificationReporterWithSender<StdVerifSenderError>;
-    pub type SharedStdVerifReporterWithSender = Arc<Mutex<StdVerifReporterWithSender>>;
-
-    #[derive(Debug, Eq, PartialEq)]
-    pub enum StdVerifSenderError {
-        PoisonError,
-        StoreError(StoreError),
-        RxDisconnected(StoreAddr),
-    }
-
-    impl From<StoreError> for StdVerifSenderError {
-        fn from(e: StoreError) -> Self {
-            StdVerifSenderError::StoreError(e)
-        }
-    }
-
-    impl From<StoreError> for VerificationError<StdVerifSenderError> {
-        fn from(e: StoreError) -> Self {
-            VerificationError::SendError(e.into())
-        }
-    }
-
-    trait SendBackend: Send {
-        fn send(&self, addr: StoreAddr) -> Result<(), StoreAddr>;
-    }
-
-    struct StdSenderBase<S> {
-        pub ignore_poison_error: bool,
-        tm_store: SharedPool,
-        tx: S,
-    }
-
-    impl<S: SendBackend> StdSenderBase<S> {
-        pub fn new(tm_store: SharedPool, tx: S) -> Self {
-            Self {
-                ignore_poison_error: false,
-                tm_store,
-                tx,
-            }
-        }
-    }
-
-    unsafe impl<S: Sync> Sync for StdSenderBase<S> {}
-    unsafe impl<S: Send> Send for StdSenderBase<S> {}
-
-    impl SendBackend for mpsc::Sender<StoreAddr> {
-        fn send(&self, addr: StoreAddr) -> Result<(), StoreAddr> {
-            self.send(addr).map_err(|_| addr)
-        }
-    }
-
-    pub struct MpscVerifSender {
-        base: StdSenderBase<mpsc::Sender<StoreAddr>>,
-    }
-
-    /// Verification sender with a [mpsc::Sender] backend.
-    /// It implements the [VerificationSender] trait to be used as PUS Verification TM sender.
-    impl MpscVerifSender {
-        pub fn new(tm_store: SharedPool, tx: mpsc::Sender<StoreAddr>) -> Self {
-            Self {
-                base: StdSenderBase::new(tm_store, tx),
-            }
-        }
-    }
-
-    //noinspection RsTraitImplementation
-    impl VerificationSender<StdVerifSenderError> for MpscVerifSender {
-        delegate!(
-            to self.base {
-                fn send_verification_tm(&mut self, tm: PusTm) -> Result<(), VerificationError<StdVerifSenderError>>;
-            }
-        );
-    }
-    unsafe impl Sync for MpscVerifSender {}
-    unsafe impl Send for MpscVerifSender {}
-
-    impl SendBackend for crossbeam_channel::Sender<StoreAddr> {
-        fn send(&self, addr: StoreAddr) -> Result<(), StoreAddr> {
-            self.send(addr).map_err(|_| addr)
-        }
-    }
-
-    /// Verification sender with a [crossbeam_channel::Sender] backend.
-    /// It implements the [VerificationSender] trait to be used as PUS Verification TM sender
-    pub struct CrossbeamVerifSender {
-        base: StdSenderBase<crossbeam_channel::Sender<StoreAddr>>,
-    }
-
-    impl CrossbeamVerifSender {
-        pub fn new(tm_store: SharedPool, tx: crossbeam_channel::Sender<StoreAddr>) -> Self {
-            Self {
-                base: StdSenderBase::new(tm_store, tx),
-            }
-        }
-    }
-
-    //noinspection RsTraitImplementation
-    impl VerificationSender<StdVerifSenderError> for CrossbeamVerifSender {
-        delegate!(
-            to self.base {
-                fn send_verification_tm(&mut self, tm: PusTm) -> Result<(), VerificationError<StdVerifSenderError>>;
-            }
-        );
-    }
-
-    unsafe impl Sync for CrossbeamVerifSender {}
-    unsafe impl Send for CrossbeamVerifSender {}
-
-    impl<S: SendBackend + 'static> VerificationSender<StdVerifSenderError> for StdSenderBase<S> {
-        fn send_verification_tm(
-            &mut self,
-            tm: PusTm,
-        ) -> Result<(), VerificationError<StdVerifSenderError>> {
-            let operation = |mut mg: RwLockWriteGuard<ShareablePoolProvider>| {
-                let (addr, buf) = mg.free_element(tm.len_packed())?;
-                tm.write_to(buf).map_err(VerificationError::PusError)?;
-                drop(mg);
-                self.tx.send(addr).map_err(|_| {
-                    VerificationError::SendError(StdVerifSenderError::RxDisconnected(addr))
-                })?;
-                Ok(())
-            };
-            match self.tm_store.write() {
-                Ok(lock) => operation(lock),
-                Err(poison_error) => {
-                    if self.ignore_poison_error {
-                        operation(poison_error.into_inner())
-                    } else {
-                        Err(VerificationError::SendError(
-                            StdVerifSenderError::PoisonError,
-                        ))
-                    }
-                }
-            }
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use crate::pus::verification::{
-        FailParams, FailParamsWithStep, RequestId, StateNone, VerificationError,
-        VerificationReporter, VerificationReporterCfg, VerificationReporterWithSender,
-        VerificationSender, VerificationToken,
-    };
-    use alloc::boxed::Box;
-    use alloc::format;
-    use alloc::vec::Vec;
-    use spacepackets::ecss::{EcssEnumU16, EcssEnumU32, EcssEnumU8, EcssEnumeration, PusPacket};
-    use spacepackets::tc::{PusTc, PusTcSecondaryHeader};
-    use spacepackets::tm::{PusTm, PusTmSecondaryHeaderT};
-    use spacepackets::{ByteConversionError, CcsdsPacket, SpHeader};
-    use std::collections::VecDeque;
-
-    const TEST_APID: u16 = 0x02;
-    const EMPTY_STAMP: [u8; 7] = [0; 7];
-
-    #[derive(Debug, Eq, PartialEq)]
-    struct TmInfo {
-        pub subservice: u8,
-        pub apid: u16,
-        pub msg_counter: u16,
-        pub dest_id: u16,
-        pub time_stamp: [u8; 7],
-        pub req_id: RequestId,
-        pub additional_data: Option<Vec<u8>>,
-    }
-
-    #[derive(Default)]
-    struct TestSender {
-        pub service_queue: VecDeque<TmInfo>,
-    }
-
-    impl VerificationSender<()> for TestSender {
-        fn send_verification_tm(&mut self, tm: PusTm) -> Result<(), VerificationError<()>> {
-            assert_eq!(PusPacket::service(&tm), 1);
-            assert!(tm.source_data().is_some());
-            let mut time_stamp = [0; 7];
-            time_stamp.clone_from_slice(&tm.time_stamp()[0..7]);
-            let src_data = tm.source_data().unwrap();
-            assert!(src_data.len() >= 4);
-            let req_id = RequestId::from_bytes(&src_data[0..RequestId::SIZE_AS_BYTES]).unwrap();
-            let mut vec = None;
-            if src_data.len() > 4 {
-                let mut new_vec = Vec::new();
-                new_vec.extend_from_slice(&src_data[RequestId::SIZE_AS_BYTES..]);
-                vec = Some(new_vec);
-            }
-            self.service_queue.push_back(TmInfo {
-                subservice: PusPacket::subservice(&tm),
-                apid: tm.apid(),
-                msg_counter: tm.msg_counter(),
-                dest_id: tm.dest_id(),
-                time_stamp,
-                req_id,
-                additional_data: vec,
-            });
-            Ok(())
-        }
-    }
-
-    #[derive(Debug, Copy, Clone, Eq, PartialEq)]
-    struct DummyError {}
-    #[derive(Default)]
-    struct FallibleSender {}
-
-    impl VerificationSender<DummyError> for FallibleSender {
-        fn send_verification_tm(&mut self, _: PusTm) -> Result<(), VerificationError<DummyError>> {
-            Err(VerificationError::SendError(DummyError {}))
-        }
-    }
-
-    struct TestBase<'a> {
-        vr: VerificationReporter,
-        #[allow(dead_code)]
-        tc: PusTc<'a>,
-    }
-
-    impl<'a> TestBase<'a> {
-        fn rep(&mut self) -> &mut VerificationReporter {
-            &mut self.vr
-        }
-    }
-    struct TestBaseWithHelper<'a, E> {
-        helper: VerificationReporterWithSender<E>,
-        #[allow(dead_code)]
-        tc: PusTc<'a>,
-    }
-
-    impl<'a, E> TestBaseWithHelper<'a, E> {
-        fn rep(&mut self) -> &mut VerificationReporter {
-            &mut self.helper.reporter
-        }
-    }
-
-    fn base_reporter() -> VerificationReporter {
-        let cfg = VerificationReporterCfg::new(TEST_APID, 1, 2, 8);
-        VerificationReporter::new(cfg)
-    }
-
-    fn base_tc_init(app_data: Option<&[u8]>) -> (PusTc, RequestId) {
-        let mut sph = SpHeader::tc(TEST_APID, 0x34, 0).unwrap();
-        let tc_header = PusTcSecondaryHeader::new_simple(17, 1);
-        let pus_tc = PusTc::new(&mut sph, tc_header, app_data, true);
-        let req_id = RequestId::new(&pus_tc);
-        (pus_tc, req_id)
-    }
-
-    fn base_init(api_sel: bool) -> (TestBase<'static>, VerificationToken<StateNone>) {
-        let mut reporter = base_reporter();
-        let (tc, req_id) = base_tc_init(None);
-        let init_tok;
-        if api_sel {
-            init_tok = reporter.add_tc_with_req_id(req_id);
-        } else {
-            init_tok = reporter.add_tc(&tc);
-        }
-        (TestBase { vr: reporter, tc }, init_tok)
-    }
-
-    fn base_with_helper_init() -> (
-        TestBaseWithHelper<'static, ()>,
-        VerificationToken<StateNone>,
-    ) {
-        let mut reporter = base_reporter();
-        let (tc, _) = base_tc_init(None);
-        let init_tok = reporter.add_tc(&tc);
-        let sender = TestSender::default();
-        let helper = VerificationReporterWithSender::new_from_reporter(reporter, Box::new(sender));
-        (TestBaseWithHelper { helper, tc }, init_tok)
-    }
-
-    fn acceptance_check(sender: &mut TestSender, req_id: &RequestId) {
-        let cmp_info = TmInfo {
-            time_stamp: EMPTY_STAMP,
-            subservice: 1,
-            dest_id: 0,
-            apid: TEST_APID,
-            msg_counter: 0,
-            additional_data: None,
-            req_id: req_id.clone(),
-        };
-        assert_eq!(sender.service_queue.len(), 1);
-        let info = sender.service_queue.pop_front().unwrap();
-        assert_eq!(info, cmp_info);
-    }
-
-    #[test]
-    fn test_basic_acceptance_success() {
-        let (mut b, tok) = base_init(false);
-        let mut sender = TestSender::default();
-        b.vr.acceptance_success(tok, &mut sender, &EMPTY_STAMP)
-            .expect("Sending acceptance success failed");
-        acceptance_check(&mut sender, &tok.req_id);
-    }
-
-    #[test]
-    fn test_basic_acceptance_success_with_helper() {
-        let (mut b, tok) = base_with_helper_init();
-        b.helper
-            .acceptance_success(tok, &EMPTY_STAMP)
-            .expect("Sending acceptance success failed");
-        let sender: &mut TestSender = b.helper.sender.downcast_mut().unwrap();
-        acceptance_check(sender, &tok.req_id);
-    }
-
-    #[test]
-    fn test_acceptance_send_fails() {
-        let (mut b, tok) = base_init(false);
-        let mut faulty_sender = FallibleSender::default();
-        let res =
-            b.vr.acceptance_success(tok, &mut faulty_sender, &EMPTY_STAMP);
-        assert!(res.is_err());
-        let err = res.unwrap_err();
-        assert_eq!(err.1, tok);
-        match err.0 {
-            VerificationError::SendError(e) => {
-                assert_eq!(e, DummyError {})
-            }
-            _ => panic!("{}", format!("Unexpected error {:?}", err.0)),
-        }
-    }
-
-    fn acceptance_fail_check(sender: &mut TestSender, req_id: RequestId, stamp_buf: [u8; 7]) {
-        let cmp_info = TmInfo {
-            time_stamp: stamp_buf,
-            subservice: 2,
-            dest_id: 5,
-            apid: TEST_APID,
-            msg_counter: 0,
-            additional_data: Some([0, 2].to_vec()),
-            req_id,
-        };
-        assert_eq!(sender.service_queue.len(), 1);
-        let info = sender.service_queue.pop_front().unwrap();
-        assert_eq!(info, cmp_info);
-    }
-
-    #[test]
-    fn test_basic_acceptance_failure() {
-        let (mut b, tok) = base_init(true);
-        b.rep().dest_id = 5;
-        let stamp_buf = [1, 2, 3, 4, 5, 6, 7];
-        let mut sender = TestSender::default();
-        let fail_code = EcssEnumU16::new(2);
-        let fail_params = FailParams::new(stamp_buf.as_slice(), &fail_code, None);
-        b.vr.acceptance_failure(tok, &mut sender, fail_params)
-            .expect("Sending acceptance success failed");
-        acceptance_fail_check(&mut sender, tok.req_id, stamp_buf);
-    }
-
-    #[test]
-    fn test_basic_acceptance_failure_with_helper() {
-        let (mut b, tok) = base_with_helper_init();
-        b.rep().dest_id = 5;
-        let stamp_buf = [1, 2, 3, 4, 5, 6, 7];
-        let fail_code = EcssEnumU16::new(2);
-        let fail_params = FailParams::new(stamp_buf.as_slice(), &fail_code, None);
-        b.helper
-            .acceptance_failure(tok, fail_params)
-            .expect("Sending acceptance success failed");
-        let sender: &mut TestSender = b.helper.sender.downcast_mut().unwrap();
-        acceptance_fail_check(sender, tok.req_id, stamp_buf);
-    }
-
-    #[test]
-    fn test_acceptance_fail_data_too_large() {
-        let (mut b, tok) = base_with_helper_init();
-        b.rep().dest_id = 5;
-        let stamp_buf = [1, 2, 3, 4, 5, 6, 7];
-        let fail_code = EcssEnumU16::new(2);
-        let fail_data: [u8; 16] = [0; 16];
-        // 4 req ID + 1 byte step + 2 byte error code + 8 byte fail data
-        assert_eq!(b.rep().allowed_source_data_len(), 15);
-        let fail_params =
-            FailParams::new(stamp_buf.as_slice(), &fail_code, Some(fail_data.as_slice()));
-        let res = b.helper.acceptance_failure(tok, fail_params);
-        assert!(res.is_err());
-        let err_with_token = res.unwrap_err();
-        assert_eq!(err_with_token.1, tok);
-        match err_with_token.0 {
-            VerificationError::ByteConversionError(e) => match e {
-                ByteConversionError::ToSliceTooSmall(missmatch) => {
-                    assert_eq!(
-                        missmatch.expected,
-                        fail_data.len() + RequestId::SIZE_AS_BYTES + fail_code.byte_width()
-                    );
-                    assert_eq!(missmatch.found, b.rep().allowed_source_data_len());
-                }
-                _ => {
-                    panic!("{}", format!("Unexpected error {:?}", e))
-                }
-            },
-            _ => {
-                panic!("{}", format!("Unexpected error {:?}", err_with_token.0))
-            }
-        }
-    }
-
-    #[test]
-    fn test_basic_acceptance_failure_with_fail_data() {
-        let (mut b, tok) = base_init(false);
-        let mut sender = TestSender::default();
-        let fail_code = EcssEnumU8::new(10);
-        let fail_data = EcssEnumU32::new(12);
-        let mut fail_data_raw = [0; 4];
-        fail_data.to_bytes(&mut fail_data_raw).unwrap();
-        let fail_params = FailParams::new(&EMPTY_STAMP, &fail_code, Some(fail_data_raw.as_slice()));
-        b.vr.acceptance_failure(tok, &mut sender, fail_params)
-            .expect("Sending acceptance success failed");
-        let cmp_info = TmInfo {
-            time_stamp: EMPTY_STAMP,
-            subservice: 2,
-            dest_id: 0,
-            apid: TEST_APID,
-            msg_counter: 0,
-            additional_data: Some([10, 0, 0, 0, 12].to_vec()),
-            req_id: tok.req_id,
-        };
-        assert_eq!(sender.service_queue.len(), 1);
-        let info = sender.service_queue.pop_front().unwrap();
-        assert_eq!(info, cmp_info);
-    }
-
-    fn start_fail_check(sender: &mut TestSender, req_id: RequestId, fail_data_raw: [u8; 4]) {
-        assert_eq!(sender.service_queue.len(), 2);
-        let mut cmp_info = TmInfo {
-            time_stamp: EMPTY_STAMP,
-            subservice: 1,
-            dest_id: 0,
-            apid: TEST_APID,
-            msg_counter: 0,
-            additional_data: None,
-            req_id,
-        };
-        let mut info = sender.service_queue.pop_front().unwrap();
-        assert_eq!(info, cmp_info);
-
-        cmp_info = TmInfo {
-            time_stamp: EMPTY_STAMP,
-            subservice: 4,
-            dest_id: 0,
-            apid: TEST_APID,
-            msg_counter: 1,
-            additional_data: Some([&[22], fail_data_raw.as_slice()].concat().to_vec()),
-            req_id,
-        };
-        info = sender.service_queue.pop_front().unwrap();
-        assert_eq!(info, cmp_info);
-    }
-
-    #[test]
-    fn test_start_failure() {
-        let (mut b, tok) = base_init(false);
-        let mut sender = TestSender::default();
-        let fail_code = EcssEnumU8::new(22);
-        let fail_data: i32 = -12;
-        let mut fail_data_raw = [0; 4];
-        fail_data_raw.copy_from_slice(fail_data.to_be_bytes().as_slice());
-        let fail_params = FailParams::new(&EMPTY_STAMP, &fail_code, Some(fail_data_raw.as_slice()));
-
-        let accepted_token =
-            b.vr.acceptance_success(tok, &mut sender, &EMPTY_STAMP)
-                .expect("Sending acceptance success failed");
-        let empty =
-            b.vr.start_failure(accepted_token, &mut sender, fail_params)
-                .expect("Start failure failure");
-        assert_eq!(empty, ());
-        start_fail_check(&mut sender, tok.req_id, fail_data_raw);
-    }
-
-    #[test]
-    fn test_start_failure_with_helper() {
-        let (mut b, tok) = base_with_helper_init();
-        let fail_code = EcssEnumU8::new(22);
-        let fail_data: i32 = -12;
-        let mut fail_data_raw = [0; 4];
-        fail_data_raw.copy_from_slice(fail_data.to_be_bytes().as_slice());
-        let fail_params = FailParams::new(&EMPTY_STAMP, &fail_code, Some(fail_data_raw.as_slice()));
-
-        let accepted_token = b
-            .helper
-            .acceptance_success(tok, &EMPTY_STAMP)
-            .expect("Sending acceptance success failed");
-        let empty = b
-            .helper
-            .start_failure(accepted_token, fail_params)
-            .expect("Start failure failure");
-        assert_eq!(empty, ());
-        let sender: &mut TestSender = b.helper.sender.downcast_mut().unwrap();
-        start_fail_check(sender, tok.req_id, fail_data_raw);
-    }
-
-    fn step_success_check(sender: &mut TestSender, req_id: RequestId) {
-        let mut cmp_info = TmInfo {
-            time_stamp: EMPTY_STAMP,
-            subservice: 1,
-            dest_id: 0,
-            apid: TEST_APID,
-            msg_counter: 0,
-            additional_data: None,
-            req_id,
-        };
-        let mut info = sender.service_queue.pop_front().unwrap();
-        assert_eq!(info, cmp_info);
-        cmp_info = TmInfo {
-            time_stamp: [0, 1, 0, 1, 0, 1, 0],
-            subservice: 3,
-            dest_id: 0,
-            apid: TEST_APID,
-            msg_counter: 1,
-            additional_data: None,
-            req_id,
-        };
-        info = sender.service_queue.pop_front().unwrap();
-        assert_eq!(info, cmp_info);
-        cmp_info = TmInfo {
-            time_stamp: EMPTY_STAMP,
-            subservice: 5,
-            dest_id: 0,
-            apid: TEST_APID,
-            msg_counter: 2,
-            additional_data: Some([0].to_vec()),
-            req_id,
-        };
-        info = sender.service_queue.pop_front().unwrap();
-        assert_eq!(info, cmp_info);
-        cmp_info = TmInfo {
-            time_stamp: EMPTY_STAMP,
-            subservice: 5,
-            dest_id: 0,
-            apid: TEST_APID,
-            msg_counter: 3,
-            additional_data: Some([1].to_vec()),
-            req_id,
-        };
-        info = sender.service_queue.pop_front().unwrap();
-        assert_eq!(info, cmp_info);
-    }
-
-    #[test]
-    fn test_steps_success() {
-        let (mut b, tok) = base_init(false);
-        let mut sender = TestSender::default();
-        let accepted_token = b
-            .rep()
-            .acceptance_success(tok, &mut sender, &EMPTY_STAMP)
-            .expect("Sending acceptance success failed");
-        let started_token = b
-            .rep()
-            .start_success(accepted_token, &mut sender, &[0, 1, 0, 1, 0, 1, 0])
-            .expect("Sending start success failed");
-        let mut empty = b
-            .rep()
-            .step_success(
-                &started_token,
-                &mut sender,
-                &EMPTY_STAMP,
-                EcssEnumU8::new(0),
-            )
-            .expect("Sending step 0 success failed");
-        assert_eq!(empty, ());
-        empty =
-            b.vr.step_success(
-                &started_token,
-                &mut sender,
-                &EMPTY_STAMP,
-                EcssEnumU8::new(1),
-            )
-            .expect("Sending step 1 success failed");
-        assert_eq!(empty, ());
-        assert_eq!(sender.service_queue.len(), 4);
-        step_success_check(&mut sender, tok.req_id);
-    }
-
-    #[test]
-    fn test_steps_success_with_helper() {
-        let (mut b, tok) = base_with_helper_init();
-        let accepted_token = b
-            .helper
-            .acceptance_success(tok, &EMPTY_STAMP)
-            .expect("Sending acceptance success failed");
-        let started_token = b
-            .helper
-            .start_success(accepted_token, &[0, 1, 0, 1, 0, 1, 0])
-            .expect("Sending start success failed");
-        let mut empty = b
-            .helper
-            .step_success(&started_token, &EMPTY_STAMP, EcssEnumU8::new(0))
-            .expect("Sending step 0 success failed");
-        assert_eq!(empty, ());
-        empty = b
-            .helper
-            .step_success(&started_token, &EMPTY_STAMP, EcssEnumU8::new(1))
-            .expect("Sending step 1 success failed");
-        assert_eq!(empty, ());
-        let sender: &mut TestSender = b.helper.sender.downcast_mut().unwrap();
-        assert_eq!(sender.service_queue.len(), 4);
-        step_success_check(sender, tok.req_id);
-    }
-
-    fn check_step_failure(sender: &mut TestSender, req_id: RequestId, fail_data_raw: [u8; 4]) {
-        assert_eq!(sender.service_queue.len(), 4);
-        let mut cmp_info = TmInfo {
-            time_stamp: EMPTY_STAMP,
-            subservice: 1,
-            dest_id: 0,
-            apid: TEST_APID,
-            msg_counter: 0,
-            additional_data: None,
-            req_id,
-        };
-        let mut info = sender.service_queue.pop_front().unwrap();
-        assert_eq!(info, cmp_info);
-
-        cmp_info = TmInfo {
-            time_stamp: [0, 1, 0, 1, 0, 1, 0],
-            subservice: 3,
-            dest_id: 0,
-            apid: TEST_APID,
-            msg_counter: 1,
-            additional_data: None,
-            req_id,
-        };
-        info = sender.service_queue.pop_front().unwrap();
-        assert_eq!(info, cmp_info);
-
-        cmp_info = TmInfo {
-            time_stamp: EMPTY_STAMP,
-            subservice: 5,
-            dest_id: 0,
-            apid: TEST_APID,
-            msg_counter: 2,
-            additional_data: Some([0].to_vec()),
-            req_id,
-        };
-        info = sender.service_queue.pop_front().unwrap();
-        assert_eq!(info, cmp_info);
-
-        cmp_info = TmInfo {
-            time_stamp: EMPTY_STAMP,
-            subservice: 6,
-            dest_id: 0,
-            apid: TEST_APID,
-            msg_counter: 3,
-            additional_data: Some(
-                [
-                    [1].as_slice(),
-                    &[0, 0, 0x10, 0x20],
-                    fail_data_raw.as_slice(),
-                ]
-                .concat()
-                .to_vec(),
-            ),
-            req_id,
-        };
-        info = sender.service_queue.pop_front().unwrap();
-        assert_eq!(info, cmp_info);
-    }
-
-    #[test]
-    fn test_step_failure() {
-        let (mut b, tok) = base_init(false);
-        let mut sender = TestSender::default();
-        let req_id = tok.req_id;
-        let fail_code = EcssEnumU32::new(0x1020);
-        let fail_data: f32 = -22.3232;
-        let mut fail_data_raw = [0; 4];
-        fail_data_raw.copy_from_slice(fail_data.to_be_bytes().as_slice());
-        let fail_step = EcssEnumU8::new(1);
-        let fail_params = FailParamsWithStep::new(
-            &EMPTY_STAMP,
-            &fail_step,
-            &fail_code,
-            Some(fail_data_raw.as_slice()),
-        );
-
-        let accepted_token =
-            b.vr.acceptance_success(tok, &mut sender, &EMPTY_STAMP)
-                .expect("Sending acceptance success failed");
-        let started_token =
-            b.vr.start_success(accepted_token, &mut sender, &[0, 1, 0, 1, 0, 1, 0])
-                .expect("Sending start success failed");
-        let mut empty =
-            b.vr.step_success(
-                &started_token,
-                &mut sender,
-                &EMPTY_STAMP,
-                EcssEnumU8::new(0),
-            )
-            .expect("Sending completion success failed");
-        assert_eq!(empty, ());
-        empty =
-            b.vr.step_failure(started_token, &mut sender, fail_params)
-                .expect("Step failure failed");
-        assert_eq!(empty, ());
-        check_step_failure(&mut sender, req_id, fail_data_raw);
-    }
-
-    #[test]
-    fn test_steps_failure_with_helper() {
-        let (mut b, tok) = base_with_helper_init();
-        let req_id = tok.req_id;
-        let fail_code = EcssEnumU32::new(0x1020);
-        let fail_data: f32 = -22.3232;
-        let mut fail_data_raw = [0; 4];
-        fail_data_raw.copy_from_slice(fail_data.to_be_bytes().as_slice());
-        let fail_step = EcssEnumU8::new(1);
-        let fail_params = FailParamsWithStep::new(
-            &EMPTY_STAMP,
-            &fail_step,
-            &fail_code,
-            Some(fail_data_raw.as_slice()),
-        );
-
-        let accepted_token = b
-            .helper
-            .acceptance_success(tok, &EMPTY_STAMP)
-            .expect("Sending acceptance success failed");
-        let started_token = b
-            .helper
-            .start_success(accepted_token, &[0, 1, 0, 1, 0, 1, 0])
-            .expect("Sending start success failed");
-        let mut empty = b
-            .helper
-            .step_success(&started_token, &EMPTY_STAMP, EcssEnumU8::new(0))
-            .expect("Sending completion success failed");
-        assert_eq!(empty, ());
-        empty = b
-            .helper
-            .step_failure(started_token, fail_params)
-            .expect("Step failure failed");
-        assert_eq!(empty, ());
-        let sender: &mut TestSender = b.helper.sender.downcast_mut().unwrap();
-        check_step_failure(sender, req_id, fail_data_raw);
-    }
-
-    fn completion_fail_check(sender: &mut TestSender, req_id: RequestId) {
-        assert_eq!(sender.service_queue.len(), 3);
-
-        let mut cmp_info = TmInfo {
-            time_stamp: EMPTY_STAMP,
-            subservice: 1,
-            dest_id: 0,
-            apid: TEST_APID,
-            msg_counter: 0,
-            additional_data: None,
-            req_id,
-        };
-        let mut info = sender.service_queue.pop_front().unwrap();
-        assert_eq!(info, cmp_info);
-
-        cmp_info = TmInfo {
-            time_stamp: [0, 1, 0, 1, 0, 1, 0],
-            subservice: 3,
-            dest_id: 0,
-            apid: TEST_APID,
-            msg_counter: 1,
-            additional_data: None,
-            req_id,
-        };
-        info = sender.service_queue.pop_front().unwrap();
-        assert_eq!(info, cmp_info);
-
-        cmp_info = TmInfo {
-            time_stamp: EMPTY_STAMP,
-            subservice: 8,
-            dest_id: 0,
-            apid: TEST_APID,
-            msg_counter: 2,
-            additional_data: Some([0, 0, 0x10, 0x20].to_vec()),
-            req_id,
-        };
-        info = sender.service_queue.pop_front().unwrap();
-        assert_eq!(info, cmp_info);
-    }
-
-    #[test]
-    fn test_completion_failure() {
-        let (mut b, tok) = base_init(false);
-        let mut sender = TestSender::default();
-        let req_id = tok.req_id;
-        let fail_code = EcssEnumU32::new(0x1020);
-        let fail_params = FailParams::new(&EMPTY_STAMP, &fail_code, None);
-
-        let accepted_token =
-            b.vr.acceptance_success(tok, &mut sender, &EMPTY_STAMP)
-                .expect("Sending acceptance success failed");
-        let started_token =
-            b.vr.start_success(accepted_token, &mut sender, &[0, 1, 0, 1, 0, 1, 0])
-                .expect("Sending start success failed");
-        let empty =
-            b.vr.completion_failure(started_token, &mut sender, fail_params)
-                .expect("Completion failure");
-        assert_eq!(empty, ());
-        completion_fail_check(&mut sender, req_id);
-    }
-
-    #[test]
-    fn test_completion_failure_with_helper() {
-        let (mut b, tok) = base_with_helper_init();
-        let req_id = tok.req_id;
-        let fail_code = EcssEnumU32::new(0x1020);
-        let fail_params = FailParams::new(&EMPTY_STAMP, &fail_code, None);
-
-        let accepted_token = b
-            .helper
-            .acceptance_success(tok, &EMPTY_STAMP)
-            .expect("Sending acceptance success failed");
-        let started_token = b
-            .helper
-            .start_success(accepted_token, &[0, 1, 0, 1, 0, 1, 0])
-            .expect("Sending start success failed");
-        let empty = b
-            .helper
-            .completion_failure(started_token, fail_params)
-            .expect("Completion failure");
-        assert_eq!(empty, ());
-        let sender: &mut TestSender = b.helper.sender.downcast_mut().unwrap();
-        completion_fail_check(sender, req_id);
-    }
-
-    fn completion_success_check(sender: &mut TestSender, req_id: RequestId) {
-        assert_eq!(sender.service_queue.len(), 3);
-        let cmp_info = TmInfo {
-            time_stamp: EMPTY_STAMP,
-            subservice: 1,
-            dest_id: 0,
-            apid: TEST_APID,
-            msg_counter: 0,
-            additional_data: None,
-            req_id,
-        };
-        let mut info = sender.service_queue.pop_front().unwrap();
-        assert_eq!(info, cmp_info);
-
-        let cmp_info = TmInfo {
-            time_stamp: [0, 1, 0, 1, 0, 1, 0],
-            subservice: 3,
-            dest_id: 0,
-            apid: TEST_APID,
-            msg_counter: 1,
-            additional_data: None,
-            req_id,
-        };
-        info = sender.service_queue.pop_front().unwrap();
-        assert_eq!(info, cmp_info);
-        let cmp_info = TmInfo {
-            time_stamp: EMPTY_STAMP,
-            subservice: 7,
-            dest_id: 0,
-            apid: TEST_APID,
-            msg_counter: 2,
-            additional_data: None,
-            req_id,
-        };
-        info = sender.service_queue.pop_front().unwrap();
-        assert_eq!(info, cmp_info);
-    }
-
-    #[test]
-    fn test_complete_success_sequence() {
-        let (mut b, tok) = base_init(false);
-        let mut sender = TestSender::default();
-        let accepted_token =
-            b.vr.acceptance_success(tok, &mut sender, &EMPTY_STAMP)
-                .expect("Sending acceptance success failed");
-        let started_token =
-            b.vr.start_success(accepted_token, &mut sender, &[0, 1, 0, 1, 0, 1, 0])
-                .expect("Sending start success failed");
-        let empty =
-            b.vr.completion_success(started_token, &mut sender, &EMPTY_STAMP)
-                .expect("Sending completion success failed");
-        assert_eq!(empty, ());
-        completion_success_check(&mut sender, tok.req_id);
-    }
-
-    #[test]
-    fn test_complete_success_sequence_with_helper() {
-        let (mut b, tok) = base_with_helper_init();
-        let accepted_token = b
-            .helper
-            .acceptance_success(tok, &EMPTY_STAMP)
-            .expect("Sending acceptance success failed");
-        let started_token = b
-            .helper
-            .start_success(accepted_token, &[0, 1, 0, 1, 0, 1, 0])
-            .expect("Sending start success failed");
-        let empty = b
-            .helper
-            .completion_success(started_token, &EMPTY_STAMP)
-            .expect("Sending completion success failed");
-        assert_eq!(empty, ());
-        let sender: &mut TestSender = b.helper.sender.downcast_mut().unwrap();
-        completion_success_check(sender, tok.req_id);
-    }
-}
diff --git a/fsrc-core/src/tmtc/mod.rs b/fsrc-core/src/tmtc/mod.rs
deleted file mode 100644
index b1d0b3d..0000000
--- a/fsrc-core/src/tmtc/mod.rs
+++ /dev/null
@@ -1,71 +0,0 @@
-//! Telemetry and Telecommanding (TMTC) module. Contains packet routing components with special
-//! support for CCSDS and ECSS packets.
-//!
-//! The distributor modules provided by this module use trait objects provided by the user to
-//! directly dispatch received packets to packet listeners based on packet fields like the CCSDS
-//! Application Process ID (APID) or the ECSS PUS service type. This allows for fast packet
-//! routing without the overhead and complication of using message queues. However, it also requires
-use crate::error::{FsrcErrorRaw, FsrcGroupIds};
-use downcast_rs::{impl_downcast, Downcast};
-use spacepackets::tc::PusTc;
-use spacepackets::SpHeader;
-
-#[cfg(feature = "alloc")]
-pub mod ccsds_distrib;
-#[cfg(feature = "alloc")]
-pub mod pus_distrib;
-pub mod tm_helper;
-
-pub use ccsds_distrib::{CcsdsDistributor, CcsdsError, CcsdsPacketHandler};
-pub use pus_distrib::{PusDistributor, PusServiceProvider};
-
-const _RAW_PACKET_ERROR: &str = "raw-tmtc";
-const _CCSDS_ERROR: &str = "ccsds-tmtc";
-const _PUS_ERROR: &str = "pus-tmtc";
-
-// TODO: A macro for general and unknown errors would be nice
-const _FROM_BYTES_SLICE_TOO_SMALL_ERROR: FsrcErrorRaw = FsrcErrorRaw::new(
-    FsrcGroupIds::Tmtc as u8,
-    0,
-    _RAW_PACKET_ERROR,
-    "FROM_BYTES_SLICE_TOO_SMALL_ERROR",
-);
-
-const _FROM_BYTES_ZEROCOPY_ERROR: FsrcErrorRaw = FsrcErrorRaw::new(
-    FsrcGroupIds::Tmtc as u8,
-    1,
-    _RAW_PACKET_ERROR,
-    "FROM_BYTES_ZEROCOPY_ERROR",
-);
-
-/// Generic trait for object which can receive any telecommands in form of a raw bytestream, with
-/// no assumptions about the received protocol.
-///
-/// This trait is implemented by both the [crate::tmtc::pus_distrib::PusDistributor] and the
-/// [crate::tmtc::ccsds_distrib::CcsdsDistributor]  which allows to pass the respective packets in
-/// raw byte format into them.
-pub trait ReceivesTc: Downcast {
-    type Error;
-    fn pass_tc(&mut self, tc_raw: &[u8]) -> Result<(), Self::Error>;
-}
-
-impl_downcast!(ReceivesTc assoc Error);
-
-/// Generic trait for object which can receive CCSDS space packets, for fsrc-example ECSS PUS packets
-/// for CCSDS File Delivery Protocol (CFDP) packets.
-///
-/// This trait is implemented by both the [crate::tmtc::pus_distrib::PusDistributor] and the
-/// [crate::tmtc::ccsds_distrib::CcsdsDistributor] which allows
-/// to pass the respective packets in raw byte format or in CCSDS format into them.
-pub trait ReceivesCcsdsTc {
-    type Error;
-    fn pass_ccsds(&mut self, header: &SpHeader, tc_raw: &[u8]) -> Result<(), Self::Error>;
-}
-
-/// Generic trait for objects which can receive ECSS PUS telecommands. This trait is
-/// implemented by the [crate::tmtc::pus_distrib::PusDistributor] objects to allow passing PUS TC
-/// packets into it.
-pub trait ReceivesEcssPusTc {
-    type Error;
-    fn pass_pus_tc(&mut self, header: &SpHeader, pus_tc: &PusTc) -> Result<(), Self::Error>;
-}
diff --git a/fsrc-core/src/tmtc/tm_helper.rs b/fsrc-core/src/tmtc/tm_helper.rs
deleted file mode 100644
index c8581bf..0000000
--- a/fsrc-core/src/tmtc/tm_helper.rs
+++ /dev/null
@@ -1,51 +0,0 @@
-use spacepackets::time::{CdsShortTimeProvider, TimeWriter};
-use spacepackets::tm::{PusTm, PusTmSecondaryHeader};
-use spacepackets::SpHeader;
-
-pub struct PusTmWithCdsShortHelper {
-    apid: u16,
-    cds_short_buf: [u8; 7],
-}
-
-impl PusTmWithCdsShortHelper {
-    pub fn new(apid: u16) -> Self {
-        Self {
-            apid,
-            cds_short_buf: [0; 7],
-        }
-    }
-
-    #[cfg(feature = "std")]
-    pub fn create_pus_tm_timestamp_now<'a>(
-        &'a mut self,
-        service: u8,
-        subservice: u8,
-        source_data: Option<&'a [u8]>,
-    ) -> PusTm {
-        let time_stamp = CdsShortTimeProvider::from_now().unwrap();
-        time_stamp.write_to_bytes(&mut self.cds_short_buf).unwrap();
-        self.create_pus_tm_common(service, subservice, source_data)
-    }
-
-    pub fn create_pus_tm_with_stamp<'a>(
-        &'a mut self,
-        service: u8,
-        subservice: u8,
-        source_data: Option<&'a [u8]>,
-        stamper: &CdsShortTimeProvider,
-    ) -> PusTm {
-        stamper.write_to_bytes(&mut self.cds_short_buf).unwrap();
-        self.create_pus_tm_common(service, subservice, source_data)
-    }
-
-    fn create_pus_tm_common<'a>(
-        &'a self,
-        service: u8,
-        subservice: u8,
-        source_data: Option<&'a [u8]>,
-    ) -> PusTm {
-        let mut reply_header = SpHeader::tm(self.apid, 0, 0).unwrap();
-        let tc_header = PusTmSecondaryHeader::new_simple(service, subservice, &self.cds_short_buf);
-        PusTm::new(&mut reply_header, tc_header, source_data, true)
-    }
-}
diff --git a/fsrc-core/tests/verification_test.rs b/fsrc-core/tests/verification_test.rs
deleted file mode 100644
index 22f351e..0000000
--- a/fsrc-core/tests/verification_test.rs
+++ /dev/null
@@ -1,188 +0,0 @@
-use fsrc_core::pool::{LocalPool, PoolCfg, PoolProvider, SharedPool};
-use fsrc_core::pus::verification::{
-    CrossbeamVerifSender, FailParams, RequestId, VerificationReporterCfg,
-    VerificationReporterWithSender,
-};
-use hashbrown::HashMap;
-use spacepackets::ecss::{EcssEnumU16, EcssEnumU8, PusPacket};
-use spacepackets::tc::{PusTc, PusTcSecondaryHeader};
-use spacepackets::tm::PusTm;
-use spacepackets::SpHeader;
-use std::sync::{Arc, Mutex, RwLock};
-use std::thread;
-use std::time::Duration;
-
-const TEST_APID: u16 = 0x03;
-const FIXED_STAMP: [u8; 7] = [0; 7];
-const PACKETS_SENT: u8 = 8;
-
-/// This test also shows how the verification report could be used in a multi-threaded context,
-/// wrapping it into an [Arc] and [Mutex] and then passing it to two threads.
-///
-///  - The first thread generates a acceptance, a start, two steps and one completion report
-///  - The second generates an acceptance and start success report and a completion failure
-///  - The third thread is the verification receiver. In the test case, it verifies the other two
-///    threads have sent the correct expected verification reports
-#[test]
-fn test_shared_reporter() {
-    let cfg = VerificationReporterCfg::new(TEST_APID, 1, 2, 8);
-    // Shared pool object to store the verification PUS telemetry
-    let pool_cfg = PoolCfg::new(vec![(10, 32), (10, 64), (10, 128), (10, 1024)]);
-    let shared_tm_pool: SharedPool =
-        Arc::new(RwLock::new(Box::new(LocalPool::new(pool_cfg.clone()))));
-    let shared_tc_pool_0 = Arc::new(RwLock::new(LocalPool::new(pool_cfg)));
-    let shared_tc_pool_1 = shared_tc_pool_0.clone();
-    let (tx, rx) = crossbeam_channel::bounded(5);
-    let sender = CrossbeamVerifSender::new(shared_tm_pool.clone(), tx.clone());
-    let reporter_with_sender_0 = Arc::new(Mutex::new(VerificationReporterWithSender::new(
-        cfg,
-        Box::new(sender),
-    )));
-    let reporter_with_sender_1 = reporter_with_sender_0.clone();
-    // For test purposes, we retrieve the request ID from the TCs and pass them to the receiver
-    // tread.
-    let req_id_0;
-    let req_id_1;
-
-    let (tx_tc_0, rx_tc_0) = crossbeam_channel::bounded(3);
-    let (tx_tc_1, rx_tc_1) = crossbeam_channel::bounded(3);
-    {
-        let mut tc_guard = shared_tc_pool_0.write().unwrap();
-        let mut sph = SpHeader::tc(TEST_APID, 0, 0).unwrap();
-        let tc_header = PusTcSecondaryHeader::new_simple(17, 1);
-        let pus_tc_0 = PusTc::new(&mut sph, tc_header, None, true);
-        req_id_0 = RequestId::new(&pus_tc_0);
-        let (addr, mut buf) = tc_guard.free_element(pus_tc_0.len_packed()).unwrap();
-        pus_tc_0.write_to(&mut buf).unwrap();
-        tx_tc_0.send(addr).unwrap();
-        let mut sph = SpHeader::tc(TEST_APID, 1, 0).unwrap();
-        let tc_header = PusTcSecondaryHeader::new_simple(5, 1);
-        let pus_tc_1 = PusTc::new(&mut sph, tc_header, None, true);
-        req_id_1 = RequestId::new(&pus_tc_1);
-        let (addr, mut buf) = tc_guard.free_element(pus_tc_0.len_packed()).unwrap();
-        pus_tc_1.write_to(&mut buf).unwrap();
-        tx_tc_1.send(addr).unwrap();
-    }
-    let verif_sender_0 = thread::spawn(move || {
-        let mut tc_buf: [u8; 1024] = [0; 1024];
-        let tc_addr = rx_tc_0
-            .recv_timeout(Duration::from_millis(20))
-            .expect("Receive timeout");
-        let tc_len;
-        {
-            let mut tc_guard = shared_tc_pool_0.write().unwrap();
-            let pg = tc_guard.read_with_guard(tc_addr);
-            let buf = pg.read().unwrap();
-            tc_len = buf.len();
-            tc_buf[0..tc_len].copy_from_slice(buf);
-        }
-        let (_tc, _) = PusTc::new_from_raw_slice(&tc_buf[0..tc_len]).unwrap();
-        let accepted_token;
-        {
-            let mut mg = reporter_with_sender_0.lock().expect("Locking mutex failed");
-            let token = mg.add_tc_with_req_id(req_id_0);
-            accepted_token = mg
-                .acceptance_success(token, &FIXED_STAMP)
-                .expect("Acceptance success failed");
-        }
-        // Do some start handling here
-        let started_token;
-        {
-            let mut mg = reporter_with_sender_0.lock().expect("Locking mutex failed");
-            started_token = mg
-                .start_success(accepted_token, &FIXED_STAMP)
-                .expect("Start success failed");
-            // Do some step handling here
-            mg.step_success(&started_token, &FIXED_STAMP, EcssEnumU8::new(0))
-                .expect("Start success failed");
-        }
-        // Finish up
-        let mut mg = reporter_with_sender_0.lock().expect("Locking mutex failed");
-        mg.step_success(&started_token, &FIXED_STAMP, EcssEnumU8::new(1))
-            .expect("Start success failed");
-        mg.completion_success(started_token, &FIXED_STAMP)
-            .expect("Completion success failed");
-    });
-
-    let verif_sender_1 = thread::spawn(move || {
-        let mut tc_buf: [u8; 1024] = [0; 1024];
-        let tc_addr = rx_tc_1
-            .recv_timeout(Duration::from_millis(20))
-            .expect("Receive timeout");
-        let tc_len;
-        {
-            let mut tc_guard = shared_tc_pool_1.write().unwrap();
-            let pg = tc_guard.read_with_guard(tc_addr);
-            let buf = pg.read().unwrap();
-            tc_len = buf.len();
-            tc_buf[0..tc_len].copy_from_slice(buf);
-        }
-        let (tc, _) = PusTc::new_from_raw_slice(&tc_buf[0..tc_len]).unwrap();
-        let mut mg = reporter_with_sender_1
-            .lock()
-            .expect("Locking reporter failed");
-        let token = mg.add_tc(&tc);
-        let accepted_token = mg
-            .acceptance_success(token, &FIXED_STAMP)
-            .expect("Acceptance success failed");
-        let started_token = mg
-            .start_success(accepted_token, &FIXED_STAMP)
-            .expect("Start success failed");
-        let fail_code = EcssEnumU16::new(2);
-        let params = FailParams::new(&FIXED_STAMP, &fail_code, None);
-        mg.completion_failure(started_token, params)
-            .expect("Completion success failed");
-    });
-
-    let verif_receiver = thread::spawn(move || {
-        let mut packet_counter = 0;
-        let mut tm_buf: [u8; 1024] = [0; 1024];
-        let mut verif_map = HashMap::new();
-        while packet_counter < PACKETS_SENT {
-            let verif_addr = rx
-                .recv_timeout(Duration::from_millis(50))
-                .expect("Packet reception timeout");
-            let tm_len;
-            {
-                let mut rg = shared_tm_pool.write().expect("Error locking shared pool");
-                let store_guard = rg.read_with_guard(verif_addr);
-                let slice = store_guard.read().expect("Error reading TM slice");
-                tm_len = slice.len();
-                tm_buf[0..tm_len].copy_from_slice(slice);
-            }
-            let (pus_tm, _) = PusTm::new_from_raw_slice(&tm_buf[0..tm_len], 7)
-                .expect("Error reading verification TM");
-            let req_id = RequestId::from_bytes(
-                &pus_tm.source_data().expect("Invalid TM source data")[0..RequestId::SIZE_AS_BYTES],
-            )
-            .unwrap();
-            if !verif_map.contains_key(&req_id) {
-                let mut content = Vec::new();
-                content.push(pus_tm.subservice());
-                verif_map.insert(req_id, content);
-            } else {
-                let content = verif_map.get_mut(&req_id).unwrap();
-                content.push(pus_tm.subservice())
-            }
-            packet_counter += 1;
-        }
-        for (req_id, content) in verif_map {
-            if req_id == req_id_1 {
-                assert_eq!(content[0], 1);
-                assert_eq!(content[1], 3);
-                assert_eq!(content[2], 8);
-            } else if req_id == req_id_0 {
-                assert_eq!(content[0], 1);
-                assert_eq!(content[1], 3);
-                assert_eq!(content[2], 5);
-                assert_eq!(content[3], 5);
-                assert_eq!(content[4], 7);
-            } else {
-                panic!("Unexpected request ID {:?}", req_id);
-            }
-        }
-    });
-    verif_sender_0.join().expect("Joining thread 0 failed");
-    verif_sender_1.join().expect("Joining thread 1 failed");
-    verif_receiver.join().expect("Joining thread 2 failed");
-}
diff --git a/fsrc-example/Cargo.toml b/fsrc-example/Cargo.toml
deleted file mode 100644
index 8bccc84..0000000
--- a/fsrc-example/Cargo.toml
+++ /dev/null
@@ -1,15 +0,0 @@
-[package]
-name = "fsrc-example"
-version = "0.1.0"
-edition = "2021"
-authors = ["Robin Mueller <muellerr@irs.uni-stuttgart.de>"]
-
-[dependencies]
-crossbeam-channel = "0.5"
-delegate = "0.8"
-
-[dependencies.spacepackets]
-path = "../spacepackets"
-
-[dependencies.fsrc-core]
-path = "../fsrc-core"
diff --git a/fsrc-example/src/bin/obsw/main.rs b/fsrc-example/src/bin/obsw/main.rs
deleted file mode 100644
index 00ad086..0000000
--- a/fsrc-example/src/bin/obsw/main.rs
+++ /dev/null
@@ -1,73 +0,0 @@
-mod ccsds;
-mod pus;
-mod tmtc;
-
-use crate::tmtc::{core_tmtc_task, TmStore, PUS_APID};
-use fsrc_core::hal::host::udp_server::UdpTcServer;
-use fsrc_core::pool::{LocalPool, PoolCfg, SharedPool, StoreAddr};
-use fsrc_core::pus::verification::{
-    MpscVerifSender, VerificationReporterCfg, VerificationReporterWithSender,
-};
-use fsrc_core::tmtc::CcsdsError;
-use fsrc_example::{OBSW_SERVER_ADDR, SERVER_PORT};
-use std::net::{IpAddr, SocketAddr};
-use std::sync::{mpsc, Arc, Mutex, RwLock};
-use std::thread;
-
-struct TmFunnel {
-    tm_funnel_rx: mpsc::Receiver<StoreAddr>,
-    tm_server_tx: mpsc::Sender<StoreAddr>,
-}
-
-struct UdpTmtcServer {
-    udp_tc_server: UdpTcServer<CcsdsError<()>>,
-    tm_rx: mpsc::Receiver<StoreAddr>,
-    tm_store: SharedPool,
-}
-
-unsafe impl Send for UdpTmtcServer {}
-
-fn main() {
-    println!("Running OBSW example");
-    let pool_cfg = PoolCfg::new(vec![(8, 32), (4, 64), (2, 128)]);
-    let tm_pool = LocalPool::new(pool_cfg);
-    let tm_store: SharedPool = Arc::new(RwLock::new(Box::new(tm_pool)));
-    let tm_store_helper = TmStore {
-        pool: tm_store.clone(),
-    };
-    let addr = SocketAddr::new(IpAddr::V4(OBSW_SERVER_ADDR), SERVER_PORT);
-    let (tm_funnel_tx, tm_funnel_rx) = mpsc::channel();
-    let (tm_server_tx, tm_server_rx) = mpsc::channel();
-    let sender = MpscVerifSender::new(tm_store.clone(), tm_funnel_tx.clone());
-    let verif_cfg = VerificationReporterCfg::new(PUS_APID, 1, 2, 8);
-    let reporter_with_sender_0 = Arc::new(Mutex::new(VerificationReporterWithSender::new(
-        verif_cfg,
-        Box::new(sender),
-    )));
-    let jh0 = thread::spawn(move || {
-        core_tmtc_task(
-            tm_funnel_tx.clone(),
-            tm_server_rx,
-            tm_store_helper.clone(),
-            addr,
-            reporter_with_sender_0,
-        );
-    });
-
-    let jh1 = thread::spawn(move || {
-        let tm_funnel = TmFunnel {
-            tm_server_tx,
-            tm_funnel_rx,
-        };
-        loop {
-            if let Ok(addr) = tm_funnel.tm_funnel_rx.recv() {
-                tm_funnel
-                    .tm_server_tx
-                    .send(addr)
-                    .expect("Sending TM to server failed");
-            }
-        }
-    });
-    jh0.join().expect("Joining UDP TMTC server thread failed");
-    jh1.join().expect("Joining TM Funnel thread failed");
-}
diff --git a/fsrc-example/src/bin/obsw/pus.rs b/fsrc-example/src/bin/obsw/pus.rs
deleted file mode 100644
index f4c59e3..0000000
--- a/fsrc-example/src/bin/obsw/pus.rs
+++ /dev/null
@@ -1,93 +0,0 @@
-use crate::tmtc::TmStore;
-use fsrc_core::pool::StoreAddr;
-use fsrc_core::pus::verification::{
-    SharedStdVerifReporterWithSender, StateAccepted, VerificationToken,
-};
-use fsrc_core::tmtc::tm_helper::PusTmWithCdsShortHelper;
-use fsrc_core::tmtc::PusServiceProvider;
-use spacepackets::tc::{PusTc, PusTcSecondaryHeaderT};
-use spacepackets::time::{CdsShortTimeProvider, TimeWriter};
-use spacepackets::SpHeader;
-use std::sync::mpsc;
-
-pub struct PusReceiver {
-    pub tm_helper: PusTmWithCdsShortHelper,
-    pub tm_tx: mpsc::Sender<StoreAddr>,
-    pub tm_store: TmStore,
-    pub verif_reporter: SharedStdVerifReporterWithSender,
-    stamper: CdsShortTimeProvider,
-    time_stamp: [u8; 7],
-}
-
-impl PusReceiver {
-    pub fn new(
-        apid: u16,
-        tm_tx: mpsc::Sender<StoreAddr>,
-        tm_store: TmStore,
-        verif_reporter: SharedStdVerifReporterWithSender,
-    ) -> Self {
-        Self {
-            tm_helper: PusTmWithCdsShortHelper::new(apid),
-            tm_tx,
-            tm_store,
-            verif_reporter,
-            stamper: CdsShortTimeProvider::default(),
-            time_stamp: [0; 7],
-        }
-    }
-}
-
-impl PusServiceProvider for PusReceiver {
-    type Error = ();
-
-    fn handle_pus_tc_packet(
-        &mut self,
-        service: u8,
-        _header: &SpHeader,
-        pus_tc: &PusTc,
-    ) -> Result<(), Self::Error> {
-        let mut reporter = self
-            .verif_reporter
-            .lock()
-            .expect("Locking Verification Reporter failed");
-        let init_token = reporter.add_tc(pus_tc);
-        self.stamper
-            .update_from_now()
-            .expect("Updating time for time stamp failed");
-        self.stamper
-            .write_to_bytes(&mut self.time_stamp)
-            .expect("Writing time stamp failed");
-        let accepted_token = reporter
-            .acceptance_success(init_token, &self.time_stamp)
-            .expect("Acceptance success failure");
-        drop(reporter);
-        if service == 17 {
-            self.handle_test_service(pus_tc, accepted_token);
-        }
-        Ok(())
-    }
-}
-
-impl PusReceiver {
-    fn handle_test_service(&mut self, pus_tc: &PusTc, token: VerificationToken<StateAccepted>) {
-        if pus_tc.subservice() == 1 {
-            println!("Received PUS ping command TC[17,1]");
-            println!("Sending ping reply PUS TM[17,2]");
-            let ping_reply = self.tm_helper.create_pus_tm_timestamp_now(17, 2, None);
-            let addr = self.tm_store.add_pus_tm(&ping_reply);
-            let mut reporter = self
-                .verif_reporter
-                .lock()
-                .expect("Error locking verification reporter");
-            let start_token = reporter
-                .start_success(token, &self.time_stamp)
-                .expect("Error sending start success");
-            self.tm_tx
-                .send(addr)
-                .expect("Sending TM to TM funnel failed");
-            reporter
-                .completion_success(start_token, &self.time_stamp)
-                .expect("Error sending completion success");
-        }
-    }
-}
diff --git a/fsrc-example/src/bin/obsw/tmtc.rs b/fsrc-example/src/bin/obsw/tmtc.rs
deleted file mode 100644
index 5a34d1e..0000000
--- a/fsrc-example/src/bin/obsw/tmtc.rs
+++ /dev/null
@@ -1,110 +0,0 @@
-use fsrc_core::hal::host::udp_server::{ReceiveResult, UdpTcServer};
-use std::net::SocketAddr;
-use std::sync::mpsc;
-use std::thread;
-use std::time::Duration;
-
-use crate::ccsds::CcsdsReceiver;
-use crate::pus::PusReceiver;
-use crate::UdpTmtcServer;
-use fsrc_core::pool::{SharedPool, StoreAddr};
-use fsrc_core::pus::verification::SharedStdVerifReporterWithSender;
-use fsrc_core::tmtc::{CcsdsDistributor, CcsdsError, PusDistributor};
-use spacepackets::tm::PusTm;
-
-pub const PUS_APID: u16 = 0x02;
-
-#[derive(Clone)]
-pub struct TmStore {
-    pub pool: SharedPool,
-}
-
-impl TmStore {
-    pub fn add_pus_tm(&mut self, pus_tm: &PusTm) -> StoreAddr {
-        let mut pg = self.pool.write().expect("Error locking TM store");
-        let (addr, buf) = pg.free_element(pus_tm.len_packed()).expect("Store error");
-        pus_tm
-            .write_to(buf)
-            .expect("Writing PUS TM to store failed");
-        addr
-    }
-}
-
-pub fn core_tmtc_task(
-    tm_creator_tx: mpsc::Sender<StoreAddr>,
-    tm_server_rx: mpsc::Receiver<StoreAddr>,
-    tm_store_helper: TmStore,
-    addr: SocketAddr,
-    verif_reporter: SharedStdVerifReporterWithSender,
-) {
-    let pus_receiver = PusReceiver::new(
-        PUS_APID,
-        tm_creator_tx,
-        tm_store_helper.clone(),
-        verif_reporter,
-    );
-    let pus_distributor = PusDistributor::new(Box::new(pus_receiver));
-    let ccsds_receiver = CcsdsReceiver {
-        pus_handler: pus_distributor,
-    };
-    let ccsds_distributor = CcsdsDistributor::new(Box::new(ccsds_receiver));
-    let udp_tc_server = UdpTcServer::new(addr, 2048, Box::new(ccsds_distributor))
-        .expect("Creating UDP TMTC server failed");
-
-    let mut udp_tmtc_server = UdpTmtcServer {
-        udp_tc_server,
-        tm_rx: tm_server_rx,
-        tm_store: tm_store_helper.pool.clone(),
-    };
-    loop {
-        core_tmtc_loop(&mut udp_tmtc_server);
-        thread::sleep(Duration::from_millis(400));
-    }
-}
-
-fn core_tmtc_loop(udp_tmtc_server: &mut UdpTmtcServer) {
-    while core_tc_handling(udp_tmtc_server) {}
-    if let Some(recv_addr) = udp_tmtc_server.udp_tc_server.last_sender() {
-        core_tm_handling(udp_tmtc_server, &recv_addr);
-    }
-}
-
-fn core_tc_handling(udp_tmtc_server: &mut UdpTmtcServer) -> bool {
-    match udp_tmtc_server.udp_tc_server.try_recv_tc() {
-        Ok(_) => true,
-        Err(e) => match e {
-            ReceiveResult::ReceiverError(e) => match e {
-                CcsdsError::PacketError(e) => {
-                    println!("Got packet error: {e:?}");
-                    true
-                }
-                CcsdsError::CustomError(_) => {
-                    println!("Unknown receiver error");
-                    true
-                }
-            },
-            ReceiveResult::IoError(e) => {
-                println!("IO error {e}");
-                false
-            }
-            ReceiveResult::NothingReceived => false,
-        },
-    }
-}
-
-fn core_tm_handling(udp_tmtc_server: &mut UdpTmtcServer, recv_addr: &SocketAddr) {
-    while let Ok(addr) = udp_tmtc_server.tm_rx.try_recv() {
-        let mut store_lock = udp_tmtc_server
-            .tm_store
-            .write()
-            .expect("Locking TM store failed");
-        let pg = store_lock.read_with_guard(addr);
-        let buf = pg.read().expect("Error reading TM pool data");
-        println!("Sending TM");
-        udp_tmtc_server
-            .udp_tc_server
-            .socket
-            .send_to(buf, recv_addr)
-            .expect("Sending TM failed");
-    }
-}
diff --git a/fsrc-example/src/lib.rs b/fsrc-example/src/lib.rs
deleted file mode 100644
index b1bb894..0000000
--- a/fsrc-example/src/lib.rs
+++ /dev/null
@@ -1,4 +0,0 @@
-use std::net::Ipv4Addr;
-
-pub const OBSW_SERVER_ADDR: Ipv4Addr = Ipv4Addr::new(127, 0, 0, 1);
-pub const SERVER_PORT: u16 = 7301;
diff --git a/satrs-core/.gitignore b/satrs-core/.gitignore
new file mode 100644
index 0000000..e5a3461
--- /dev/null
+++ b/satrs-core/.gitignore
@@ -0,0 +1,5 @@
+/target
+
+# CLion
+/.idea/*
+!/.idea/runConfigurations
diff --git a/satrs-core/CHANGELOG.md b/satrs-core/CHANGELOG.md
new file mode 100644
index 0000000..68e54a2
--- /dev/null
+++ b/satrs-core/CHANGELOG.md
@@ -0,0 +1,9 @@
+Change Log
+=======
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](http://keepachangelog.com/)
+and this project adheres to [Semantic Versioning](http://semver.org/).
+
+# [unreleased]
diff --git a/satrs-core/Cargo.toml b/satrs-core/Cargo.toml
new file mode 100644
index 0000000..22e9d5b
--- /dev/null
+++ b/satrs-core/Cargo.toml
@@ -0,0 +1,106 @@
+[package]
+name = "satrs-core"
+version = "0.1.0-alpha.0"
+edition = "2021"
+rust-version = "1.61"
+authors = ["Robin Mueller <muellerr@irs.uni-stuttgart.de>"]
+description = "Core components of the sat-rs framework to build software for remote systems"
+homepage = "https://egit.irs.uni-stuttgart.de/rust/satrs-core"
+repository = "https://egit.irs.uni-stuttgart.de/rust/satrs-core"
+license = "Apache-2.0"
+keywords = ["no-std", "space", "aerospace"]
+categories = ["aerospace", "aerospace::space-protocols", "no-std", "hardware-support", "embedded"]
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+delegate = ">=0.8, <0.11"
+paste = "1"
+embed-doc-image = "0.1"
+
+[dependencies.num_enum]
+version = "0.6"
+default-features = false
+
+[dependencies.dyn-clone]
+version = "1"
+optional = true
+
+[dependencies.hashbrown]
+version = "0.14"
+optional = true
+
+[dependencies.heapless]
+version = "0.7"
+optional = true
+
+[dependencies.num-traits]
+version = "0.2"
+default-features = false
+
+[dependencies.downcast-rs]
+version = "1.2"
+default-features = false
+optional = true
+
+[dependencies.bus]
+version = "2.2"
+optional = true
+
+[dependencies.crossbeam-channel]
+version= "0.5"
+default-features = false
+optional = true
+
+[dependencies.thiserror]
+version = "1"
+optional = true
+
+[dependencies.serde]
+version = "1"
+default-features = false
+optional = true
+
+[dependencies.spacepackets]
+# version = "0.6"
+# path = "../spacepackets"
+git = "https://egit.irs.uni-stuttgart.de/rust/spacepackets.git"
+rev = "784564a20ed"
+default-features = false
+
+[dev-dependencies]
+serde = "1"
+zerocopy = "0.6"
+once_cell = "1.13"
+serde_json = "1"
+
+[dev-dependencies.postcard]
+version = "1"
+
+[features]
+default = ["std"]
+std = [
+	"downcast-rs/std",
+	"alloc",
+	"bus",
+	"postcard/use-std",
+	"crossbeam-channel/std",
+	"serde/std",
+	"spacepackets/std",
+	"num_enum/std",
+	"thiserror"
+]
+alloc = [
+	"serde/alloc",
+	"spacepackets/alloc",
+	"hashbrown",
+	"dyn-clone",
+	"downcast-rs"
+]
+serde = ["dep:serde", "spacepackets/serde"]
+crossbeam = ["crossbeam-channel"]
+heapless = ["dep:heapless"]
+doc-images = []
+
+[package.metadata.docs.rs]
+all-features = true
+rustdoc-args = ["--cfg", "doc_cfg"]
diff --git a/satrs-core/LICENSE-APACHE b/satrs-core/LICENSE-APACHE
new file mode 100644
index 0000000..16fe87b
--- /dev/null
+++ b/satrs-core/LICENSE-APACHE
@@ -0,0 +1,201 @@
+                              Apache License
+                        Version 2.0, January 2004
+                     http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+   "License" shall mean the terms and conditions for use, reproduction,
+   and distribution as defined by Sections 1 through 9 of this document.
+
+   "Licensor" shall mean the copyright owner or entity authorized by
+   the copyright owner that is granting the License.
+
+   "Legal Entity" shall mean the union of the acting entity and all
+   other entities that control, are controlled by, or are under common
+   control with that entity. For the purposes of this definition,
+   "control" means (i) the power, direct or indirect, to cause the
+   direction or management of such entity, whether by contract or
+   otherwise, or (ii) ownership of fifty percent (50%) or more of the
+   outstanding shares, or (iii) beneficial ownership of such entity.
+
+   "You" (or "Your") shall mean an individual or Legal Entity
+   exercising permissions granted by this License.
+
+   "Source" form shall mean the preferred form for making modifications,
+   including but not limited to software source code, documentation
+   source, and configuration files.
+
+   "Object" form shall mean any form resulting from mechanical
+   transformation or translation of a Source form, including but
+   not limited to compiled object code, generated documentation,
+   and conversions to other media types.
+
+   "Work" shall mean the work of authorship, whether in Source or
+   Object form, made available under the License, as indicated by a
+   copyright notice that is included in or attached to the work
+   (an example is provided in the Appendix below).
+
+   "Derivative Works" shall mean any work, whether in Source or Object
+   form, that is based on (or derived from) the Work and for which the
+   editorial revisions, annotations, elaborations, or other modifications
+   represent, as a whole, an original work of authorship. For the purposes
+   of this License, Derivative Works shall not include works that remain
+   separable from, or merely link (or bind by name) to the interfaces of,
+   the Work and Derivative Works thereof.
+
+   "Contribution" shall mean any work of authorship, including
+   the original version of the Work and any modifications or additions
+   to that Work or Derivative Works thereof, that is intentionally
+   submitted to Licensor for inclusion in the Work by the copyright owner
+   or by an individual or Legal Entity authorized to submit on behalf of
+   the copyright owner. For the purposes of this definition, "submitted"
+   means any form of electronic, verbal, or written communication sent
+   to the Licensor or its representatives, including but not limited to
+   communication on electronic mailing lists, source code control systems,
+   and issue tracking systems that are managed by, or on behalf of, the
+   Licensor for the purpose of discussing and improving the Work, but
+   excluding communication that is conspicuously marked or otherwise
+   designated in writing by the copyright owner as "Not a Contribution."
+
+   "Contributor" shall mean Licensor and any individual or Legal Entity
+   on behalf of whom a Contribution has been received by Licensor and
+   subsequently incorporated within the Work.
+
+2. Grant of Copyright License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   copyright license to reproduce, prepare Derivative Works of,
+   publicly display, publicly perform, sublicense, and distribute the
+   Work and such Derivative Works in Source or Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   (except as stated in this section) patent license to make, have made,
+   use, offer to sell, sell, import, and otherwise transfer the Work,
+   where such license applies only to those patent claims licensable
+   by such Contributor that are necessarily infringed by their
+   Contribution(s) alone or by combination of their Contribution(s)
+   with the Work to which such Contribution(s) was submitted. If You
+   institute patent litigation against any entity (including a
+   cross-claim or counterclaim in a lawsuit) alleging that the Work
+   or a Contribution incorporated within the Work constitutes direct
+   or contributory patent infringement, then any patent licenses
+   granted to You under this License for that Work shall terminate
+   as of the date such litigation is filed.
+
+4. Redistribution. You may reproduce and distribute copies of the
+   Work or Derivative Works thereof in any medium, with or without
+   modifications, and in Source or Object form, provided that You
+   meet the following conditions:
+
+   (a) You must give any other recipients of the Work or
+       Derivative Works a copy of this License; and
+
+   (b) You must cause any modified files to carry prominent notices
+       stating that You changed the files; and
+
+   (c) You must retain, in the Source form of any Derivative Works
+       that You distribute, all copyright, patent, trademark, and
+       attribution notices from the Source form of the Work,
+       excluding those notices that do not pertain to any part of
+       the Derivative Works; and
+
+   (d) If the Work includes a "NOTICE" text file as part of its
+       distribution, then any Derivative Works that You distribute must
+       include a readable copy of the attribution notices contained
+       within such NOTICE file, excluding those notices that do not
+       pertain to any part of the Derivative Works, in at least one
+       of the following places: within a NOTICE text file distributed
+       as part of the Derivative Works; within the Source form or
+       documentation, if provided along with the Derivative Works; or,
+       within a display generated by the Derivative Works, if and
+       wherever such third-party notices normally appear. The contents
+       of the NOTICE file are for informational purposes only and
+       do not modify the License. You may add Your own attribution
+       notices within Derivative Works that You distribute, alongside
+       or as an addendum to the NOTICE text from the Work, provided
+       that such additional attribution notices cannot be construed
+       as modifying the License.
+
+   You may add Your own copyright statement to Your modifications and
+   may provide additional or different license terms and conditions
+   for use, reproduction, or distribution of Your modifications, or
+   for any such Derivative Works as a whole, provided Your use,
+   reproduction, and distribution of the Work otherwise complies with
+   the conditions stated in this License.
+
+5. Submission of Contributions. Unless You explicitly state otherwise,
+   any Contribution intentionally submitted for inclusion in the Work
+   by You to the Licensor shall be under the terms and conditions of
+   this License, without any additional terms or conditions.
+   Notwithstanding the above, nothing herein shall supersede or modify
+   the terms of any separate license agreement you may have executed
+   with Licensor regarding such Contributions.
+
+6. Trademarks. This License does not grant permission to use the trade
+   names, trademarks, service marks, or product names of the Licensor,
+   except as required for reasonable and customary use in describing the
+   origin of the Work and reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty. Unless required by applicable law or
+   agreed to in writing, Licensor provides the Work (and each
+   Contributor provides its Contributions) on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+   implied, including, without limitation, any warranties or conditions
+   of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+   PARTICULAR PURPOSE. You are solely responsible for determining the
+   appropriateness of using or redistributing the Work and assume any
+   risks associated with Your exercise of permissions under this License.
+
+8. Limitation of Liability. In no event and under no legal theory,
+   whether in tort (including negligence), contract, or otherwise,
+   unless required by applicable law (such as deliberate and grossly
+   negligent acts) or agreed to in writing, shall any Contributor be
+   liable to You for damages, including any direct, indirect, special,
+   incidental, or consequential damages of any character arising as a
+   result of this License or out of the use or inability to use the
+   Work (including but not limited to damages for loss of goodwill,
+   work stoppage, computer failure or malfunction, or any and all
+   other commercial damages or losses), even if such Contributor
+   has been advised of the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability. While redistributing
+   the Work or Derivative Works thereof, You may choose to offer,
+   and charge a fee for, acceptance of support, warranty, indemnity,
+   or other liability obligations and/or rights consistent with this
+   License. However, in accepting such obligations, You may act only
+   on Your own behalf and on Your sole responsibility, not on behalf
+   of any other Contributor, and only if You agree to indemnify,
+   defend, and hold each Contributor harmless for any liability
+   incurred by, or claims asserted against, such Contributor by reason
+   of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
+
+APPENDIX: How to apply the Apache License to your work.
+
+   To apply the Apache License to your work, attach the following
+   boilerplate notice, with the fields enclosed by brackets "[]"
+   replaced with your own identifying information. (Don't include
+   the brackets!)  The text should be enclosed in the appropriate
+   comment syntax for the file format. We also recommend that a
+   file or class name and description of purpose be included on the
+   same "printed page" as the copyright notice for easier
+   identification within third-party archives.
+
+Copyright [yyyy] [name of copyright owner]
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+	http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
diff --git a/satrs-core/NOTICE b/satrs-core/NOTICE
new file mode 100644
index 0000000..717a583
--- /dev/null
+++ b/satrs-core/NOTICE
@@ -0,0 +1 @@
+This software contains code developed at the University of Stuttgart's Institute of Space Systems.
diff --git a/satrs-core/README.md b/satrs-core/README.md
new file mode 100644
index 0000000..94299c8
--- /dev/null
+++ b/satrs-core/README.md
@@ -0,0 +1,5 @@
+satrs-core
+======
+
+This crate contains the core components of the sat-rs framework.
+You can find more information on [homepage](https://egit.irs.uni-stuttgart.de/rust/sat-rs)
diff --git a/satrs-core/images/event_man_arch.graphml b/satrs-core/images/event_man_arch.graphml
new file mode 100644
index 0000000..1336793
--- /dev/null
+++ b/satrs-core/images/event_man_arch.graphml
@@ -0,0 +1,259 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<graphml xmlns="http://graphml.graphdrawing.org/xmlns" xmlns:java="http://www.yworks.com/xml/yfiles-common/1.0/java" xmlns:sys="http://www.yworks.com/xml/yfiles-common/markup/primitives/2.0" xmlns:x="http://www.yworks.com/xml/yfiles-common/markup/2.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:y="http://www.yworks.com/xml/graphml" xmlns:yed="http://www.yworks.com/xml/yed/3" xsi:schemaLocation="http://graphml.graphdrawing.org/xmlns http://www.yworks.com/xml/schema/graphml/1.1/ygraphml.xsd">
+  <!--Created by yEd 3.22-->
+  <key attr.name="Description" attr.type="string" for="graph" id="d0"/>
+  <key for="port" id="d1" yfiles.type="portgraphics"/>
+  <key for="port" id="d2" yfiles.type="portgeometry"/>
+  <key for="port" id="d3" yfiles.type="portuserdata"/>
+  <key attr.name="url" attr.type="string" for="node" id="d4"/>
+  <key attr.name="description" attr.type="string" for="node" id="d5"/>
+  <key for="node" id="d6" yfiles.type="nodegraphics"/>
+  <key for="graphml" id="d7" yfiles.type="resources"/>
+  <key attr.name="url" attr.type="string" for="edge" id="d8"/>
+  <key attr.name="description" attr.type="string" for="edge" id="d9"/>
+  <key for="edge" id="d10" yfiles.type="edgegraphics"/>
+  <graph edgedefault="directed" id="G">
+    <data key="d0" xml:space="preserve"/>
+    <node id="n0">
+      <data key="d6">
+        <y:ShapeNode>
+          <y:Geometry height="509.9999999999999" width="768.7000000000003" x="579.3105418719211" y="304.7"/>
+          <y:Fill hasColor="false" transparent="false"/>
+          <y:BorderStyle color="#000000" raised="false" type="line" width="1.0"/>
+          <y:NodeLabel alignment="center" autoSizePolicy="content" fontFamily="Ubuntu" fontSize="16" fontStyle="plain" hasBackgroundColor="false" hasLineColor="false" height="21.936037063598633" horizontalTextPosition="center" iconTextGap="4" modelName="custom" textColor="#000000" verticalTextPosition="bottom" visible="true" width="150.1282958984375" x="26.197490701913352" xml:space="preserve" y="24.234711021505348">Example Event Flow<y:LabelModel><y:SmartNodeLabelModel distance="4.0"/></y:LabelModel><y:ModelParameter><y:SmartNodeLabelModelParameter labelRatioX="-0.5" labelRatioY="-0.5" nodeRatioX="-0.46591974671274444" nodeRatioY="-0.452480958781362" offsetX="0.0" offsetY="0.0" upX="0.0" upY="-1.0"/></y:ModelParameter></y:NodeLabel>
+          <y:Shape type="rectangle"/>
+        </y:ShapeNode>
+      </data>
+    </node>
+    <node id="n1">
+      <data key="d6">
+        <y:ShapeNode>
+          <y:Geometry height="60.0" width="203.0" x="814.0" y="506.6799999999999"/>
+          <y:Fill color="#FFFF00" transparent="false"/>
+          <y:BorderStyle color="#000000" raised="false" type="line" width="1.0"/>
+          <y:NodeLabel alignment="center" autoSizePolicy="content" fontFamily="Ubuntu" fontSize="12" fontStyle="plain" hasBackgroundColor="false" hasLineColor="false" height="17.452094078063965" horizontalTextPosition="center" iconTextGap="4" modelName="custom" textColor="#000000" verticalTextPosition="bottom" visible="true" width="86.21258544921875" x="58.393707275390625" xml:space="preserve" y="21.27395296096796">Event Manager<y:LabelModel><y:SmartNodeLabelModel distance="4.0"/></y:LabelModel><y:ModelParameter><y:SmartNodeLabelModelParameter labelRatioX="0.0" labelRatioY="0.0" nodeRatioX="0.0" nodeRatioY="0.0" offsetX="0.0" offsetY="0.0" upX="0.0" upY="-1.0"/></y:ModelParameter></y:NodeLabel>
+          <y:Shape type="rectangle"/>
+        </y:ShapeNode>
+      </data>
+    </node>
+    <node id="n2">
+      <data key="d6">
+        <y:ShapeNode>
+          <y:Geometry height="60.0" width="82.0" x="617.6" y="413.23"/>
+          <y:Fill color="#FF9900" transparent="false"/>
+          <y:BorderStyle color="#000000" raised="false" type="line" width="1.0"/>
+          <y:NodeLabel alignment="center" autoSizePolicy="content" fontFamily="Ubuntu" fontSize="12" fontStyle="plain" hasBackgroundColor="false" hasLineColor="false" height="30.90418815612793" horizontalTextPosition="center" iconTextGap="4" modelName="custom" textColor="#000000" verticalTextPosition="bottom" visible="true" width="55.120361328125" x="13.4398193359375" xml:space="preserve" y="14.547905921936035">Event
+Creator 0<y:LabelModel><y:SmartNodeLabelModel distance="4.0"/></y:LabelModel><y:ModelParameter><y:SmartNodeLabelModelParameter labelRatioX="0.0" labelRatioY="0.0" nodeRatioX="0.0" nodeRatioY="0.0" offsetX="0.0" offsetY="0.0" upX="0.0" upY="-1.0"/></y:ModelParameter></y:NodeLabel>
+          <y:Shape type="rectangle"/>
+        </y:ShapeNode>
+      </data>
+    </node>
+    <node id="n3">
+      <data key="d6">
+        <y:ShapeNode>
+          <y:Geometry height="60.0" width="76.55999999999995" x="988.5" y="335.62999999999994"/>
+          <y:Fill color="#FF9900" transparent="false"/>
+          <y:BorderStyle color="#000000" raised="false" type="line" width="1.0"/>
+          <y:NodeLabel alignment="center" autoSizePolicy="content" fontFamily="Ubuntu" fontSize="12" fontStyle="plain" hasBackgroundColor="false" hasLineColor="false" height="30.90418815612793" horizontalTextPosition="center" iconTextGap="4" modelName="custom" textColor="#000000" verticalTextPosition="bottom" visible="true" width="55.120361328125" x="10.719819335937473" xml:space="preserve" y="14.547905921936035">Event
+Creator 2<y:LabelModel><y:SmartNodeLabelModel distance="4.0"/></y:LabelModel><y:ModelParameter><y:SmartNodeLabelModelParameter labelRatioX="0.0" labelRatioY="0.0" nodeRatioX="0.0" nodeRatioY="0.0" offsetX="0.0" offsetY="0.0" upX="0.0" upY="-1.0"/></y:ModelParameter></y:NodeLabel>
+          <y:Shape type="rectangle"/>
+        </y:ShapeNode>
+      </data>
+    </node>
+    <node id="n4">
+      <data key="d6">
+        <y:ShapeNode>
+          <y:Geometry height="60.0" width="72.55999999999983" x="860.6610837438426" y="335.62999999999994"/>
+          <y:Fill color="#FF9900" transparent="false"/>
+          <y:BorderStyle color="#000000" raised="false" type="line" width="1.0"/>
+          <y:NodeLabel alignment="center" autoSizePolicy="content" fontFamily="Ubuntu" fontSize="12" fontStyle="plain" hasBackgroundColor="false" hasLineColor="false" height="30.90418815612793" horizontalTextPosition="center" iconTextGap="4" modelName="custom" textColor="#000000" verticalTextPosition="bottom" visible="true" width="55.120361328125" x="8.719819335937359" xml:space="preserve" y="14.547905921936035">Event
+Creator 1<y:LabelModel><y:SmartNodeLabelModel distance="4.0"/></y:LabelModel><y:ModelParameter><y:SmartNodeLabelModelParameter labelRatioX="0.0" labelRatioY="0.0" nodeRatioX="0.0" nodeRatioY="0.0" offsetX="0.0" offsetY="0.0" upX="0.0" upY="-1.0"/></y:ModelParameter></y:NodeLabel>
+          <y:Shape type="rectangle"/>
+        </y:ShapeNode>
+      </data>
+    </node>
+    <node id="n5">
+      <data key="d6">
+        <y:ShapeNode>
+          <y:Geometry height="60.0" width="87.27999999999997" x="1112.52" y="335.62999999999994"/>
+          <y:Fill color="#FF9900" transparent="false"/>
+          <y:BorderStyle color="#000000" raised="false" type="line" width="1.0"/>
+          <y:NodeLabel alignment="center" autoSizePolicy="content" fontFamily="Ubuntu" fontSize="12" fontStyle="plain" hasBackgroundColor="false" hasLineColor="false" height="30.90418815612793" horizontalTextPosition="center" iconTextGap="4" modelName="custom" textColor="#000000" verticalTextPosition="bottom" visible="true" width="55.120361328125" x="16.079819335937373" xml:space="preserve" y="14.547905921936035">Event
+Creator 3<y:LabelModel><y:SmartNodeLabelModel distance="4.0"/></y:LabelModel><y:ModelParameter><y:SmartNodeLabelModelParameter labelRatioX="0.0" labelRatioY="0.0" nodeRatioX="0.0" nodeRatioY="0.0" offsetX="0.0" offsetY="0.0" upX="0.0" upY="-1.0"/></y:ModelParameter></y:NodeLabel>
+          <y:Shape type="rectangle"/>
+        </y:ShapeNode>
+      </data>
+    </node>
+    <node id="n6">
+      <data key="d6">
+        <y:ShapeNode>
+          <y:Geometry height="60.0" width="126.0" x="781.0" y="620.26"/>
+          <y:Fill color="#FFCC00" transparent="false"/>
+          <y:BorderStyle color="#000000" raised="false" type="line" width="1.0"/>
+          <y:NodeLabel alignment="center" autoSizePolicy="content" fontFamily="Ubuntu" fontSize="12" fontStyle="plain" hasBackgroundColor="false" hasLineColor="false" height="30.90418815612793" horizontalTextPosition="center" iconTextGap="4" modelName="custom" textColor="#000000" verticalTextPosition="bottom" visible="true" width="92.78865051269531" x="16.605674743652344" xml:space="preserve" y="14.547905921936035">PUS Service 5
+Event Reporting
+<y:LabelModel><y:SmartNodeLabelModel distance="4.0"/></y:LabelModel><y:ModelParameter><y:SmartNodeLabelModelParameter labelRatioX="0.0" labelRatioY="0.0" nodeRatioX="0.0" nodeRatioY="0.0" offsetX="0.0" offsetY="0.0" upX="0.0" upY="-1.0"/></y:ModelParameter></y:NodeLabel>
+          <y:Shape type="rectangle"/>
+        </y:ShapeNode>
+      </data>
+    </node>
+    <node id="n7">
+      <data key="d6">
+        <y:ShapeNode>
+          <y:Geometry height="60.0" width="118.63999999999987" x="928.2" y="620.26"/>
+          <y:Fill color="#FFCC00" transparent="false"/>
+          <y:BorderStyle color="#000000" raised="false" type="line" width="1.0"/>
+          <y:NodeLabel alignment="center" autoSizePolicy="content" fontFamily="Ubuntu" fontSize="12" fontStyle="plain" hasBackgroundColor="false" hasLineColor="false" height="30.90418815612793" horizontalTextPosition="center" iconTextGap="4" modelName="custom" textColor="#000000" verticalTextPosition="bottom" visible="true" width="84.08859252929688" x="17.2757037353515" xml:space="preserve" y="14.547905921936035">PUS Service 19
+Event Action<y:LabelModel><y:SmartNodeLabelModel distance="4.0"/></y:LabelModel><y:ModelParameter><y:SmartNodeLabelModelParameter labelRatioX="0.0" labelRatioY="0.0" nodeRatioX="0.0" nodeRatioY="0.0" offsetX="0.0" offsetY="0.0" upX="0.0" upY="-1.0"/></y:ModelParameter></y:NodeLabel>
+          <y:Shape type="rectangle"/>
+        </y:ShapeNode>
+      </data>
+    </node>
+    <node id="n8">
+      <data key="d6">
+        <y:ShapeNode>
+          <y:Geometry height="60.0" width="87.27999999999997" x="792.1260377358491" y="733.8400000000001"/>
+          <y:Fill color="#FFCC99" transparent="false"/>
+          <y:BorderStyle color="#000000" raised="false" type="line" width="1.0"/>
+          <y:NodeLabel alignment="center" autoSizePolicy="content" fontFamily="Ubuntu" fontSize="12" fontStyle="plain" hasBackgroundColor="false" hasLineColor="false" height="30.90418815612793" horizontalTextPosition="center" iconTextGap="4" modelName="custom" textColor="#000000" verticalTextPosition="bottom" visible="true" width="59.932403564453125" x="13.673798217773424" xml:space="preserve" y="14.547905921936035">Telemetry
+Sink<y:LabelModel><y:SmartNodeLabelModel distance="4.0"/></y:LabelModel><y:ModelParameter><y:SmartNodeLabelModelParameter labelRatioX="0.0" labelRatioY="0.0" nodeRatioX="0.0" nodeRatioY="0.0" offsetX="0.0" offsetY="0.0" upX="0.0" upY="-1.0"/></y:ModelParameter></y:NodeLabel>
+          <y:Shape type="rectangle"/>
+        </y:ShapeNode>
+      </data>
+    </node>
+    <node id="n9">
+      <data key="d6">
+        <y:ShapeNode>
+          <y:Geometry height="170.79999999999995" width="210.80000000000018" x="1076.84" y="601.88"/>
+          <y:Fill hasColor="false" transparent="false"/>
+          <y:BorderStyle color="#000000" raised="false" type="line" width="1.0"/>
+          <y:NodeLabel alignment="left" autoSizePolicy="content" fontFamily="Dialog" fontSize="12" fontStyle="plain" hasBackgroundColor="false" hasLineColor="false" height="143.6875" horizontalTextPosition="center" iconTextGap="4" modelName="custom" textColor="#000000" verticalTextPosition="bottom" visible="true" width="181.591796875" x="8.373079774614325" xml:space="preserve" y="7.444138124199753">Subscriptions
+
+1. Event Creator 0 subscribes
+    for event 0
+2. Event Creator 1 subscribes
+    for event group 2
+3. PUS Service 5 handler
+    subscribes for all events
+4. PUS Service 19 handler
+    subscribes for all events<y:LabelModel><y:SmartNodeLabelModel distance="4.0"/></y:LabelModel><y:ModelParameter><y:SmartNodeLabelModelParameter labelRatioX="-0.5" labelRatioY="-0.5" nodeRatioX="-0.4602795077105583" nodeRatioY="-0.45641605313700395" offsetX="0.0" offsetY="0.0" upX="0.0" upY="-1.0"/></y:ModelParameter></y:NodeLabel>
+          <y:Shape type="rectangle"/>
+        </y:ShapeNode>
+      </data>
+    </node>
+    <edge id="e0" source="n4" target="n1">
+      <data key="d10">
+        <y:PolyLineEdge>
+          <y:Path sx="8.058916256157545" sy="0.0" tx="-10.5" ty="0.0"/>
+          <y:LineStyle color="#000000" type="line" width="1.0"/>
+          <y:Arrows source="none" target="standard"/>
+          <y:EdgeLabel alignment="center" configuration="AutoFlippingLabel" distance="2.0" fontFamily="Ubuntu" fontSize="12" fontStyle="plain" hasBackgroundColor="false" hasLineColor="false" height="30.90418815612793" horizontalTextPosition="center" iconTextGap="4" modelName="custom" preferredPlacement="anywhere" ratio="0.5" textColor="#000000" verticalTextPosition="bottom" visible="true" width="53.92036437988281" x="8.639817810058275" xml:space="preserve" y="29.00100609374465">event 1
+(group 1)<y:LabelModel><y:SmartEdgeLabelModel autoRotationEnabled="false" defaultAngle="0.0" defaultDistance="10.0"/></y:LabelModel><y:ModelParameter><y:SmartEdgeLabelModelParameter angle="6.283185307179586" distance="35.59999999999969" distanceToCenter="true" position="left" ratio="0.34252387409930674" segment="-1"/></y:ModelParameter><y:PreferredPlacementDescriptor angle="0.0" angleOffsetOnRightSide="0" angleReference="absolute" angleRotationOnRightSide="co" distance="-1.0" frozen="true" placement="anywhere" side="anywhere" sideReference="relative_to_edge_flow"/></y:EdgeLabel>
+          <y:BendStyle smoothed="false"/>
+        </y:PolyLineEdge>
+      </data>
+    </edge>
+    <edge id="e1" source="n2" target="n1">
+      <data key="d10">
+        <y:PolyLineEdge>
+          <y:Path sx="0.0" sy="11.93999999999994" tx="-83.5" ty="0.0">
+            <y:Point x="832.0" y="455.16999999999996"/>
+          </y:Path>
+          <y:LineStyle color="#000000" type="line" width="1.0"/>
+          <y:Arrows source="none" target="standard"/>
+          <y:EdgeLabel alignment="center" configuration="AutoFlippingLabel" distance="2.0" fontFamily="Ubuntu" fontSize="12" fontStyle="plain" hasBackgroundColor="false" hasLineColor="false" height="30.90418815612793" horizontalTextPosition="center" iconTextGap="4" modelName="custom" preferredPlacement="anywhere" ratio="0.5" textColor="#000000" verticalTextPosition="bottom" visible="true" width="53.92036437988281" x="25.334655000000453" xml:space="preserve" y="-40.972107505798476">event 0
+(group 0)<y:LabelModel><y:SmartEdgeLabelModel autoRotationEnabled="false" defaultAngle="0.0" defaultDistance="10.0"/></y:LabelModel><y:ModelParameter><y:SmartEdgeLabelModelParameter angle="6.283185307179586" distance="25.520000000000095" distanceToCenter="true" position="left" ratio="0.20267159489379444" segment="0"/></y:ModelParameter><y:PreferredPlacementDescriptor angle="0.0" angleOffsetOnRightSide="0" angleReference="absolute" angleRotationOnRightSide="co" distance="-1.0" frozen="true" placement="anywhere" side="anywhere" sideReference="relative_to_edge_flow"/></y:EdgeLabel>
+          <y:BendStyle smoothed="false"/>
+        </y:PolyLineEdge>
+      </data>
+    </edge>
+    <edge id="e2" source="n3" target="n1">
+      <data key="d10">
+        <y:PolyLineEdge>
+          <y:Path sx="-23.719999999999914" sy="5.5" tx="87.56000000000006" ty="0.0"/>
+          <y:LineStyle color="#000000" type="line" width="1.0"/>
+          <y:Arrows source="none" target="standard"/>
+          <y:EdgeLabel alignment="center" configuration="AutoFlippingLabel" distance="2.0" fontFamily="Ubuntu" fontSize="12" fontStyle="plain" hasBackgroundColor="false" hasLineColor="false" height="30.90418815612793" horizontalTextPosition="center" iconTextGap="4" modelName="custom" preferredPlacement="anywhere" ratio="0.5" textColor="#000000" verticalTextPosition="bottom" visible="true" width="53.92036437988281" x="5.6761352539062955" xml:space="preserve" y="27.551854405966765">event 2
+(group 3)<y:LabelModel><y:SmartEdgeLabelModel autoRotationEnabled="false" defaultAngle="0.0" defaultDistance="10.0"/></y:LabelModel><y:ModelParameter><y:SmartEdgeLabelModelParameter angle="6.283185307179586" distance="5.676132812499983" distanceToCenter="false" position="left" ratio="0.3219761157957032" segment="-1"/></y:ModelParameter><y:PreferredPlacementDescriptor angle="0.0" angleOffsetOnRightSide="0" angleReference="absolute" angleRotationOnRightSide="co" distance="-1.0" frozen="true" placement="anywhere" side="anywhere" sideReference="relative_to_edge_flow"/></y:EdgeLabel>
+          <y:BendStyle smoothed="false"/>
+        </y:PolyLineEdge>
+      </data>
+    </edge>
+    <edge id="e3" source="n5" target="n1">
+      <data key="d10">
+        <y:PolyLineEdge>
+          <y:Path sx="-6.275467980295616" sy="0.0" tx="57.5" ty="8.5">
+            <y:Point x="1149.8845320197042" y="545.1799999999998"/>
+          </y:Path>
+          <y:LineStyle color="#000000" type="line" width="1.0"/>
+          <y:Arrows source="none" target="standard"/>
+          <y:EdgeLabel alignment="center" configuration="AutoFlippingLabel" distance="2.0" fontFamily="Ubuntu" fontSize="12" fontStyle="plain" hasBackgroundColor="false" hasLineColor="false" height="30.90418815612793" horizontalTextPosition="center" iconTextGap="4" modelName="custom" preferredPlacement="anywhere" ratio="0.5" textColor="#000000" verticalTextPosition="bottom" visible="true" width="97.38468933105469" x="26.667665869801795" xml:space="preserve" y="43.287014528669715">event 3 (group 2)
+event 4 (group 2)<y:LabelModel><y:SmartEdgeLabelModel autoRotationEnabled="false" defaultAngle="0.0" defaultDistance="10.0"/></y:LabelModel><y:ModelParameter><y:SmartEdgeLabelModelParameter angle="6.283185307179586" distance="75.3599999999999" distanceToCenter="true" position="left" ratio="0.2967848459873102" segment="0"/></y:ModelParameter><y:PreferredPlacementDescriptor angle="0.0" angleOffsetOnRightSide="0" angleReference="absolute" angleRotationOnRightSide="co" distance="-1.0" frozen="true" placement="anywhere" side="anywhere" sideReference="relative_to_edge_flow"/></y:EdgeLabel>
+          <y:BendStyle smoothed="false"/>
+        </y:PolyLineEdge>
+      </data>
+    </edge>
+    <edge id="e4" source="n1" target="n6">
+      <data key="d10">
+        <y:PolyLineEdge>
+          <y:Path sx="-65.0" sy="0.0" tx="6.5" ty="0.0"/>
+          <y:LineStyle color="#000000" type="line" width="1.0"/>
+          <y:Arrows source="none" target="standard"/>
+          <y:EdgeLabel alignment="center" configuration="AutoFlippingLabel" distance="2.0" fontFamily="Ubuntu" fontSize="12" fontStyle="plain" hasBackgroundColor="false" hasLineColor="false" height="17.452094078063965" horizontalTextPosition="center" iconTextGap="4" modelName="custom" preferredPlacement="anywhere" ratio="0.5" textColor="#000000" verticalTextPosition="bottom" visible="true" width="83.16456604003906" x="-98.78228302001958" xml:space="preserve" y="16.63042580701972">&lt;&lt;all events&gt;&gt;<y:LabelModel><y:SmartEdgeLabelModel autoRotationEnabled="false" defaultAngle="0.0" defaultDistance="10.0"/></y:LabelModel><y:ModelParameter><y:SmartEdgeLabelModelParameter angle="6.283185307179586" distance="57.20000000000004" distanceToCenter="true" position="right" ratio="0.4441995640590947" segment="-1"/></y:ModelParameter><y:PreferredPlacementDescriptor angle="0.0" angleOffsetOnRightSide="0" angleReference="absolute" angleRotationOnRightSide="co" distance="-1.0" frozen="true" placement="anywhere" side="anywhere" sideReference="relative_to_edge_flow"/></y:EdgeLabel>
+          <y:BendStyle smoothed="false"/>
+        </y:PolyLineEdge>
+      </data>
+    </edge>
+    <edge id="e5" source="n1" target="n7">
+      <data key="d10">
+        <y:PolyLineEdge>
+          <y:Path sx="42.660000000000196" sy="0.0" tx="-29.359999999999786" ty="0.0"/>
+          <y:LineStyle color="#000000" type="line" width="1.0"/>
+          <y:Arrows source="none" target="standard"/>
+          <y:EdgeLabel alignment="center" configuration="AutoFlippingLabel" distance="2.0" fontFamily="Ubuntu" fontSize="12" fontStyle="plain" hasBackgroundColor="false" hasLineColor="false" height="17.452094078063965" horizontalTextPosition="center" iconTextGap="4" modelName="custom" preferredPlacement="anywhere" ratio="0.5" textColor="#000000" verticalTextPosition="bottom" visible="true" width="83.16456604003906" x="20.4177438354493" xml:space="preserve" y="17.885881494816203">&lt;&lt;all events&gt;&gt;<y:LabelModel><y:SmartEdgeLabelModel autoRotationEnabled="false" defaultAngle="0.0" defaultDistance="10.0"/></y:LabelModel><y:ModelParameter><y:SmartEdgeLabelModelParameter angle="6.283185307179586" distance="62.0" distanceToCenter="true" position="left" ratio="0.492249939452652" segment="-1"/></y:ModelParameter><y:PreferredPlacementDescriptor angle="0.0" angleOffsetOnRightSide="0" angleReference="absolute" angleRotationOnRightSide="co" distance="-1.0" frozen="true" placement="anywhere" side="anywhere" sideReference="relative_to_edge_flow"/></y:EdgeLabel>
+          <y:BendStyle smoothed="false"/>
+        </y:PolyLineEdge>
+      </data>
+    </edge>
+    <edge id="e6" source="n1" target="n2">
+      <data key="d10">
+        <y:PolyLineEdge>
+          <y:Path sx="0.0" sy="0.0" tx="0.0" ty="0.0">
+            <y:Point x="658.6" y="536.6799999999998"/>
+          </y:Path>
+          <y:LineStyle color="#000000" type="line" width="1.0"/>
+          <y:Arrows source="none" target="standard"/>
+          <y:EdgeLabel alignment="center" configuration="AutoFlippingLabel" distance="2.0" fontFamily="Ubuntu" fontSize="12" fontStyle="plain" hasBackgroundColor="false" hasLineColor="false" height="30.90418815612793" horizontalTextPosition="center" iconTextGap="4" modelName="custom" preferredPlacement="anywhere" ratio="0.5" textColor="#000000" verticalTextPosition="bottom" visible="true" width="44.69230651855469" x="-131.99129340961497" xml:space="preserve" y="-45.45208675384538">event 1
+event 2<y:LabelModel><y:SmartEdgeLabelModel autoRotationEnabled="false" defaultAngle="0.0" defaultDistance="10.0"/></y:LabelModel><y:ModelParameter><y:SmartEdgeLabelModelParameter angle="0.0" distance="30.0" distanceToCenter="true" position="right" ratio="0.6426904695623505" segment="0"/></y:ModelParameter><y:PreferredPlacementDescriptor angle="0.0" angleOffsetOnRightSide="0" angleReference="absolute" angleRotationOnRightSide="co" distance="-1.0" frozen="true" placement="anywhere" side="anywhere" sideReference="relative_to_edge_flow"/></y:EdgeLabel>
+          <y:BendStyle smoothed="false"/>
+        </y:PolyLineEdge>
+      </data>
+    </edge>
+    <edge id="e7" source="n1" target="n4">
+      <data key="d10">
+        <y:PolyLineEdge>
+          <y:Path sx="-35.69940886699487" sy="0.0" tx="-17.140492610837327" ty="1.5"/>
+          <y:LineStyle color="#000000" type="line" width="1.0"/>
+          <y:Arrows source="none" target="standard"/>
+          <y:EdgeLabel alignment="center" configuration="AutoFlippingLabel" distance="2.0" fontFamily="Ubuntu" fontSize="12" fontStyle="plain" hasBackgroundColor="false" hasLineColor="false" height="17.452094078063965" horizontalTextPosition="center" iconTextGap="4" modelName="custom" preferredPlacement="anywhere" ratio="0.5" textColor="#000000" verticalTextPosition="bottom" visible="true" width="46.14430236816406" x="-54.352158195608126" xml:space="preserve" y="-79.29459128622307">group 2<y:LabelModel><y:SmartEdgeLabelModel autoRotationEnabled="false" defaultAngle="0.0" defaultDistance="10.0"/></y:LabelModel><y:ModelParameter><y:SmartEdgeLabelModelParameter angle="6.283185307179586" distance="31.279999999999973" distanceToCenter="true" position="left" ratio="0.6800790648728832" segment="-1"/></y:ModelParameter><y:PreferredPlacementDescriptor angle="0.0" angleOffsetOnRightSide="0" angleReference="absolute" angleRotationOnRightSide="co" distance="-1.0" frozen="true" placement="anywhere" side="anywhere" sideReference="relative_to_edge_flow"/></y:EdgeLabel>
+          <y:BendStyle smoothed="false"/>
+        </y:PolyLineEdge>
+      </data>
+    </edge>
+    <edge id="e8" source="n6" target="n8">
+      <data key="d10">
+        <y:PolyLineEdge>
+          <y:Path sx="0.0" sy="0.0" tx="8.233962264150945" ty="-21.42352238805968"/>
+          <y:LineStyle color="#000000" type="line" width="1.0"/>
+          <y:Arrows source="none" target="standard"/>
+          <y:EdgeLabel alignment="center" configuration="AutoFlippingLabel" distance="2.0" fontFamily="Ubuntu" fontSize="12" fontStyle="plain" hasBackgroundColor="false" hasLineColor="false" height="30.90418815612793" horizontalTextPosition="center" iconTextGap="4" modelName="custom" preferredPlacement="anywhere" ratio="0.5" textColor="#000000" verticalTextPosition="bottom" visible="true" width="87.40060424804688" x="-100.50030212402339" xml:space="preserve" y="11.337896156311103">enabled Events
+as PUS 5 TM<y:LabelModel><y:SmartEdgeLabelModel autoRotationEnabled="false" defaultAngle="0.0" defaultDistance="10.0"/></y:LabelModel><y:ModelParameter><y:SmartEdgeLabelModelParameter angle="6.283185307179586" distance="56.79999999999995" distanceToCenter="true" position="right" ratio="0.5" segment="0"/></y:ModelParameter><y:PreferredPlacementDescriptor angle="0.0" angleOffsetOnRightSide="0" angleReference="absolute" angleRotationOnRightSide="co" distance="-1.0" frozen="true" placement="anywhere" side="anywhere" sideReference="relative_to_edge_flow"/></y:EdgeLabel>
+          <y:BendStyle smoothed="false"/>
+        </y:PolyLineEdge>
+      </data>
+    </edge>
+  </graph>
+  <data key="d7">
+    <y:Resources/>
+  </data>
+</graphml>
diff --git a/satrs-core/images/event_man_arch.png b/satrs-core/images/event_man_arch.png
new file mode 100644
index 0000000..61c8d72
Binary files /dev/null and b/satrs-core/images/event_man_arch.png differ
diff --git a/satrs-core/src/device.rs b/satrs-core/src/device.rs
new file mode 100644
index 0000000..e69de29
diff --git a/fsrc-core/src/error.rs b/satrs-core/src/error.rs
similarity index 100%
rename from fsrc-core/src/error.rs
rename to satrs-core/src/error.rs
diff --git a/satrs-core/src/event_man.rs b/satrs-core/src/event_man.rs
new file mode 100644
index 0000000..5c56b85
--- /dev/null
+++ b/satrs-core/src/event_man.rs
@@ -0,0 +1,718 @@
+//! Event management and forwarding
+//!
+//! This module provides components to perform event routing. The most important component for this
+//! task is the [EventManager]. It receives all events and then routes them to event subscribers
+//! where appropriate.
+#![cfg_attr(feature = "doc-images",
+cfg_attr(all(),
+doc = ::embed_doc_image::embed_image!("event_man_arch", "images/event_man_arch.png"
+)))]
+#![cfg_attr(
+    not(feature = "doc-images"),
+    doc = "**Doc images not enabled**. Compile with feature `doc-images` and Rust version >= 1.54 \
+           to enable."
+)]
+//! One common use case for satellite systems is to offer a light-weight publish-subscribe mechanism
+//! and IPC mechanism for software and hardware events which are also packaged as telemetry (TM) or
+//! can trigger a system response.
+//!
+//! The following graph shows how the event flow for such a setup could look like:
+//!
+//! ![Event flow][event_man_arch]
+//!
+//! The event manager has a listener table abstracted by the [ListenerTable], which maps
+//! listener groups identified by [ListenerKey]s to a [sender ID][ChannelId].
+//! It also contains a sender table abstracted by the [SenderTable] which maps these sender IDs
+//! to a concrete [SendEventProvider]s. A simple approach would be to use one send event provider
+//! for each OBSW thread and then subscribe for all interesting events for a particular thread
+//! using the send event provider ID.
+//!
+//! This can be done with the [EventManager] like this:
+//!
+//!  1. Provide a concrete [EventReceiver] implementation. This abstraction allow to use different
+//!     message queue backends. A straightforward implementation where dynamic memory allocation is
+//!     not a big concern could use [std::sync::mpsc::channel] to do this and is provided in
+//!     form of the [MpscEventReceiver].
+//!  2. To set up event creators, create channel pairs using some message queue implementation.
+//!     Each event creator gets a (cloned) sender component which allows it to send events to the
+//!     manager.
+//!  3. The event manager receives the receiver component as part of a [EventReceiver]
+//!     implementation so all events are routed to the manager.
+//!  4. Create the [send event providers][SendEventProvider]s which allow routing events to
+//!     subscribers. You can now use their [sender IDs][SendEventProvider::id] to subscribe for
+//!     event groups, for example by using the [EventManager::subscribe_single] method.
+//!  5. Add the send provider as well using the [EventManager::add_sender] call so the event
+//!     manager can route listener groups to a the send provider.
+//!
+//! Some components like a PUS Event Service or PUS Event Action Service might require all
+//! events to package them as telemetry or start actions where applicable.
+//! Other components might only be interested in certain events. For example, a thermal system
+//! handler might only be interested in temperature events generated by a thermal sensor component.
+//!
+//! # Examples
+//!
+//! You can check [integration test](https://egit.irs.uni-stuttgart.de/rust/sat-rs/src/branch/main/satrs-core/tests/pus_events.rs)
+//! for a concrete example using multi-threading where events are routed to
+//! different threads.
+use crate::events::{EventU16, EventU32, GenericEvent, LargestEventRaw, LargestGroupIdRaw};
+use crate::params::{Params, ParamsHeapless};
+#[cfg(feature = "alloc")]
+use alloc::boxed::Box;
+#[cfg(feature = "alloc")]
+use alloc::vec;
+#[cfg(feature = "alloc")]
+use alloc::vec::Vec;
+use core::slice::Iter;
+#[cfg(feature = "alloc")]
+use hashbrown::HashMap;
+
+use crate::ChannelId;
+#[cfg(feature = "std")]
+pub use stdmod::*;
+
+#[derive(PartialEq, Eq, Hash, Copy, Clone, Debug)]
+pub enum ListenerKey {
+    Single(LargestEventRaw),
+    Group(LargestGroupIdRaw),
+    All,
+}
+
+pub type EventWithHeaplessAuxData<Event> = (Event, Option<ParamsHeapless>);
+pub type EventU32WithHeaplessAuxData = EventWithHeaplessAuxData<EventU32>;
+pub type EventU16WithHeaplessAuxData = EventWithHeaplessAuxData<EventU16>;
+
+pub type EventWithAuxData<Event> = (Event, Option<Params>);
+pub type EventU32WithAuxData = EventWithAuxData<EventU32>;
+pub type EventU16WithAuxData = EventWithAuxData<EventU16>;
+
+pub trait SendEventProvider<Provider: GenericEvent, AuxDataProvider = Params> {
+    type Error;
+
+    fn id(&self) -> ChannelId;
+    fn send_no_data(&self, event: Provider) -> Result<(), Self::Error> {
+        self.send(event, None)
+    }
+    fn send(&self, event: Provider, aux_data: Option<AuxDataProvider>) -> Result<(), Self::Error>;
+}
+
+/// Generic abstraction for an event receiver.
+pub trait EventReceiver<Event: GenericEvent, AuxDataProvider = Params> {
+    /// This function has to be provided by any event receiver. A receive call may or may not return
+    /// an event.
+    ///
+    /// To allow returning arbitrary additional auxiliary data, a mutable slice is passed to the
+    /// [Self::receive] call as well. Receivers can write data to this slice, but care must be taken
+    /// to avoid panics due to size missmatches or out of bound writes.
+    fn receive(&self) -> Option<(Event, Option<AuxDataProvider>)>;
+}
+
+pub trait ListenerTable {
+    fn get_listeners(&self) -> Vec<ListenerKey>;
+    fn contains_listener(&self, key: &ListenerKey) -> bool;
+    fn get_listener_ids(&self, key: &ListenerKey) -> Option<Iter<ChannelId>>;
+    fn add_listener(&mut self, key: ListenerKey, sender_id: ChannelId) -> bool;
+    fn remove_duplicates(&mut self, key: &ListenerKey);
+}
+
+pub trait SenderTable<SendProviderError, Event: GenericEvent = EventU32, AuxDataProvider = Params> {
+    fn contains_send_event_provider(&self, id: &ChannelId) -> bool;
+    fn get_send_event_provider(
+        &mut self,
+        id: &ChannelId,
+    ) -> Option<&mut Box<dyn SendEventProvider<Event, AuxDataProvider, Error = SendProviderError>>>;
+    fn add_send_event_provider(
+        &mut self,
+        send_provider: Box<
+            dyn SendEventProvider<Event, AuxDataProvider, Error = SendProviderError>,
+        >,
+    ) -> bool;
+}
+
+/// Generic event manager implementation.
+///
+/// # Generics
+///
+///  * `SendProviderError`: [SendEventProvider] error type
+///  * `Event`: Concrete event provider, currently either [EventU32] or [EventU16]
+///  * `AuxDataProvider`: Concrete auxiliary data provider, currently either [Params] or
+///     [ParamsHeapless]
+pub struct EventManager<SendProviderError, Event: GenericEvent = EventU32, AuxDataProvider = Params>
+{
+    listener_table: Box<dyn ListenerTable>,
+    sender_table: Box<dyn SenderTable<SendProviderError, Event, AuxDataProvider>>,
+    event_receiver: Box<dyn EventReceiver<Event, AuxDataProvider>>,
+}
+
+/// Safety: It is safe to implement [Send] because all fields in the [EventManager] are [Send]
+/// as well
+#[cfg(feature = "std")]
+unsafe impl<E, Event: GenericEvent + Send, AuxDataProvider: Send> Send
+    for EventManager<E, Event, AuxDataProvider>
+{
+}
+
+#[cfg(feature = "std")]
+pub type EventManagerWithMpscQueue<Event, AuxDataProvider> = EventManager<
+    std::sync::mpsc::SendError<(Event, Option<AuxDataProvider>)>,
+    Event,
+    AuxDataProvider,
+>;
+
+#[derive(Debug)]
+pub enum EventRoutingResult<Event: GenericEvent, AuxDataProvider> {
+    /// No event was received
+    Empty,
+    /// An event was received and routed.
+    /// The first tuple entry will contain the number of recipients.
+    Handled(u32, Event, Option<AuxDataProvider>),
+}
+
+#[derive(Debug)]
+pub enum EventRoutingError<E> {
+    SendError(E),
+    NoSendersForKey(ListenerKey),
+    NoSenderForId(ChannelId),
+}
+
+#[derive(Debug)]
+pub struct EventRoutingErrorsWithResult<Event: GenericEvent, AuxDataProvider, E> {
+    pub result: EventRoutingResult<Event, AuxDataProvider>,
+    pub errors: [Option<EventRoutingError<E>>; 3],
+}
+
+impl<E, Event: GenericEvent + Copy> EventManager<E, Event> {
+    pub fn remove_duplicates(&mut self, key: &ListenerKey) {
+        self.listener_table.remove_duplicates(key)
+    }
+
+    /// Subscribe for a unique event.
+    pub fn subscribe_single(&mut self, event: &Event, sender_id: ChannelId) {
+        self.update_listeners(ListenerKey::Single(event.raw_as_largest_type()), sender_id);
+    }
+
+    /// Subscribe for an event group.
+    pub fn subscribe_group(&mut self, group_id: LargestGroupIdRaw, sender_id: ChannelId) {
+        self.update_listeners(ListenerKey::Group(group_id), sender_id);
+    }
+
+    /// Subscribe for all events received by the manager.
+    ///
+    /// For example, this can be useful for a handler component which sends every event as
+    /// a telemetry packet.
+    pub fn subscribe_all(&mut self, sender_id: ChannelId) {
+        self.update_listeners(ListenerKey::All, sender_id);
+    }
+}
+
+impl<E: 'static, Event: GenericEvent + Copy + 'static, AuxDataProvider: Clone + 'static>
+    EventManager<E, Event, AuxDataProvider>
+{
+    /// Create an event manager where the sender table will be the [DefaultSenderTableProvider]
+    /// and the listener table will be the [DefaultListenerTableProvider].
+    pub fn new(event_receiver: Box<dyn EventReceiver<Event, AuxDataProvider>>) -> Self {
+        let listener_table: Box<DefaultListenerTableProvider> = Box::default();
+        let sender_table: Box<DefaultSenderTableProvider<E, Event, AuxDataProvider>> =
+            Box::default();
+        Self::new_custom_tables(listener_table, sender_table, event_receiver)
+    }
+}
+
+impl<E, Event: GenericEvent + Copy, AuxDataProvider: Clone>
+    EventManager<E, Event, AuxDataProvider>
+{
+    pub fn new_custom_tables(
+        listener_table: Box<dyn ListenerTable>,
+        sender_table: Box<dyn SenderTable<E, Event, AuxDataProvider>>,
+        event_receiver: Box<dyn EventReceiver<Event, AuxDataProvider>>,
+    ) -> Self {
+        EventManager {
+            listener_table,
+            sender_table,
+            event_receiver,
+        }
+    }
+
+    pub fn add_sender(
+        &mut self,
+        send_provider: impl SendEventProvider<Event, AuxDataProvider, Error = E> + 'static,
+    ) {
+        if !self
+            .sender_table
+            .contains_send_event_provider(&send_provider.id())
+        {
+            self.sender_table
+                .add_send_event_provider(Box::new(send_provider));
+        }
+    }
+
+    fn update_listeners(&mut self, key: ListenerKey, sender_id: ChannelId) {
+        self.listener_table.add_listener(key, sender_id);
+    }
+
+    /// This function will use the cached event receiver and try to receive one event.
+    /// If an event was received, it will try to route that event to all subscribed event listeners.
+    /// If this works without any issues, the [EventRoutingResult] will contain context information
+    /// about the routed event.
+    ///
+    /// This function will track up to 3 errors returned as part of the
+    /// [EventRoutingErrorsWithResult] error struct.
+    pub fn try_event_handling(
+        &mut self,
+    ) -> Result<
+        EventRoutingResult<Event, AuxDataProvider>,
+        EventRoutingErrorsWithResult<Event, AuxDataProvider, E>,
+    > {
+        let mut err_idx = 0;
+        let mut err_slice = [None, None, None];
+        let mut num_recipients = 0;
+        let mut add_error = |error: EventRoutingError<E>| {
+            if err_idx < 3 {
+                err_slice[err_idx] = Some(error);
+                err_idx += 1;
+            }
+        };
+        let mut send_handler =
+            |key: &ListenerKey, event: Event, aux_data: &Option<AuxDataProvider>| {
+                if self.listener_table.contains_listener(key) {
+                    if let Some(ids) = self.listener_table.get_listener_ids(key) {
+                        for id in ids {
+                            if let Some(sender) = self.sender_table.get_send_event_provider(id) {
+                                if let Err(e) = sender.send(event, aux_data.clone()) {
+                                    add_error(EventRoutingError::SendError(e));
+                                } else {
+                                    num_recipients += 1;
+                                }
+                            } else {
+                                add_error(EventRoutingError::NoSenderForId(*id));
+                            }
+                        }
+                    } else {
+                        add_error(EventRoutingError::NoSendersForKey(*key));
+                    }
+                }
+            };
+        if let Some((event, aux_data)) = self.event_receiver.receive() {
+            let single_key = ListenerKey::Single(event.raw_as_largest_type());
+            send_handler(&single_key, event, &aux_data);
+            let group_key = ListenerKey::Group(event.group_id_as_largest_type());
+            send_handler(&group_key, event, &aux_data);
+            send_handler(&ListenerKey::All, event, &aux_data);
+            if err_idx > 0 {
+                return Err(EventRoutingErrorsWithResult {
+                    result: EventRoutingResult::Handled(num_recipients, event, aux_data),
+                    errors: err_slice,
+                });
+            }
+            return Ok(EventRoutingResult::Handled(num_recipients, event, aux_data));
+        }
+        Ok(EventRoutingResult::Empty)
+    }
+}
+
+#[derive(Default)]
+pub struct DefaultListenerTableProvider {
+    listeners: HashMap<ListenerKey, Vec<ChannelId>>,
+}
+
+pub struct DefaultSenderTableProvider<
+    SendProviderError,
+    Event: GenericEvent = EventU32,
+    AuxDataProvider = Params,
+> {
+    senders: HashMap<
+        ChannelId,
+        Box<dyn SendEventProvider<Event, AuxDataProvider, Error = SendProviderError>>,
+    >,
+}
+
+impl<SendProviderError, Event: GenericEvent, AuxDataProvider> Default
+    for DefaultSenderTableProvider<SendProviderError, Event, AuxDataProvider>
+{
+    fn default() -> Self {
+        Self {
+            senders: HashMap::new(),
+        }
+    }
+}
+
+impl ListenerTable for DefaultListenerTableProvider {
+    fn get_listeners(&self) -> Vec<ListenerKey> {
+        let mut key_list = Vec::new();
+        for key in self.listeners.keys() {
+            key_list.push(*key);
+        }
+        key_list
+    }
+
+    fn contains_listener(&self, key: &ListenerKey) -> bool {
+        self.listeners.contains_key(key)
+    }
+
+    fn get_listener_ids(&self, key: &ListenerKey) -> Option<Iter<ChannelId>> {
+        self.listeners.get(key).map(|vec| vec.iter())
+    }
+
+    fn add_listener(&mut self, key: ListenerKey, sender_id: ChannelId) -> bool {
+        if let Some(existing_list) = self.listeners.get_mut(&key) {
+            existing_list.push(sender_id);
+        } else {
+            let new_list = vec![sender_id];
+            self.listeners.insert(key, new_list);
+        }
+        true
+    }
+
+    fn remove_duplicates(&mut self, key: &ListenerKey) {
+        if let Some(list) = self.listeners.get_mut(key) {
+            list.sort_unstable();
+            list.dedup();
+        }
+    }
+}
+
+impl<SendProviderError, Event: GenericEvent, AuxDataProvider>
+    SenderTable<SendProviderError, Event, AuxDataProvider>
+    for DefaultSenderTableProvider<SendProviderError, Event, AuxDataProvider>
+{
+    fn contains_send_event_provider(&self, id: &ChannelId) -> bool {
+        self.senders.contains_key(id)
+    }
+
+    fn get_send_event_provider(
+        &mut self,
+        id: &ChannelId,
+    ) -> Option<&mut Box<dyn SendEventProvider<Event, AuxDataProvider, Error = SendProviderError>>>
+    {
+        self.senders.get_mut(id).filter(|sender| sender.id() == *id)
+    }
+
+    fn add_send_event_provider(
+        &mut self,
+        send_provider: Box<
+            dyn SendEventProvider<Event, AuxDataProvider, Error = SendProviderError>,
+        >,
+    ) -> bool {
+        let id = send_provider.id();
+        if self.senders.contains_key(&id) {
+            return false;
+        }
+        self.senders.insert(id, send_provider).is_none()
+    }
+}
+
+#[cfg(feature = "std")]
+pub mod stdmod {
+    use super::*;
+    use crate::event_man::{EventReceiver, EventWithAuxData};
+    use crate::events::{EventU16, EventU32, GenericEvent};
+    use crate::params::Params;
+    use std::sync::mpsc::{Receiver, SendError, Sender};
+
+    pub struct MpscEventReceiver<Event: GenericEvent + Send = EventU32> {
+        mpsc_receiver: Receiver<(Event, Option<Params>)>,
+    }
+
+    impl<Event: GenericEvent + Send> MpscEventReceiver<Event> {
+        pub fn new(receiver: Receiver<(Event, Option<Params>)>) -> Self {
+            Self {
+                mpsc_receiver: receiver,
+            }
+        }
+    }
+    impl<Event: GenericEvent + Send> EventReceiver<Event> for MpscEventReceiver<Event> {
+        fn receive(&self) -> Option<EventWithAuxData<Event>> {
+            if let Ok(event_and_data) = self.mpsc_receiver.try_recv() {
+                return Some(event_and_data);
+            }
+            None
+        }
+    }
+
+    pub type MpscEventU32Receiver = MpscEventReceiver<EventU32>;
+    pub type MpscEventU16Receiver = MpscEventReceiver<EventU16>;
+
+    #[derive(Clone)]
+    pub struct MpscEventSendProvider<Event: GenericEvent + Send> {
+        id: u32,
+        sender: Sender<(Event, Option<Params>)>,
+    }
+
+    impl<Event: GenericEvent + Send> MpscEventSendProvider<Event> {
+        pub fn new(id: u32, sender: Sender<(Event, Option<Params>)>) -> Self {
+            Self { id, sender }
+        }
+    }
+
+    impl<Event: GenericEvent + Send> SendEventProvider<Event> for MpscEventSendProvider<Event> {
+        type Error = SendError<(Event, Option<Params>)>;
+
+        fn id(&self) -> u32 {
+            self.id
+        }
+        fn send(&self, event: Event, aux_data: Option<Params>) -> Result<(), Self::Error> {
+            self.sender.send((event, aux_data))
+        }
+    }
+
+    pub type MpscEventU32SendProvider = MpscEventSendProvider<EventU32>;
+    pub type MpscEventU16SendProvider = MpscEventSendProvider<EventU16>;
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::event_man::EventManager;
+    use crate::events::{EventU32, GenericEvent, Severity};
+    use crate::params::ParamsRaw;
+    use alloc::boxed::Box;
+    use std::format;
+    use std::sync::mpsc::{channel, Receiver, SendError, Sender};
+
+    #[derive(Clone)]
+    struct MpscEventSenderQueue {
+        id: u32,
+        mpsc_sender: Sender<EventU32WithAuxData>,
+    }
+
+    impl MpscEventSenderQueue {
+        fn new(id: u32, mpsc_sender: Sender<EventU32WithAuxData>) -> Self {
+            Self { id, mpsc_sender }
+        }
+    }
+
+    impl SendEventProvider<EventU32> for MpscEventSenderQueue {
+        type Error = SendError<EventU32WithAuxData>;
+
+        fn id(&self) -> u32 {
+            self.id
+        }
+        fn send(&self, event: EventU32, aux_data: Option<Params>) -> Result<(), Self::Error> {
+            self.mpsc_sender.send((event, aux_data))
+        }
+    }
+
+    fn check_next_event(
+        expected: EventU32,
+        receiver: &Receiver<EventU32WithAuxData>,
+    ) -> Option<Params> {
+        if let Ok(event) = receiver.try_recv() {
+            assert_eq!(event.0, expected);
+            return event.1;
+        }
+        None
+    }
+
+    fn check_handled_event(
+        res: EventRoutingResult<EventU32, Params>,
+        expected: EventU32,
+        expected_num_sent: u32,
+    ) {
+        assert!(matches!(res, EventRoutingResult::Handled { .. }));
+        if let EventRoutingResult::Handled(num_recipients, event, _aux_data) = res {
+            assert_eq!(event, expected);
+            assert_eq!(num_recipients, expected_num_sent);
+        }
+    }
+
+    fn generic_event_man() -> (
+        Sender<EventU32WithAuxData>,
+        EventManager<SendError<EventU32WithAuxData>>,
+    ) {
+        let (event_sender, manager_queue) = channel();
+        let event_man_receiver = MpscEventReceiver::new(manager_queue);
+        (
+            event_sender,
+            EventManager::new(Box::new(event_man_receiver)),
+        )
+    }
+
+    #[test]
+    fn test_basic() {
+        let (event_sender, mut event_man) = generic_event_man();
+        let event_grp_0 = EventU32::new(Severity::INFO, 0, 0).unwrap();
+        let event_grp_1_0 = EventU32::new(Severity::HIGH, 1, 0).unwrap();
+        let (single_event_sender, single_event_receiver) = channel();
+        let single_event_listener = MpscEventSenderQueue::new(0, single_event_sender);
+        event_man.subscribe_single(&event_grp_0, single_event_listener.id());
+        event_man.add_sender(single_event_listener);
+        let (group_event_sender_0, group_event_receiver_0) = channel();
+        let group_event_listener = MpscEventSenderQueue {
+            id: 1,
+            mpsc_sender: group_event_sender_0,
+        };
+        event_man.subscribe_group(event_grp_1_0.group_id(), group_event_listener.id());
+        event_man.add_sender(group_event_listener);
+
+        // Test event with one listener
+        event_sender
+            .send((event_grp_0, None))
+            .expect("Sending single error failed");
+        let res = event_man.try_event_handling();
+        assert!(res.is_ok());
+        check_handled_event(res.unwrap(), event_grp_0, 1);
+        check_next_event(event_grp_0, &single_event_receiver);
+
+        // Test event which is sent to all group listeners
+        event_sender
+            .send((event_grp_1_0, None))
+            .expect("Sending group error failed");
+        let res = event_man.try_event_handling();
+        assert!(res.is_ok());
+        check_handled_event(res.unwrap(), event_grp_1_0, 1);
+        check_next_event(event_grp_1_0, &group_event_receiver_0);
+    }
+
+    #[test]
+    fn test_with_basic_aux_data() {
+        let (event_sender, mut event_man) = generic_event_man();
+        let event_grp_0 = EventU32::new(Severity::INFO, 0, 0).unwrap();
+        let (single_event_sender, single_event_receiver) = channel();
+        let single_event_listener = MpscEventSenderQueue::new(0, single_event_sender);
+        event_man.subscribe_single(&event_grp_0, single_event_listener.id());
+        event_man.add_sender(single_event_listener);
+        event_sender
+            .send((event_grp_0, Some(Params::Heapless((2_u32, 3_u32).into()))))
+            .expect("Sending group error failed");
+        let res = event_man.try_event_handling();
+        assert!(res.is_ok());
+        check_handled_event(res.unwrap(), event_grp_0, 1);
+        let aux = check_next_event(event_grp_0, &single_event_receiver);
+        assert!(aux.is_some());
+        let aux = aux.unwrap();
+        if let Params::Heapless(ParamsHeapless::Raw(ParamsRaw::U32Pair(pair))) = aux {
+            assert_eq!(pair.0, 2);
+            assert_eq!(pair.1, 3);
+        } else {
+            panic!("{}", format!("Unexpected auxiliary value type {:?}", aux));
+        }
+    }
+
+    /// Test listening for multiple groups
+    #[test]
+    fn test_multi_group() {
+        let (event_sender, mut event_man) = generic_event_man();
+        let res = event_man.try_event_handling();
+        assert!(res.is_ok());
+        let hres = res.unwrap();
+        assert!(matches!(hres, EventRoutingResult::Empty));
+
+        let event_grp_0 = EventU32::new(Severity::INFO, 0, 0).unwrap();
+        let event_grp_1_0 = EventU32::new(Severity::HIGH, 1, 0).unwrap();
+        let (event_grp_0_sender, event_grp_0_receiver) = channel();
+        let event_grp_0_and_1_listener = MpscEventSenderQueue {
+            id: 0,
+            mpsc_sender: event_grp_0_sender,
+        };
+        event_man.subscribe_group(event_grp_0.group_id(), event_grp_0_and_1_listener.id());
+        event_man.subscribe_group(event_grp_1_0.group_id(), event_grp_0_and_1_listener.id());
+        event_man.add_sender(event_grp_0_and_1_listener);
+
+        event_sender
+            .send((event_grp_0, None))
+            .expect("Sending Event Group 0 failed");
+        event_sender
+            .send((event_grp_1_0, None))
+            .expect("Sendign Event Group 1 failed");
+        let res = event_man.try_event_handling();
+        assert!(res.is_ok());
+        check_handled_event(res.unwrap(), event_grp_0, 1);
+        let res = event_man.try_event_handling();
+        assert!(res.is_ok());
+        check_handled_event(res.unwrap(), event_grp_1_0, 1);
+
+        check_next_event(event_grp_0, &event_grp_0_receiver);
+        check_next_event(event_grp_1_0, &event_grp_0_receiver);
+    }
+
+    /// Test listening to the same event from multiple listeners. Also test listening
+    /// to both group and single events from one listener
+    #[test]
+    fn test_listening_to_same_event_and_multi_type() {
+        let (event_sender, mut event_man) = generic_event_man();
+        let event_0 = EventU32::new(Severity::INFO, 0, 5).unwrap();
+        let event_1 = EventU32::new(Severity::HIGH, 1, 0).unwrap();
+        let (event_0_tx_0, event_0_rx_0) = channel();
+        let (event_0_tx_1, event_0_rx_1) = channel();
+        let event_listener_0 = MpscEventSenderQueue {
+            id: 0,
+            mpsc_sender: event_0_tx_0,
+        };
+        let event_listener_1 = MpscEventSenderQueue {
+            id: 1,
+            mpsc_sender: event_0_tx_1,
+        };
+        let event_listener_0_sender_id = event_listener_0.id();
+        event_man.subscribe_single(&event_0, event_listener_0_sender_id);
+        event_man.add_sender(event_listener_0);
+        let event_listener_1_sender_id = event_listener_1.id();
+        event_man.subscribe_single(&event_0, event_listener_1_sender_id);
+        event_man.add_sender(event_listener_1);
+        event_sender
+            .send((event_0, None))
+            .expect("Triggering Event 0 failed");
+        let res = event_man.try_event_handling();
+        assert!(res.is_ok());
+        check_handled_event(res.unwrap(), event_0, 2);
+        check_next_event(event_0, &event_0_rx_0);
+        check_next_event(event_0, &event_0_rx_1);
+        event_man.subscribe_group(event_1.group_id(), event_listener_0_sender_id);
+        event_sender
+            .send((event_0, None))
+            .expect("Triggering Event 0 failed");
+        event_sender
+            .send((event_1, None))
+            .expect("Triggering Event 1 failed");
+
+        // 3 Events messages will be sent now
+        let res = event_man.try_event_handling();
+        assert!(res.is_ok());
+        check_handled_event(res.unwrap(), event_0, 2);
+        let res = event_man.try_event_handling();
+        assert!(res.is_ok());
+        check_handled_event(res.unwrap(), event_1, 1);
+        // Both the single event and the group event should arrive now
+        check_next_event(event_0, &event_0_rx_0);
+        check_next_event(event_1, &event_0_rx_0);
+
+        // Do double insertion and then remove duplicates
+        event_man.subscribe_group(event_1.group_id(), event_listener_0_sender_id);
+        event_man.remove_duplicates(&ListenerKey::Group(event_1.group_id()));
+        event_sender
+            .send((event_1, None))
+            .expect("Triggering Event 1 failed");
+        let res = event_man.try_event_handling();
+        assert!(res.is_ok());
+        check_handled_event(res.unwrap(), event_1, 1);
+    }
+
+    #[test]
+    fn test_all_events_listener() {
+        let (event_sender, manager_queue) = channel();
+        let event_man_receiver = MpscEventReceiver::new(manager_queue);
+        let mut event_man: EventManager<SendError<EventU32WithAuxData>> =
+            EventManager::new(Box::new(event_man_receiver));
+        let event_0 = EventU32::new(Severity::INFO, 0, 5).unwrap();
+        let event_1 = EventU32::new(Severity::HIGH, 1, 0).unwrap();
+        let (event_0_tx_0, all_events_rx) = channel();
+        let all_events_listener = MpscEventSenderQueue {
+            id: 0,
+            mpsc_sender: event_0_tx_0,
+        };
+        event_man.subscribe_all(all_events_listener.id());
+        event_man.add_sender(all_events_listener);
+        event_sender
+            .send((event_0, None))
+            .expect("Triggering event 0 failed");
+        event_sender
+            .send((event_1, None))
+            .expect("Triggering event 1 failed");
+        let res = event_man.try_event_handling();
+        assert!(res.is_ok());
+        check_handled_event(res.unwrap(), event_0, 1);
+        let res = event_man.try_event_handling();
+        assert!(res.is_ok());
+        check_handled_event(res.unwrap(), event_1, 1);
+        check_next_event(event_0, &all_events_rx);
+        check_next_event(event_1, &all_events_rx);
+    }
+}
diff --git a/satrs-core/src/events.rs b/satrs-core/src/events.rs
new file mode 100644
index 0000000..4b4c0c9
--- /dev/null
+++ b/satrs-core/src/events.rs
@@ -0,0 +1,826 @@
+//! Event support module
+//!
+//! This module includes the basic event structs [EventU32] and [EventU16] and versions with the
+//! ECSS severity levels as a type parameter. These structs are simple abstractions on top of the
+//! [u32] and [u16] types where the raw value is the unique identifier for a particular event.
+//! The abstraction also allows to group related events using a group ID, and the severity
+//! of an event is encoded inside the raw value itself with four possible [Severity] levels:
+//!
+//!  - INFO
+//!  - LOW
+//!  - MEDIUM
+//!  - HIGH
+//!
+//! All event structs implement the [EcssEnumeration] trait and can be created as constants.
+//! This allows to easily create a static list of constant events which can then be used to generate
+//! event telemetry using the PUS event manager modules.
+//!
+//! # Examples
+//!
+//! ```
+//! use satrs_core::events::{EventU16, EventU32, EventU32TypedSev, Severity, SeverityHigh, SeverityInfo};
+//!
+//! const MSG_RECVD: EventU32TypedSev<SeverityInfo> = EventU32TypedSev::const_new(1, 0);
+//! const MSG_FAILED: EventU32 = EventU32::const_new(Severity::LOW, 1, 1);
+//!
+//! const TEMPERATURE_HIGH: EventU32TypedSev<SeverityHigh> = EventU32TypedSev::const_new(2, 0);
+//!
+//! let small_event = EventU16::new(Severity::INFO, 3, 0);
+//! ```
+use core::fmt::Debug;
+use core::hash::Hash;
+use core::marker::PhantomData;
+use delegate::delegate;
+use spacepackets::ecss::EcssEnumeration;
+use spacepackets::util::{ToBeBytes, UnsignedEnum};
+use spacepackets::{ByteConversionError, SizeMissmatch};
+
+/// Using a type definition allows to change this to u64 in the future more easily
+pub type LargestEventRaw = u32;
+/// Using a type definition allows to change this to u32 in the future more easily
+pub type LargestGroupIdRaw = u16;
+
+#[derive(Copy, Clone, PartialEq, Eq, Debug, Hash)]
+pub enum Severity {
+    INFO = 0,
+    LOW = 1,
+    MEDIUM = 2,
+    HIGH = 3,
+}
+
+pub trait HasSeverity: Debug + PartialEq + Eq + Copy + Clone {
+    const SEVERITY: Severity;
+}
+
+/// Type level support struct
+#[derive(Debug, PartialEq, Eq, Copy, Clone)]
+pub struct SeverityInfo {}
+impl HasSeverity for SeverityInfo {
+    const SEVERITY: Severity = Severity::INFO;
+}
+
+/// Type level support struct
+#[derive(Debug, PartialEq, Eq, Copy, Clone)]
+pub struct SeverityLow {}
+impl HasSeverity for SeverityLow {
+    const SEVERITY: Severity = Severity::LOW;
+}
+
+/// Type level support struct
+#[derive(Debug, PartialEq, Eq, Copy, Clone)]
+pub struct SeverityMedium {}
+impl HasSeverity for SeverityMedium {
+    const SEVERITY: Severity = Severity::MEDIUM;
+}
+
+/// Type level support struct
+#[derive(Debug, PartialEq, Eq, Copy, Clone)]
+pub struct SeverityHigh {}
+impl HasSeverity for SeverityHigh {
+    const SEVERITY: Severity = Severity::HIGH;
+}
+
+pub trait GenericEvent: EcssEnumeration {
+    type Raw;
+    type GroupId;
+    type UniqueId;
+
+    fn raw(&self) -> Self::Raw;
+    fn severity(&self) -> Severity;
+    fn group_id(&self) -> Self::GroupId;
+    fn unique_id(&self) -> Self::UniqueId;
+
+    fn raw_as_largest_type(&self) -> LargestEventRaw;
+    fn group_id_as_largest_type(&self) -> LargestGroupIdRaw;
+}
+
+impl TryFrom<u8> for Severity {
+    type Error = ();
+
+    fn try_from(value: u8) -> Result<Self, Self::Error> {
+        match value {
+            x if x == Severity::INFO as u8 => Ok(Severity::INFO),
+            x if x == Severity::LOW as u8 => Ok(Severity::LOW),
+            x if x == Severity::MEDIUM as u8 => Ok(Severity::MEDIUM),
+            x if x == Severity::HIGH as u8 => Ok(Severity::HIGH),
+            _ => Err(()),
+        }
+    }
+}
+
+#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
+struct EventBase<RAW, GID, UID> {
+    severity: Severity,
+    group_id: GID,
+    unique_id: UID,
+    phantom: PhantomData<RAW>,
+}
+
+impl<RAW: ToBeBytes, GID, UID> EventBase<RAW, GID, UID> {
+    fn write_to_bytes(
+        &self,
+        raw: RAW,
+        buf: &mut [u8],
+        width: usize,
+    ) -> Result<usize, ByteConversionError> {
+        if buf.len() < width {
+            return Err(ByteConversionError::ToSliceTooSmall(SizeMissmatch {
+                found: buf.len(),
+                expected: width,
+            }));
+        }
+        buf.copy_from_slice(raw.to_be_bytes().as_ref());
+        Ok(raw.written_len())
+    }
+}
+
+impl EventBase<u32, u16, u16> {
+    #[inline]
+    fn raw(&self) -> u32 {
+        ((self.severity as u32) << 30) | ((self.group_id as u32) << 16) | self.unique_id as u32
+    }
+}
+
+impl EventBase<u16, u8, u8> {
+    #[inline]
+    fn raw(&self) -> u16 {
+        ((self.severity as u16) << 14) | ((self.group_id as u16) << 8) | self.unique_id as u16
+    }
+}
+
+impl<RAW, GID, UID> EventBase<RAW, GID, UID> {
+    #[inline]
+    pub fn severity(&self) -> Severity {
+        self.severity
+    }
+}
+
+impl<RAW, GID> EventBase<RAW, GID, u16> {
+    #[inline]
+    pub fn unique_id(&self) -> u16 {
+        self.unique_id
+    }
+}
+
+impl<RAW, GID> EventBase<RAW, GID, u8> {
+    #[inline]
+    pub fn unique_id(&self) -> u8 {
+        self.unique_id
+    }
+}
+
+impl<RAW, UID> EventBase<RAW, u16, UID> {
+    #[inline]
+    pub fn group_id(&self) -> u16 {
+        self.group_id
+    }
+}
+
+impl<RAW, UID> EventBase<RAW, u8, UID> {
+    #[inline]
+    pub fn group_id(&self) -> u8 {
+        self.group_id
+    }
+}
+
+macro_rules! event_provider_impl {
+    () => {
+        #[inline]
+        fn raw(&self) -> Self::Raw {
+            self.base.raw()
+        }
+
+        /// Retrieve the severity of an event. Returns None if that severity bit field of the raw event
+        /// ID is invalid
+        #[inline]
+        fn severity(&self) -> Severity {
+            self.base.severity()
+        }
+
+        #[inline]
+        fn group_id(&self) -> Self::GroupId {
+            self.base.group_id()
+        }
+
+        #[inline]
+        fn unique_id(&self) -> Self::UniqueId {
+            self.base.unique_id()
+        }
+    };
+}
+
+macro_rules! impl_event_provider {
+    ($BaseIdent: ident, $TypedIdent: ident, $raw: ty, $gid: ty, $uid: ty) => {
+        impl GenericEvent for $BaseIdent {
+            type Raw = $raw;
+            type GroupId = $gid;
+            type UniqueId = $uid;
+
+            event_provider_impl!();
+
+            fn raw_as_largest_type(&self) -> LargestEventRaw {
+                self.raw().into()
+            }
+
+            fn group_id_as_largest_type(&self) -> LargestGroupIdRaw {
+                self.group_id().into()
+            }
+        }
+
+        impl<SEVERITY: HasSeverity> GenericEvent for $TypedIdent<SEVERITY> {
+            type Raw = $raw;
+            type GroupId = $gid;
+            type UniqueId = $uid;
+
+            delegate!(to self.event {
+                fn raw(&self) -> Self::Raw;
+                fn severity(&self) -> Severity;
+                fn group_id(&self) -> Self::GroupId;
+                fn unique_id(&self) -> Self::UniqueId;
+                fn raw_as_largest_type(&self) -> LargestEventRaw;
+                fn group_id_as_largest_type(&self) -> LargestGroupIdRaw;
+            });
+        }
+    }
+}
+
+macro_rules! try_from_impls {
+    ($SevIdent: ident, $severity: path, $raw: ty, $TypedSevIdent: ident) => {
+        impl TryFrom<$raw> for $TypedSevIdent<$SevIdent> {
+            type Error = Severity;
+
+            fn try_from(raw: $raw) -> Result<Self, Self::Error> {
+                Self::try_from_generic($severity, raw)
+            }
+        }
+    };
+}
+
+macro_rules! const_from_fn {
+    ($from_fn_name: ident, $TypedIdent: ident, $SevIdent: ident) => {
+        pub const fn $from_fn_name(event: $TypedIdent<$SevIdent>) -> Self {
+            Self {
+                base: event.event.base,
+            }
+        }
+    };
+}
+
+#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
+pub struct EventU32 {
+    base: EventBase<u32, u16, u16>,
+}
+
+#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
+pub struct EventU32TypedSev<SEVERITY> {
+    event: EventU32,
+    phantom: PhantomData<SEVERITY>,
+}
+
+impl<SEVERITY: HasSeverity> From<EventU32TypedSev<SEVERITY>> for EventU32 {
+    fn from(e: EventU32TypedSev<SEVERITY>) -> Self {
+        Self { base: e.event.base }
+    }
+}
+
+impl<Severity: HasSeverity> AsRef<EventU32> for EventU32TypedSev<Severity> {
+    fn as_ref(&self) -> &EventU32 {
+        &self.event
+    }
+}
+
+impl<Severity: HasSeverity> AsMut<EventU32> for EventU32TypedSev<Severity> {
+    fn as_mut(&mut self) -> &mut EventU32 {
+        &mut self.event
+    }
+}
+
+impl_event_provider!(EventU32, EventU32TypedSev, u32, u16, u16);
+
+impl EventU32 {
+    /// Generate an event. The raw representation of an event has 32 bits.
+    /// If the passed group ID is invalid (too large), None wil be returned
+    ///
+    /// # Parameter
+    ///
+    /// * `severity`: Each event has a [severity][Severity]. The raw value of the severity will
+    ///        be stored inside the uppermost 2 bits of the raw event ID
+    /// * `group_id`: Related events can be grouped using a group ID. The group ID will occupy the
+    ///        next 14 bits after the severity. Therefore, the size is limited by dec 16383 hex 0x3FFF.
+    /// * `unique_id`: Each event has a unique 16 bit ID occupying the last 16 bits of the
+    ///       raw event ID
+    pub fn new(
+        severity: Severity,
+        group_id: <Self as GenericEvent>::GroupId,
+        unique_id: <Self as GenericEvent>::UniqueId,
+    ) -> Option<Self> {
+        if group_id > (2u16.pow(14) - 1) {
+            return None;
+        }
+        Some(Self {
+            base: EventBase {
+                severity,
+                group_id,
+                unique_id,
+                phantom: PhantomData,
+            },
+        })
+    }
+    pub const fn const_new(
+        severity: Severity,
+        group_id: <Self as GenericEvent>::GroupId,
+        unique_id: <Self as GenericEvent>::UniqueId,
+    ) -> Self {
+        if group_id > (2u16.pow(14) - 1) {
+            panic!("Group ID too large");
+        }
+        Self {
+            base: EventBase {
+                severity,
+                group_id,
+                unique_id,
+                phantom: PhantomData,
+            },
+        }
+    }
+
+    const_from_fn!(const_from_info, EventU32TypedSev, SeverityInfo);
+    const_from_fn!(const_from_low, EventU32TypedSev, SeverityLow);
+    const_from_fn!(const_from_medium, EventU32TypedSev, SeverityMedium);
+    const_from_fn!(const_from_high, EventU32TypedSev, SeverityHigh);
+}
+
+impl<SEVERITY: HasSeverity> EventU32TypedSev<SEVERITY> {
+    /// This is similar to [EventU32::new] but the severity is a type generic, which allows to
+    /// have distinct types for events with different severities
+    pub fn new(
+        group_id: <Self as GenericEvent>::GroupId,
+        unique_id: <Self as GenericEvent>::UniqueId,
+    ) -> Option<Self> {
+        let event = EventU32::new(SEVERITY::SEVERITY, group_id, unique_id)?;
+        Some(Self {
+            event,
+            phantom: PhantomData,
+        })
+    }
+
+    /// Const version of [Self::new], but panics on invalid group ID input values.
+    pub const fn const_new(
+        group_id: <Self as GenericEvent>::GroupId,
+        unique_id: <Self as GenericEvent>::UniqueId,
+    ) -> Self {
+        let event = EventU32::const_new(SEVERITY::SEVERITY, group_id, unique_id);
+        Self {
+            event,
+            phantom: PhantomData,
+        }
+    }
+
+    fn try_from_generic(expected: Severity, raw: u32) -> Result<Self, Severity> {
+        let severity = Severity::try_from(((raw >> 30) & 0b11) as u8).unwrap();
+        if severity != expected {
+            return Err(severity);
+        }
+        Ok(Self::const_new(
+            ((raw >> 16) & 0x3FFF) as u16,
+            (raw & 0xFFFF) as u16,
+        ))
+    }
+}
+
+impl From<u32> for EventU32 {
+    fn from(raw: u32) -> Self {
+        // Severity conversion from u8 should never fail
+        let severity = Severity::try_from(((raw >> 30) & 0b11) as u8).unwrap();
+        let group_id = ((raw >> 16) & 0x3FFF) as u16;
+        let unique_id = (raw & 0xFFFF) as u16;
+        // Sanitized input, should never fail
+        Self::const_new(severity, group_id, unique_id)
+    }
+}
+
+try_from_impls!(SeverityInfo, Severity::INFO, u32, EventU32TypedSev);
+try_from_impls!(SeverityLow, Severity::LOW, u32, EventU32TypedSev);
+try_from_impls!(SeverityMedium, Severity::MEDIUM, u32, EventU32TypedSev);
+try_from_impls!(SeverityHigh, Severity::HIGH, u32, EventU32TypedSev);
+
+impl UnsignedEnum for EventU32 {
+    fn size(&self) -> usize {
+        core::mem::size_of::<u32>()
+    }
+
+    fn write_to_be_bytes(&self, buf: &mut [u8]) -> Result<usize, ByteConversionError> {
+        self.base.write_to_bytes(self.raw(), buf, self.size())
+    }
+}
+
+impl EcssEnumeration for EventU32 {
+    fn pfc(&self) -> u8 {
+        u32::BITS as u8
+    }
+}
+
+//noinspection RsTraitImplementation
+impl<SEVERITY: HasSeverity> UnsignedEnum for EventU32TypedSev<SEVERITY> {
+    delegate!(to self.event {
+        fn size(&self) -> usize;
+        fn write_to_be_bytes(&self, buf: &mut [u8]) -> Result<usize, ByteConversionError>;
+    });
+}
+
+//noinspection RsTraitImplementation
+impl<SEVERITY: HasSeverity> EcssEnumeration for EventU32TypedSev<SEVERITY> {
+    delegate!(to self.event {
+        fn pfc(&self) -> u8;
+    });
+}
+
+#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
+pub struct EventU16 {
+    base: EventBase<u16, u8, u8>,
+}
+
+#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
+pub struct EventU16TypedSev<SEVERITY> {
+    event: EventU16,
+    phantom: PhantomData<SEVERITY>,
+}
+
+impl<Severity: HasSeverity> AsRef<EventU16> for EventU16TypedSev<Severity> {
+    fn as_ref(&self) -> &EventU16 {
+        &self.event
+    }
+}
+
+impl<Severity: HasSeverity> AsMut<EventU16> for EventU16TypedSev<Severity> {
+    fn as_mut(&mut self) -> &mut EventU16 {
+        &mut self.event
+    }
+}
+
+impl EventU16 {
+    /// Generate a small event. The raw representation of a small event has 16 bits.
+    /// If the passed group ID is invalid (too large), [None] wil be returned
+    ///
+    /// # Parameter
+    ///
+    /// * `severity`: Each event has a [severity][Severity]. The raw value of the severity will
+    ///        be stored inside the uppermost 2 bits of the raw event ID
+    /// * `group_id`: Related events can be grouped using a group ID. The group ID will occupy the
+    ///        next 6 bits after the severity. Therefore, the size is limited by dec 63 hex 0x3F.
+    /// * `unique_id`: Each event has a unique 8 bit ID occupying the last 8 bits of the
+    ///       raw event ID
+    pub fn new(
+        severity: Severity,
+        group_id: <Self as GenericEvent>::GroupId,
+        unique_id: <Self as GenericEvent>::UniqueId,
+    ) -> Option<Self> {
+        if group_id > (2u8.pow(6) - 1) {
+            return None;
+        }
+        Some(Self {
+            base: EventBase {
+                severity,
+                group_id,
+                unique_id,
+                phantom: Default::default(),
+            },
+        })
+    }
+
+    /// Const version of [Self::new], but panics on invalid group ID input values.
+    pub const fn const_new(
+        severity: Severity,
+        group_id: <Self as GenericEvent>::GroupId,
+        unique_id: <Self as GenericEvent>::UniqueId,
+    ) -> Self {
+        if group_id > (2u8.pow(6) - 1) {
+            panic!("Group ID too large");
+        }
+        Self {
+            base: EventBase {
+                severity,
+                group_id,
+                unique_id,
+                phantom: PhantomData,
+            },
+        }
+    }
+    const_from_fn!(const_from_info, EventU16TypedSev, SeverityInfo);
+    const_from_fn!(const_from_low, EventU16TypedSev, SeverityLow);
+    const_from_fn!(const_from_medium, EventU16TypedSev, SeverityMedium);
+    const_from_fn!(const_from_high, EventU16TypedSev, SeverityHigh);
+}
+
+impl<SEVERITY: HasSeverity> EventU16TypedSev<SEVERITY> {
+    /// This is similar to [EventU16::new] but the severity is a type generic, which allows to
+    /// have distinct types for events with different severities
+    pub fn new(
+        group_id: <Self as GenericEvent>::GroupId,
+        unique_id: <Self as GenericEvent>::UniqueId,
+    ) -> Option<Self> {
+        let event = EventU16::new(SEVERITY::SEVERITY, group_id, unique_id)?;
+        Some(Self {
+            event,
+            phantom: PhantomData,
+        })
+    }
+
+    /// Const version of [Self::new], but panics on invalid group ID input values.
+    pub const fn const_new(
+        group_id: <Self as GenericEvent>::GroupId,
+        unique_id: <Self as GenericEvent>::UniqueId,
+    ) -> Self {
+        let event = EventU16::const_new(SEVERITY::SEVERITY, group_id, unique_id);
+        Self {
+            event,
+            phantom: PhantomData,
+        }
+    }
+
+    fn try_from_generic(expected: Severity, raw: u16) -> Result<Self, Severity> {
+        let severity = Severity::try_from(((raw >> 14) & 0b11) as u8).unwrap();
+        if severity != expected {
+            return Err(severity);
+        }
+        Ok(Self::const_new(
+            ((raw >> 8) & 0x3F) as u8,
+            (raw & 0xFF) as u8,
+        ))
+    }
+}
+
+impl_event_provider!(EventU16, EventU16TypedSev, u16, u8, u8);
+
+impl UnsignedEnum for EventU16 {
+    fn size(&self) -> usize {
+        core::mem::size_of::<u16>()
+    }
+
+    fn write_to_be_bytes(&self, buf: &mut [u8]) -> Result<usize, ByteConversionError> {
+        self.base.write_to_bytes(self.raw(), buf, self.size())
+    }
+}
+impl EcssEnumeration for EventU16 {
+    #[inline]
+    fn pfc(&self) -> u8 {
+        u16::BITS as u8
+    }
+}
+
+//noinspection RsTraitImplementation
+impl<SEVERITY: HasSeverity> UnsignedEnum for EventU16TypedSev<SEVERITY> {
+    delegate!(to self.event {
+        fn size(&self) -> usize;
+        fn write_to_be_bytes(&self, buf: &mut [u8]) -> Result<usize, ByteConversionError>;
+    });
+}
+
+//noinspection RsTraitImplementation
+impl<SEVERITY: HasSeverity> EcssEnumeration for EventU16TypedSev<SEVERITY> {
+    delegate!(to self.event {
+        fn pfc(&self) -> u8;
+    });
+}
+
+impl From<u16> for EventU16 {
+    fn from(raw: <Self as GenericEvent>::Raw) -> Self {
+        let severity = Severity::try_from(((raw >> 14) & 0b11) as u8).unwrap();
+        let group_id = ((raw >> 8) & 0x3F) as u8;
+        let unique_id = (raw & 0xFF) as u8;
+        // Sanitized input, new call should never fail
+        Self::const_new(severity, group_id, unique_id)
+    }
+}
+
+try_from_impls!(SeverityInfo, Severity::INFO, u16, EventU16TypedSev);
+try_from_impls!(SeverityLow, Severity::LOW, u16, EventU16TypedSev);
+try_from_impls!(SeverityMedium, Severity::MEDIUM, u16, EventU16TypedSev);
+try_from_impls!(SeverityHigh, Severity::HIGH, u16, EventU16TypedSev);
+
+impl<Severity: HasSeverity> PartialEq<EventU32> for EventU32TypedSev<Severity> {
+    #[inline]
+    fn eq(&self, other: &EventU32) -> bool {
+        self.raw() == other.raw()
+    }
+}
+
+impl<Severity: HasSeverity> PartialEq<EventU32TypedSev<Severity>> for EventU32 {
+    #[inline]
+    fn eq(&self, other: &EventU32TypedSev<Severity>) -> bool {
+        self.raw() == other.raw()
+    }
+}
+
+impl<Severity: HasSeverity> PartialEq<EventU16> for EventU16TypedSev<Severity> {
+    #[inline]
+    fn eq(&self, other: &EventU16) -> bool {
+        self.raw() == other.raw()
+    }
+}
+
+impl<Severity: HasSeverity> PartialEq<EventU16TypedSev<Severity>> for EventU16 {
+    #[inline]
+    fn eq(&self, other: &EventU16TypedSev<Severity>) -> bool {
+        self.raw() == other.raw()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::EventU32TypedSev;
+    use super::*;
+    use spacepackets::ByteConversionError;
+    use std::mem::size_of;
+
+    fn assert_size<T>(_: T, val: usize) {
+        assert_eq!(size_of::<T>(), val);
+    }
+
+    const INFO_EVENT: EventU32TypedSev<SeverityInfo> = EventU32TypedSev::const_new(0, 0);
+    const INFO_EVENT_SMALL: EventU16TypedSev<SeverityInfo> = EventU16TypedSev::const_new(0, 0);
+    const HIGH_SEV_EVENT: EventU32TypedSev<SeverityHigh> =
+        EventU32TypedSev::const_new(0x3FFF, 0xFFFF);
+    const HIGH_SEV_EVENT_SMALL: EventU16TypedSev<SeverityHigh> =
+        EventU16TypedSev::const_new(0x3F, 0xff);
+
+    /// This working is a test in itself.
+    const INFO_REDUCED: EventU32 = EventU32::const_from_info(INFO_EVENT);
+
+    #[test]
+    fn test_normal_from_raw_conversion() {
+        let conv_from_raw = EventU32TypedSev::<SeverityInfo>::try_from(INFO_EVENT.raw())
+            .expect("Creating typed EventU32 failed");
+        assert_eq!(conv_from_raw, INFO_EVENT);
+    }
+
+    #[test]
+    fn test_small_from_raw_conversion() {
+        let conv_from_raw = EventU16TypedSev::<SeverityInfo>::try_from(INFO_EVENT_SMALL.raw())
+            .expect("Creating typed EventU16 failed");
+        assert_eq!(conv_from_raw, INFO_EVENT_SMALL);
+    }
+
+    #[test]
+    fn verify_normal_size() {
+        assert_size(INFO_EVENT.raw(), 4)
+    }
+
+    #[test]
+    fn verify_small_size() {
+        assert_size(INFO_EVENT_SMALL.raw(), 2)
+    }
+
+    #[test]
+    fn test_normal_event_getters() {
+        assert_eq!(INFO_EVENT.severity(), Severity::INFO);
+        assert_eq!(INFO_EVENT.unique_id(), 0);
+        assert_eq!(INFO_EVENT.group_id(), 0);
+        let raw_event = INFO_EVENT.raw();
+        assert_eq!(raw_event, 0x00000000);
+    }
+
+    #[test]
+    fn test_small_event_getters() {
+        assert_eq!(INFO_EVENT_SMALL.severity(), Severity::INFO);
+        assert_eq!(INFO_EVENT_SMALL.unique_id(), 0);
+        assert_eq!(INFO_EVENT_SMALL.group_id(), 0);
+        let raw_event = INFO_EVENT_SMALL.raw();
+        assert_eq!(raw_event, 0x00000000);
+    }
+
+    #[test]
+    fn all_ones_event_regular() {
+        assert_eq!(HIGH_SEV_EVENT.severity(), Severity::HIGH);
+        assert_eq!(HIGH_SEV_EVENT.group_id(), 0x3FFF);
+        assert_eq!(HIGH_SEV_EVENT.unique_id(), 0xFFFF);
+        let raw_event = HIGH_SEV_EVENT.raw();
+        assert_eq!(raw_event, 0xFFFFFFFF);
+    }
+
+    #[test]
+    fn all_ones_event_small() {
+        assert_eq!(HIGH_SEV_EVENT_SMALL.severity(), Severity::HIGH);
+        assert_eq!(HIGH_SEV_EVENT_SMALL.group_id(), 0x3F);
+        assert_eq!(HIGH_SEV_EVENT_SMALL.unique_id(), 0xFF);
+        let raw_event = HIGH_SEV_EVENT_SMALL.raw();
+        assert_eq!(raw_event, 0xFFFF);
+    }
+
+    #[test]
+    fn invalid_group_id_normal() {
+        assert!(EventU32TypedSev::<SeverityMedium>::new(2_u16.pow(14), 0).is_none());
+    }
+
+    #[test]
+    fn invalid_group_id_small() {
+        assert!(EventU16TypedSev::<SeverityMedium>::new(2_u8.pow(6), 0).is_none());
+    }
+
+    #[test]
+    fn regular_new() {
+        assert_eq!(
+            EventU32TypedSev::<SeverityInfo>::new(0, 0).expect("Creating regular event failed"),
+            INFO_EVENT
+        );
+    }
+
+    #[test]
+    fn small_new() {
+        assert_eq!(
+            EventU16TypedSev::<SeverityInfo>::new(0, 0).expect("Creating regular event failed"),
+            INFO_EVENT_SMALL
+        );
+    }
+
+    #[test]
+    fn as_largest_type() {
+        let event_raw = HIGH_SEV_EVENT.raw_as_largest_type();
+        assert_size(event_raw, 4);
+        assert_eq!(event_raw, 0xFFFFFFFF);
+    }
+
+    #[test]
+    fn as_largest_type_for_small_event() {
+        let event_raw = HIGH_SEV_EVENT_SMALL.raw_as_largest_type();
+        assert_size(event_raw, 4);
+        assert_eq!(event_raw, 0xFFFF);
+    }
+
+    #[test]
+    fn as_largest_group_id() {
+        let group_id = HIGH_SEV_EVENT.group_id_as_largest_type();
+        assert_size(group_id, 2);
+        assert_eq!(group_id, 0x3FFF);
+    }
+
+    #[test]
+    fn as_largest_group_id_small_event() {
+        let group_id = HIGH_SEV_EVENT_SMALL.group_id_as_largest_type();
+        assert_size(group_id, 2);
+        assert_eq!(group_id, 0x3F);
+    }
+
+    #[test]
+    fn write_to_buf() {
+        let mut buf: [u8; 4] = [0; 4];
+        assert!(HIGH_SEV_EVENT.write_to_be_bytes(&mut buf).is_ok());
+        let val_from_raw = u32::from_be_bytes(buf);
+        assert_eq!(val_from_raw, 0xFFFFFFFF);
+    }
+
+    #[test]
+    fn write_to_buf_small() {
+        let mut buf: [u8; 2] = [0; 2];
+        assert!(HIGH_SEV_EVENT_SMALL.write_to_be_bytes(&mut buf).is_ok());
+        let val_from_raw = u16::from_be_bytes(buf);
+        assert_eq!(val_from_raw, 0xFFFF);
+    }
+
+    #[test]
+    fn write_to_buf_insufficient_buf() {
+        let mut buf: [u8; 3] = [0; 3];
+        let err = HIGH_SEV_EVENT.write_to_be_bytes(&mut buf);
+        assert!(err.is_err());
+        let err = err.unwrap_err();
+        if let ByteConversionError::ToSliceTooSmall(missmatch) = err {
+            assert_eq!(missmatch.expected, 4);
+            assert_eq!(missmatch.found, 3);
+        }
+    }
+
+    #[test]
+    fn write_to_buf_small_insufficient_buf() {
+        let mut buf: [u8; 1] = [0; 1];
+        let err = HIGH_SEV_EVENT_SMALL.write_to_be_bytes(&mut buf);
+        assert!(err.is_err());
+        let err = err.unwrap_err();
+        if let ByteConversionError::ToSliceTooSmall(missmatch) = err {
+            assert_eq!(missmatch.expected, 2);
+            assert_eq!(missmatch.found, 1);
+        }
+    }
+
+    #[test]
+    fn severity_from_invalid_raw_val() {
+        let invalid = 0xFF;
+        assert!(Severity::try_from(invalid).is_err());
+        let invalid = Severity::HIGH as u8 + 1;
+        assert!(Severity::try_from(invalid).is_err());
+    }
+
+    #[test]
+    fn reduction() {
+        let event = EventU32TypedSev::<SeverityInfo>::const_new(1, 1);
+        let raw = event.raw();
+        let reduced: EventU32 = event.into();
+        assert_eq!(reduced.group_id(), 1);
+        assert_eq!(reduced.unique_id(), 1);
+        assert_eq!(raw, reduced.raw());
+    }
+
+    #[test]
+    fn const_reducation() {
+        assert_eq!(INFO_REDUCED.raw(), INFO_EVENT.raw());
+    }
+}
diff --git a/fsrc-core/src/executable.rs b/satrs-core/src/executable.rs
similarity index 100%
rename from fsrc-core/src/executable.rs
rename to satrs-core/src/executable.rs
diff --git a/fsrc-core/src/hal/host/mod.rs b/satrs-core/src/hal/host/mod.rs
similarity index 100%
rename from fsrc-core/src/hal/host/mod.rs
rename to satrs-core/src/hal/host/mod.rs
diff --git a/fsrc-core/src/hal/host/udp_server.rs b/satrs-core/src/hal/host/udp_server.rs
similarity index 88%
rename from fsrc-core/src/hal/host/udp_server.rs
rename to satrs-core/src/hal/host/udp_server.rs
index 2c7cd37..8f80eb7 100644
--- a/fsrc-core/src/hal/host/udp_server.rs
+++ b/satrs-core/src/hal/host/udp_server.rs
@@ -1,5 +1,5 @@
 //! UDP server helper components
-use crate::tmtc::ReceivesTc;
+use crate::tmtc::{ReceivesTc, ReceivesTcCore};
 use std::boxed::Box;
 use std::io::{Error, ErrorKind};
 use std::net::{SocketAddr, ToSocketAddrs, UdpSocket};
@@ -12,20 +12,21 @@ use std::vec::Vec;
 /// be declared upfront. This avoids dynamic allocation during run-time. The user can specify a TC
 /// receiver in form of a special trait object which implements [ReceivesTc]. Please note that the
 /// receiver should copy out the received data if it the data is required past the
-/// [ReceivesTc::pass_tc] call.
+/// [ReceivesTcCore::pass_tc] call.
 ///
 /// # Examples
 ///
 /// ```
 /// use std::net::{IpAddr, Ipv4Addr, SocketAddr, UdpSocket};
-/// use fsrc_core::hal::host::udp_server::UdpTcServer;
-/// use fsrc_core::tmtc::ReceivesTc;
+/// use spacepackets::ecss::SerializablePusPacket;
+/// use satrs_core::hal::host::udp_server::UdpTcServer;
+/// use satrs_core::tmtc::{ReceivesTc, ReceivesTcCore};
 /// use spacepackets::SpHeader;
 /// use spacepackets::tc::PusTc;
 ///
 /// #[derive (Default)]
 /// struct PingReceiver {}
-/// impl ReceivesTc for PingReceiver {
+/// impl ReceivesTcCore for PingReceiver {
 ///    type Error = ();
 ///    fn pass_tc(&mut self, tc_raw: &[u8]) -> Result<(), Self::Error> {
 ///         assert_eq!(tc_raw.len(), 13);
@@ -38,10 +39,10 @@ use std::vec::Vec;
 /// let ping_receiver = PingReceiver::default();
 /// let mut udp_tc_server = UdpTcServer::new(dest_addr, 2048, Box::new(ping_receiver))
 ///       .expect("Creating UDP TMTC server failed");
-/// let mut sph = SpHeader::tc(0x02, 0, 0).unwrap();
+/// let mut sph = SpHeader::tc_unseg(0x02, 0, 0).unwrap();
 /// let pus_tc = PusTc::new_simple(&mut sph, 17, 1, None, true);
 /// let len = pus_tc
-///     .write_to(&mut buf)
+///     .write_to_bytes(&mut buf)
 ///     .expect("Error writing PUS TC packet");
 /// assert_eq!(len, 13);
 /// let client = UdpSocket::bind("127.0.0.1:7778").expect("Connecting to UDP server failed");
@@ -89,6 +90,14 @@ impl<E: PartialEq> PartialEq for ReceiveResult<E> {
 
 impl<E: Eq + PartialEq> Eq for ReceiveResult<E> {}
 
+impl<E: 'static> ReceivesTcCore for UdpTcServer<E> {
+    type Error = E;
+
+    fn pass_tc(&mut self, tc_raw: &[u8]) -> Result<(), Self::Error> {
+        self.tc_receiver.pass_tc(tc_raw)
+    }
+}
+
 impl<E: 'static> UdpTcServer<E> {
     pub fn new<A: ToSocketAddrs>(
         addr: A,
@@ -132,7 +141,8 @@ impl<E: 'static> UdpTcServer<E> {
 #[cfg(test)]
 mod tests {
     use crate::hal::host::udp_server::{ReceiveResult, UdpTcServer};
-    use crate::tmtc::ReceivesTc;
+    use crate::tmtc::ReceivesTcCore;
+    use spacepackets::ecss::SerializablePusPacket;
     use spacepackets::tc::PusTc;
     use spacepackets::SpHeader;
     use std::boxed::Box;
@@ -140,12 +150,14 @@ mod tests {
     use std::net::{IpAddr, Ipv4Addr, SocketAddr, UdpSocket};
     use std::vec::Vec;
 
+    fn is_send<T: Send>(_: &T) {}
+
     #[derive(Default)]
     struct PingReceiver {
         pub sent_cmds: VecDeque<Vec<u8>>,
     }
 
-    impl ReceivesTc for PingReceiver {
+    impl ReceivesTcCore for PingReceiver {
         type Error = ();
 
         fn pass_tc(&mut self, tc_raw: &[u8]) -> Result<(), Self::Error> {
@@ -161,12 +173,14 @@ mod tests {
         let mut buf = [0; 32];
         let dest_addr = SocketAddr::new(IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1)), 7777);
         let ping_receiver = PingReceiver::default();
+        is_send(&ping_receiver);
         let mut udp_tc_server = UdpTcServer::new(dest_addr, 2048, Box::new(ping_receiver))
             .expect("Creating UDP TMTC server failed");
-        let mut sph = SpHeader::tc(0x02, 0, 0).unwrap();
+        is_send(&udp_tc_server);
+        let mut sph = SpHeader::tc_unseg(0x02, 0, 0).unwrap();
         let pus_tc = PusTc::new_simple(&mut sph, 17, 1, None, true);
         let len = pus_tc
-            .write_to(&mut buf)
+            .write_to_bytes(&mut buf)
             .expect("Error writing PUS TC packet");
         let client = UdpSocket::bind("127.0.0.1:7778").expect("Connecting to UDP server failed");
         client
diff --git a/fsrc-core/src/hal/mod.rs b/satrs-core/src/hal/mod.rs
similarity index 61%
rename from fsrc-core/src/hal/mod.rs
rename to satrs-core/src/hal/mod.rs
index ddaf8f3..c422a72 100644
--- a/fsrc-core/src/hal/mod.rs
+++ b/satrs-core/src/hal/mod.rs
@@ -1,3 +1,4 @@
 //! # Hardware Abstraction Layer module
 #[cfg(feature = "std")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "std")))]
 pub mod host;
diff --git a/satrs-core/src/hk.rs b/satrs-core/src/hk.rs
new file mode 100644
index 0000000..dc6c72e
--- /dev/null
+++ b/satrs-core/src/hk.rs
@@ -0,0 +1,16 @@
+pub type CollectionIntervalFactor = u32;
+pub type UniqueId = u32;
+
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+pub enum HkRequest {
+    OneShot(UniqueId),
+    Enable(UniqueId),
+    Disable(UniqueId),
+    ModifyCollectionInterval(UniqueId, CollectionIntervalFactor),
+}
+
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+pub struct TargetedHkRequest {
+    target: u32,
+    hk_request: HkRequest,
+}
diff --git a/satrs-core/src/lib.rs b/satrs-core/src/lib.rs
new file mode 100644
index 0000000..940300e
--- /dev/null
+++ b/satrs-core/src/lib.rs
@@ -0,0 +1,49 @@
+//! # Core components of the sat-rs framework
+//!
+//! You can find more information about the sat-rs framework on the
+//! [homepage](https://egit.irs.uni-stuttgart.de/rust/sat-rs).
+//!
+//! ## Overview
+//!
+//! The core modules of this crate include
+//!
+//!  - The [event manager][event_man] module which provides a publish and
+//!    and subscribe to route events.
+//!  - The [pus] module which provides special support for projects using
+//!    the [ECSS PUS C standard](https://ecss.nl/standard/ecss-e-st-70-41c-space-engineering-telemetry-and-telecommand-packet-utilization-15-april-2016/).
+#![no_std]
+#![cfg_attr(doc_cfg, feature(doc_cfg))]
+#[cfg(feature = "alloc")]
+extern crate alloc;
+#[cfg(feature = "alloc")]
+extern crate downcast_rs;
+#[cfg(any(feature = "std", test))]
+extern crate std;
+
+pub mod error;
+#[cfg(feature = "alloc")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "alloc")))]
+pub mod event_man;
+pub mod events;
+#[cfg(feature = "std")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "std")))]
+pub mod executable;
+pub mod hal;
+pub mod hk;
+pub mod mode;
+pub mod objects;
+pub mod params;
+#[cfg(feature = "alloc")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "alloc")))]
+pub mod pool;
+pub mod power;
+pub mod pus;
+pub mod request;
+pub mod res_code;
+pub mod seq_count;
+pub mod tmtc;
+
+pub use spacepackets;
+
+// Generic channel ID type.
+pub type ChannelId = u32;
diff --git a/satrs-core/src/mode.rs b/satrs-core/src/mode.rs
new file mode 100644
index 0000000..e29cbf0
--- /dev/null
+++ b/satrs-core/src/mode.rs
@@ -0,0 +1,93 @@
+use crate::tmtc::TargetId;
+use core::mem::size_of;
+use serde::{Deserialize, Serialize};
+use spacepackets::{ByteConversionError, SizeMissmatch};
+
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+pub struct ModeAndSubmode {
+    mode: u32,
+    submode: u16,
+}
+
+impl ModeAndSubmode {
+    pub const fn new_mode_only(mode: u32) -> Self {
+        Self { mode, submode: 0 }
+    }
+
+    pub const fn new(mode: u32, submode: u16) -> Self {
+        Self { mode, submode }
+    }
+
+    pub fn raw_len() -> usize {
+        size_of::<u32>() + size_of::<u16>()
+    }
+
+    pub fn from_be_bytes(buf: &[u8]) -> Result<Self, ByteConversionError> {
+        if buf.len() < 6 {
+            return Err(ByteConversionError::FromSliceTooSmall(SizeMissmatch {
+                expected: 6,
+                found: buf.len(),
+            }));
+        }
+        Ok(Self {
+            mode: u32::from_be_bytes(buf[0..4].try_into().unwrap()),
+            submode: u16::from_be_bytes(buf[4..6].try_into().unwrap()),
+        })
+    }
+
+    pub fn mode(&self) -> u32 {
+        self.mode
+    }
+
+    pub fn submode(&self) -> u16 {
+        self.submode
+    }
+}
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+pub struct ModeCommand {
+    pub address: TargetId,
+    pub mode_submode: ModeAndSubmode,
+}
+
+impl ModeCommand {
+    pub const fn new(address: TargetId, mode_submode: ModeAndSubmode) -> Self {
+        Self {
+            address,
+            mode_submode,
+        }
+    }
+
+    pub fn address(&self) -> TargetId {
+        self.address
+    }
+
+    pub fn mode_submode(&self) -> ModeAndSubmode {
+        self.mode_submode
+    }
+
+    pub fn mode(&self) -> u32 {
+        self.mode_submode.mode
+    }
+
+    pub fn submode(&self) -> u16 {
+        self.mode_submode.submode
+    }
+}
+
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+pub enum ModeRequest {
+    SetMode(ModeAndSubmode),
+    ReadMode,
+    AnnounceMode,
+    AnnounceModeRecursive,
+}
+
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+pub struct TargetedModeRequest {
+    target_id: TargetId,
+    mode_request: ModeRequest,
+}
diff --git a/fsrc-core/src/objects.rs b/satrs-core/src/objects.rs
similarity index 71%
rename from fsrc-core/src/objects.rs
rename to satrs-core/src/objects.rs
index 0654f98..0ff117f 100644
--- a/fsrc-core/src/objects.rs
+++ b/satrs-core/src/objects.rs
@@ -10,7 +10,7 @@
 //! ```rust
 //! use std::any::Any;
 //! use std::error::Error;
-//! use fsrc_core::objects::{ManagedSystemObject, ObjectId, ObjectManager, SystemObject};
+//! use satrs_core::objects::{ManagedSystemObject, ObjectId, ObjectManager, SystemObject};
 //!
 //! struct ExampleSysObj {
 //!     id: ObjectId,
@@ -51,87 +51,99 @@
 //!  assert_eq!(example_obj.id, obj_id);
 //!  assert_eq!(example_obj.dummy, 42);
 //! ```
+use crate::tmtc::TargetId;
+#[cfg(feature = "alloc")]
 use alloc::boxed::Box;
-#[cfg(not(feature = "std"))]
-use alloc::vec::Vec;
+#[cfg(feature = "alloc")]
+pub use alloc_mod::*;
+#[cfg(feature = "alloc")]
 use downcast_rs::Downcast;
+#[cfg(feature = "alloc")]
 use hashbrown::HashMap;
 #[cfg(feature = "std")]
 use std::error::Error;
 
 #[derive(PartialEq, Eq, Hash, Copy, Clone, Debug)]
 pub struct ObjectId {
-    pub id: u32,
+    pub id: TargetId,
     pub name: &'static str,
 }
 
-/// Each object which is stored inside the [object manager][ObjectManager] needs to implemented
-/// this trait
-pub trait SystemObject: Downcast {
-    type Error;
-    fn get_object_id(&self) -> &ObjectId;
-    fn initialize(&mut self) -> Result<(), Self::Error>;
-}
-downcast_rs::impl_downcast!(SystemObject assoc Error);
-
-pub trait ManagedSystemObject: SystemObject + Send {}
-downcast_rs::impl_downcast!(ManagedSystemObject assoc Error);
-
-/// Helper module to manage multiple [ManagedSystemObjects][ManagedSystemObject] by mapping them
-/// using an [object ID][ObjectId]
 #[cfg(feature = "alloc")]
-pub struct ObjectManager<E> {
-    obj_map: HashMap<ObjectId, Box<dyn ManagedSystemObject<Error = E>>>,
-}
+pub mod alloc_mod {
+    use super::*;
 
-#[cfg(feature = "alloc")]
-impl<E: 'static> Default for ObjectManager<E> {
-    fn default() -> Self {
-        Self::new()
+    /// Each object which is stored inside the [object manager][ObjectManager] needs to implemented
+    /// this trait
+    pub trait SystemObject: Downcast {
+        type Error;
+        fn get_object_id(&self) -> &ObjectId;
+        fn initialize(&mut self) -> Result<(), Self::Error>;
     }
-}
+    downcast_rs::impl_downcast!(SystemObject assoc Error);
 
-#[cfg(feature = "alloc")]
-impl<E: 'static> ObjectManager<E> {
-    pub fn new() -> Self {
-        ObjectManager {
-            obj_map: HashMap::new(),
+    pub trait ManagedSystemObject: SystemObject + Send {}
+    downcast_rs::impl_downcast!(ManagedSystemObject assoc Error);
+
+    /// Helper module to manage multiple [ManagedSystemObjects][ManagedSystemObject] by mapping them
+    /// using an [object ID][ObjectId]
+    #[cfg(feature = "alloc")]
+    pub struct ObjectManager<E> {
+        obj_map: HashMap<ObjectId, Box<dyn ManagedSystemObject<Error = E>>>,
+    }
+
+    #[cfg(feature = "alloc")]
+    impl<E: 'static> Default for ObjectManager<E> {
+        fn default() -> Self {
+            Self::new()
         }
     }
-    pub fn insert(&mut self, sys_obj: Box<dyn ManagedSystemObject<Error = E>>) -> bool {
-        let obj_id = sys_obj.get_object_id();
-        if self.obj_map.contains_key(obj_id) {
-            return false;
-        }
-        self.obj_map.insert(*obj_id, sys_obj).is_none()
-    }
 
-    /// Initializes all System Objects in the hash map and returns the number of successful
-    /// initializations
-    pub fn initialize(&mut self) -> Result<u32, Box<dyn Error>> {
-        let mut init_success = 0;
-        for val in self.obj_map.values_mut() {
-            if val.initialize().is_ok() {
-                init_success += 1
+    #[cfg(feature = "alloc")]
+    impl<E: 'static> ObjectManager<E> {
+        pub fn new() -> Self {
+            ObjectManager {
+                obj_map: HashMap::new(),
             }
         }
-        Ok(init_success)
-    }
+        pub fn insert(&mut self, sys_obj: Box<dyn ManagedSystemObject<Error = E>>) -> bool {
+            let obj_id = sys_obj.get_object_id();
+            if self.obj_map.contains_key(obj_id) {
+                return false;
+            }
+            self.obj_map.insert(*obj_id, sys_obj).is_none()
+        }
 
-    /// Retrieve a reference to an object stored inside the manager. The type to retrieve needs to
-    /// be explicitly passed as a generic parameter or specified on the left hand side of the
-    /// expression.
-    pub fn get_ref<T: ManagedSystemObject<Error = E>>(&self, key: &ObjectId) -> Option<&T> {
-        self.obj_map.get(key).and_then(|o| o.downcast_ref::<T>())
-    }
+        /// Initializes all System Objects in the hash map and returns the number of successful
+        /// initializations
+        pub fn initialize(&mut self) -> Result<u32, Box<dyn Error>> {
+            let mut init_success = 0;
+            for val in self.obj_map.values_mut() {
+                if val.initialize().is_ok() {
+                    init_success += 1
+                }
+            }
+            Ok(init_success)
+        }
 
-    /// Retrieve a mutable reference to an object stored inside the manager. The type to retrieve
-    /// needs to be explicitly passed as a generic parameter or specified on the left hand side
-    /// of the expression.
-    pub fn get_mut<T: ManagedSystemObject<Error = E>>(&mut self, key: &ObjectId) -> Option<&mut T> {
-        self.obj_map
-            .get_mut(key)
-            .and_then(|o| o.downcast_mut::<T>())
+        /// Retrieve a reference to an object stored inside the manager. The type to retrieve needs to
+        /// be explicitly passed as a generic parameter or specified on the left hand side of the
+        /// expression.
+        pub fn get_ref<T: ManagedSystemObject<Error = E>>(&self, key: &ObjectId) -> Option<&T> {
+            self.obj_map.get(key).and_then(|o| o.downcast_ref::<T>())
+        }
+
+        /// Retrieve a mutable reference to an object stored inside the manager. The type to retrieve
+        /// needs to be explicitly passed as a generic parameter or specified on the left hand side
+        /// of the expression.
+        pub fn get_mut<T: ManagedSystemObject<Error = E>>(
+            &mut self,
+            key: &ObjectId,
+        ) -> Option<&mut T> {
+            self.obj_map
+                .get_mut(key)
+                .and_then(|o| o.downcast_mut::<T>())
+        }
     }
 }
 
diff --git a/satrs-core/src/params.rs b/satrs-core/src/params.rs
new file mode 100644
index 0000000..9df929b
--- /dev/null
+++ b/satrs-core/src/params.rs
@@ -0,0 +1,680 @@
+//! Parameter types and enums.
+//!
+//! This module contains various helper types.
+//!
+//! # Primtive Parameter Wrappers and Enumeration
+//!
+//! This module includes wrapper for primitive rust types using the newtype pattern.
+//! This was also done for pairs and triplets of these primitive types.
+//! The [WritableToBeBytes] was implemented for all those types as well, which allows to easily
+//! convert them into a network friendly raw byte format. The [ParamsRaw] enumeration groups
+//! all newtypes and implements the [WritableToBeBytes] trait itself.
+//!
+//! ## Example for primitive type wrapper
+//!
+//! ```
+//! use satrs_core::params::{ParamsRaw, ToBeBytes, U32Pair, WritableToBeBytes};
+//!
+//! let u32_pair = U32Pair(0x1010, 25);
+//! assert_eq!(u32_pair.0, 0x1010);
+//! assert_eq!(u32_pair.1, 25);
+//! // Convert to raw stream
+//! let raw_buf = u32_pair.to_be_bytes();
+//! assert_eq!(raw_buf, [0, 0, 0x10, 0x10, 0, 0, 0, 25]);
+//!
+//! // Convert to enum variant
+//! let params_raw: ParamsRaw = u32_pair.into();
+//! assert_eq!(params_raw, (0x1010_u32, 25_u32).into());
+//!
+//! // Convert to stream using the enum variant
+//! let mut other_raw_buf: [u8; 8] = [0; 8];
+//! params_raw.write_to_be_bytes(&mut other_raw_buf).expect("Writing parameter to buffer failed");
+//! assert_eq!(other_raw_buf, [0, 0, 0x10, 0x10, 0, 0, 0, 25]);
+//!
+//! // Create a pair from a raw stream
+//! let u32_pair_from_stream: U32Pair = raw_buf.as_slice().try_into().unwrap();
+//! assert_eq!(u32_pair_from_stream.0, 0x1010);
+//! assert_eq!(u32_pair_from_stream.1, 25);
+//! ```
+//!
+//! # Generic Parameter Enumeration
+//!
+//! The module also contains generic parameter enumerations.
+//! This includes the [ParamsHeapless] enumeration for contained values which do not require heap
+//! allocation, and the [Params] which enumerates [ParamsHeapless] and some additional types which
+//! require [alloc] support but allow for more flexbility.
+#[cfg(feature = "alloc")]
+use crate::pool::StoreAddr;
+#[cfg(feature = "alloc")]
+use alloc::string::{String, ToString};
+#[cfg(feature = "alloc")]
+use alloc::vec::Vec;
+use core::fmt::Debug;
+use core::mem::size_of;
+use paste::paste;
+use spacepackets::ecss::{EcssEnumU16, EcssEnumU32, EcssEnumU64, EcssEnumU8};
+use spacepackets::util::UnsignedEnum;
+use spacepackets::ByteConversionError;
+use spacepackets::SizeMissmatch;
+
+#[cfg(feature = "alloc")]
+pub use alloc_mod::*;
+pub use spacepackets::util::ToBeBytes;
+
+/// Generic trait which is used for objects which can be converted into a raw network (big) endian
+/// byte format.
+pub trait WritableToBeBytes {
+    fn raw_len(&self) -> usize;
+    /// Writes the object to a raw buffer in network endianness (big)
+    fn write_to_be_bytes(&self, buf: &mut [u8]) -> Result<usize, ByteConversionError>;
+}
+
+macro_rules! param_to_be_bytes_impl {
+    ($Newtype: ident) => {
+        impl WritableToBeBytes for $Newtype {
+            #[inline]
+            fn raw_len(&self) -> usize {
+                size_of::<<Self as ToBeBytes>::ByteArray>()
+            }
+
+            fn write_to_be_bytes(&self, buf: &mut [u8]) -> Result<usize, ByteConversionError> {
+                let raw_len = self.raw_len();
+                if buf.len() < raw_len {
+                    return Err(ByteConversionError::ToSliceTooSmall(SizeMissmatch {
+                        found: buf.len(),
+                        expected: raw_len,
+                    }));
+                }
+                buf[0..raw_len].copy_from_slice(&self.to_be_bytes());
+                Ok(raw_len)
+            }
+        }
+    };
+}
+
+macro_rules! primitive_newtypes_with_eq {
+    ($($ty: ty,)+) => {
+        $(
+            paste! {
+                #[derive(Debug, Copy, Clone, PartialEq, Eq)]
+                pub struct [<$ty:upper>](pub $ty);
+                #[derive(Debug, Copy, Clone, PartialEq, Eq)]
+                pub struct [<$ty:upper Pair>](pub $ty, pub $ty);
+                #[derive(Debug, Copy, Clone, PartialEq, Eq)]
+                pub struct [<$ty:upper Triplet>](pub $ty, pub $ty, pub $ty);
+
+                param_to_be_bytes_impl!([<$ty:upper>]);
+                param_to_be_bytes_impl!([<$ty:upper Pair>]);
+                param_to_be_bytes_impl!([<$ty:upper Triplet>]);
+
+                impl From<$ty> for [<$ty:upper>] {
+                    fn from(v: $ty) -> Self {
+                        Self(v)
+                    }
+                }
+                impl From<($ty, $ty)> for [<$ty:upper Pair>] {
+                    fn from(v: ($ty, $ty)) -> Self {
+                        Self(v.0, v.1)
+                    }
+                }
+                impl From<($ty, $ty, $ty)> for [<$ty:upper Triplet>] {
+                    fn from(v: ($ty, $ty, $ty)) -> Self {
+                        Self(v.0, v.1, v.2)
+                    }
+                }
+            }
+        )+
+    }
+}
+
+macro_rules! primitive_newtypes {
+    ($($ty: ty,)+) => {
+        $(
+            paste! {
+                #[derive(Debug, Copy, Clone, PartialEq)]
+                pub struct [<$ty:upper>](pub $ty);
+                #[derive(Debug, Copy, Clone, PartialEq)]
+                pub struct [<$ty:upper Pair>](pub $ty, pub $ty);
+                #[derive(Debug, Copy, Clone, PartialEq)]
+                pub struct [<$ty:upper Triplet>](pub $ty, pub $ty, pub $ty);
+
+                param_to_be_bytes_impl!([<$ty:upper>]);
+                param_to_be_bytes_impl!([<$ty:upper Pair>]);
+                param_to_be_bytes_impl!([<$ty:upper Triplet>]);
+
+                impl From<$ty> for [<$ty:upper>] {
+                    fn from(v: $ty) -> Self {
+                        Self(v)
+                    }
+                }
+                impl From<($ty, $ty)> for [<$ty:upper Pair>] {
+                    fn from(v: ($ty, $ty)) -> Self {
+                        Self(v.0, v.1)
+                    }
+                }
+                impl From<($ty, $ty, $ty)> for [<$ty:upper Triplet>] {
+                    fn from(v: ($ty, $ty, $ty)) -> Self {
+                        Self(v.0, v.1, v.2)
+                    }
+                }
+            }
+        )+
+    }
+}
+
+primitive_newtypes_with_eq!(u8, u16, u32, u64, i8, i16, i32, i64,);
+primitive_newtypes!(f32, f64,);
+
+macro_rules! scalar_byte_conversions_impl {
+    ($($ty: ty,)+) => {
+        $(
+            paste! {
+                impl ToBeBytes for [<$ty:upper>] {
+                    type ByteArray = [u8; size_of::<$ty>()];
+
+                    fn written_len(&self) -> usize {
+                        size_of::<Self::ByteArray>()
+                    }
+
+                    fn to_be_bytes(&self) -> Self::ByteArray {
+                        self.0.to_be_bytes()
+                    }
+                }
+
+                impl TryFrom<&[u8]> for [<$ty:upper>] {
+                    type Error = ByteConversionError;
+
+                    fn try_from(v: &[u8]) -> Result<Self, Self::Error>  {
+                        if v.len() < size_of::<$ty>() {
+                            return Err(ByteConversionError::FromSliceTooSmall(SizeMissmatch {
+                                expected: size_of::<$ty>(),
+                                found: v.len()
+                            }));
+                        }
+                        Ok([<$ty:upper>]($ty::from_be_bytes(v[0..size_of::<$ty>()].try_into().unwrap())))
+                    }
+                }
+            }
+        )+
+    }
+}
+
+macro_rules! pair_byte_conversions_impl {
+    ($($ty: ty,)+) => {
+        $(
+            paste! {
+                impl ToBeBytes for [<$ty:upper Pair>] {
+                    type ByteArray = [u8; size_of::<$ty>() * 2];
+
+                    fn written_len(&self) -> usize {
+                        size_of::<Self::ByteArray>()
+                    }
+
+                    fn to_be_bytes(&self) -> Self::ByteArray {
+                        let mut array = [0; size_of::<$ty>() * 2];
+                        array[0..size_of::<$ty>()].copy_from_slice(&self.0.to_be_bytes());
+                        array[
+                            size_of::<$ty>()..2 * size_of::<$ty>()
+                        ].copy_from_slice(&self.1.to_be_bytes());
+                        array
+                    }
+                }
+
+                impl TryFrom<&[u8]> for [<$ty:upper Pair>] {
+                    type Error = ByteConversionError;
+
+                    fn try_from(v: &[u8]) -> Result<Self, Self::Error>  {
+                        if v.len() < 2 * size_of::<$ty>() {
+                            return Err(ByteConversionError::FromSliceTooSmall(SizeMissmatch {
+                                expected: 2 * size_of::<$ty>(),
+                                found: v.len()
+                            }));
+                        }
+                        Ok([<$ty:upper Pair>](
+                            $ty::from_be_bytes(v[0..size_of::<$ty>()].try_into().unwrap()),
+                            $ty::from_be_bytes(v[size_of::<$ty>()..2 * size_of::<$ty>()].try_into().unwrap())
+                        ))
+                    }
+                }
+            }
+        )+
+    }
+}
+
+macro_rules! triplet_to_be_bytes_impl {
+    ($($ty: ty,)+) => {
+        $(
+            paste! {
+                impl ToBeBytes for [<$ty:upper Triplet>] {
+                    type ByteArray = [u8; size_of::<$ty>() * 3];
+
+                    fn written_len(&self) -> usize {
+                        size_of::<Self::ByteArray>()
+                    }
+
+                    fn to_be_bytes(&self) -> Self::ByteArray {
+                        let mut array = [0; size_of::<$ty>() * 3];
+                        array[0..size_of::<$ty>()].copy_from_slice(&self.0.to_be_bytes());
+                        array[
+                            size_of::<$ty>()..2 * size_of::<$ty>()
+                        ].copy_from_slice(&self.1.to_be_bytes());
+                        array[
+                            2 * size_of::<$ty>()..3 * size_of::<$ty>()
+                        ].copy_from_slice(&self.2.to_be_bytes());
+                        array
+                    }
+                }
+                impl TryFrom<&[u8]> for [<$ty:upper Triplet>] {
+                    type Error = ByteConversionError;
+
+                    fn try_from(v: &[u8]) -> Result<Self, Self::Error>  {
+                        if v.len() < 3 * size_of::<$ty>() {
+                            return Err(ByteConversionError::FromSliceTooSmall(SizeMissmatch {
+                                expected: 3 * size_of::<$ty>(),
+                                found: v.len()
+                            }));
+                        }
+                        Ok([<$ty:upper Triplet>](
+                            $ty::from_be_bytes(v[0..size_of::<$ty>()].try_into().unwrap()),
+                            $ty::from_be_bytes(v[size_of::<$ty>()..2 * size_of::<$ty>()].try_into().unwrap()),
+                            $ty::from_be_bytes(v[2 * size_of::<$ty>()..3 * size_of::<$ty>()].try_into().unwrap())
+                        ))
+                    }
+                }
+            }
+        )+
+    }
+}
+
+scalar_byte_conversions_impl!(u8, u16, u32, u64, i8, i16, i32, i64, f32, f64,);
+
+impl ToBeBytes for U8Pair {
+    type ByteArray = [u8; 2];
+
+    fn written_len(&self) -> usize {
+        size_of::<Self::ByteArray>()
+    }
+
+    fn to_be_bytes(&self) -> Self::ByteArray {
+        let mut array = [0; 2];
+        array[0] = self.0;
+        array[1] = self.1;
+        array
+    }
+}
+
+impl ToBeBytes for I8Pair {
+    type ByteArray = [u8; 2];
+
+    fn written_len(&self) -> usize {
+        size_of::<Self::ByteArray>()
+    }
+
+    fn to_be_bytes(&self) -> Self::ByteArray {
+        let mut array = [0; 2];
+        array[0] = self.0 as u8;
+        array[1] = self.1 as u8;
+        array
+    }
+}
+
+impl ToBeBytes for U8Triplet {
+    type ByteArray = [u8; 3];
+
+    fn written_len(&self) -> usize {
+        size_of::<Self::ByteArray>()
+    }
+
+    fn to_be_bytes(&self) -> Self::ByteArray {
+        let mut array = [0; 3];
+        array[0] = self.0;
+        array[1] = self.1;
+        array[2] = self.2;
+        array
+    }
+}
+
+impl ToBeBytes for I8Triplet {
+    type ByteArray = [u8; 3];
+
+    fn written_len(&self) -> usize {
+        size_of::<Self::ByteArray>()
+    }
+
+    fn to_be_bytes(&self) -> Self::ByteArray {
+        let mut array = [0; 3];
+        array[0] = self.0 as u8;
+        array[1] = self.1 as u8;
+        array[2] = self.2 as u8;
+        array
+    }
+}
+
+pair_byte_conversions_impl!(u16, u32, u64, i16, i32, i64, f32, f64,);
+triplet_to_be_bytes_impl!(u16, u32, u64, i16, i32, i64, f32, f64,);
+
+/// Generic enumeration for additonal parameters only consisting of primitive data types.
+///
+/// All contained variants and the enum itself implement the [WritableToBeBytes] trait, which
+/// allows to easily convert them into a network-friendly format.
+#[derive(Debug, Copy, Clone, PartialEq)]
+pub enum ParamsRaw {
+    U8(U8),
+    U8Pair(U8Pair),
+    U8Triplet(U8Triplet),
+    I8(I8),
+    I8Pair(I8Pair),
+    I8Triplet(I8Triplet),
+    U16(U16),
+    U16Pair(U16Pair),
+    U16Triplet(U16Triplet),
+    I16(I16),
+    I16Pair(I16Pair),
+    I16Triplet(I16Triplet),
+    U32(U32),
+    U32Pair(U32Pair),
+    U32Triplet(U32Triplet),
+    I32(I32),
+    I32Pair(I32Pair),
+    I32Triplet(I32Triplet),
+    F32(F32),
+    F32Pair(F32Pair),
+    F32Triplet(F32Triplet),
+    U64(U64),
+    I64(I64),
+    F64(F64),
+}
+
+impl WritableToBeBytes for ParamsRaw {
+    fn raw_len(&self) -> usize {
+        match self {
+            ParamsRaw::U8(v) => v.raw_len(),
+            ParamsRaw::U8Pair(v) => v.raw_len(),
+            ParamsRaw::U8Triplet(v) => v.raw_len(),
+            ParamsRaw::I8(v) => v.raw_len(),
+            ParamsRaw::I8Pair(v) => v.raw_len(),
+            ParamsRaw::I8Triplet(v) => v.raw_len(),
+            ParamsRaw::U16(v) => v.raw_len(),
+            ParamsRaw::U16Pair(v) => v.raw_len(),
+            ParamsRaw::U16Triplet(v) => v.raw_len(),
+            ParamsRaw::I16(v) => v.raw_len(),
+            ParamsRaw::I16Pair(v) => v.raw_len(),
+            ParamsRaw::I16Triplet(v) => v.raw_len(),
+            ParamsRaw::U32(v) => v.raw_len(),
+            ParamsRaw::U32Pair(v) => v.raw_len(),
+            ParamsRaw::U32Triplet(v) => v.raw_len(),
+            ParamsRaw::I32(v) => v.raw_len(),
+            ParamsRaw::I32Pair(v) => v.raw_len(),
+            ParamsRaw::I32Triplet(v) => v.raw_len(),
+            ParamsRaw::F32(v) => v.raw_len(),
+            ParamsRaw::F32Pair(v) => v.raw_len(),
+            ParamsRaw::F32Triplet(v) => v.raw_len(),
+            ParamsRaw::U64(v) => v.raw_len(),
+            ParamsRaw::I64(v) => v.raw_len(),
+            ParamsRaw::F64(v) => v.raw_len(),
+        }
+    }
+
+    fn write_to_be_bytes(&self, buf: &mut [u8]) -> Result<usize, ByteConversionError> {
+        match self {
+            ParamsRaw::U8(v) => v.write_to_be_bytes(buf),
+            ParamsRaw::U8Pair(v) => v.write_to_be_bytes(buf),
+            ParamsRaw::U8Triplet(v) => v.write_to_be_bytes(buf),
+            ParamsRaw::I8(v) => v.write_to_be_bytes(buf),
+            ParamsRaw::I8Pair(v) => v.write_to_be_bytes(buf),
+            ParamsRaw::I8Triplet(v) => v.write_to_be_bytes(buf),
+            ParamsRaw::U16(v) => v.write_to_be_bytes(buf),
+            ParamsRaw::U16Pair(v) => v.write_to_be_bytes(buf),
+            ParamsRaw::U16Triplet(v) => v.write_to_be_bytes(buf),
+            ParamsRaw::I16(v) => v.write_to_be_bytes(buf),
+            ParamsRaw::I16Pair(v) => v.write_to_be_bytes(buf),
+            ParamsRaw::I16Triplet(v) => v.write_to_be_bytes(buf),
+            ParamsRaw::U32(v) => v.write_to_be_bytes(buf),
+            ParamsRaw::U32Pair(v) => v.write_to_be_bytes(buf),
+            ParamsRaw::U32Triplet(v) => v.write_to_be_bytes(buf),
+            ParamsRaw::I32(v) => v.write_to_be_bytes(buf),
+            ParamsRaw::I32Pair(v) => v.write_to_be_bytes(buf),
+            ParamsRaw::I32Triplet(v) => v.write_to_be_bytes(buf),
+            ParamsRaw::F32(v) => v.write_to_be_bytes(buf),
+            ParamsRaw::F32Pair(v) => v.write_to_be_bytes(buf),
+            ParamsRaw::F32Triplet(v) => v.write_to_be_bytes(buf),
+            ParamsRaw::U64(v) => v.write_to_be_bytes(buf),
+            ParamsRaw::I64(v) => v.write_to_be_bytes(buf),
+            ParamsRaw::F64(v) => v.write_to_be_bytes(buf),
+        }
+    }
+}
+
+macro_rules! params_raw_from_newtype {
+    ($($newtype: ident,)+) => {
+        $(
+            impl From<$newtype> for ParamsRaw {
+                fn from(v: $newtype) -> Self {
+                    Self::$newtype(v)
+                }
+            }
+        )+
+    }
+}
+
+params_raw_from_newtype!(
+    U8, U8Pair, U8Triplet, U16, U16Pair, U16Triplet, U32, U32Pair, U32Triplet, I8, I8Pair,
+    I8Triplet, I16, I16Pair, I16Triplet, I32, I32Pair, I32Triplet, F32, F32Pair, F32Triplet, U64,
+    I64, F64,
+);
+
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+pub enum EcssEnumParams {
+    U8(EcssEnumU8),
+    U16(EcssEnumU16),
+    U32(EcssEnumU32),
+    U64(EcssEnumU64),
+}
+
+macro_rules! writable_as_be_bytes_ecss_enum_impl {
+    ($EnumIdent: ident) => {
+        impl WritableToBeBytes for $EnumIdent {
+            fn raw_len(&self) -> usize {
+                self.size()
+            }
+
+            fn write_to_be_bytes(&self, buf: &mut [u8]) -> Result<usize, ByteConversionError> {
+                <Self as UnsignedEnum>::write_to_be_bytes(self, buf).map(|_| self.raw_len())
+            }
+        }
+    };
+}
+
+writable_as_be_bytes_ecss_enum_impl!(EcssEnumU8);
+writable_as_be_bytes_ecss_enum_impl!(EcssEnumU16);
+writable_as_be_bytes_ecss_enum_impl!(EcssEnumU32);
+writable_as_be_bytes_ecss_enum_impl!(EcssEnumU64);
+
+impl WritableToBeBytes for EcssEnumParams {
+    fn raw_len(&self) -> usize {
+        match self {
+            EcssEnumParams::U8(e) => e.raw_len(),
+            EcssEnumParams::U16(e) => e.raw_len(),
+            EcssEnumParams::U32(e) => e.raw_len(),
+            EcssEnumParams::U64(e) => e.raw_len(),
+        }
+    }
+
+    fn write_to_be_bytes(&self, buf: &mut [u8]) -> Result<usize, ByteConversionError> {
+        match self {
+            EcssEnumParams::U8(e) => WritableToBeBytes::write_to_be_bytes(e, buf),
+            EcssEnumParams::U16(e) => WritableToBeBytes::write_to_be_bytes(e, buf),
+            EcssEnumParams::U32(e) => WritableToBeBytes::write_to_be_bytes(e, buf),
+            EcssEnumParams::U64(e) => WritableToBeBytes::write_to_be_bytes(e, buf),
+        }
+    }
+}
+
+/// Generic enumeration for parameters which do not rely on heap allocations.
+#[derive(Debug, Copy, Clone, PartialEq)]
+pub enum ParamsHeapless {
+    Raw(ParamsRaw),
+    EcssEnum(EcssEnumParams),
+}
+
+macro_rules! from_conversions_for_raw {
+    ($(($raw_ty: ty, $TargetPath: path),)+) => {
+        $(
+            impl From<$raw_ty> for ParamsRaw {
+                fn from(val: $raw_ty) -> Self {
+                    $TargetPath(val.into())
+                }
+            }
+
+            impl From<$raw_ty> for ParamsHeapless {
+                fn from(val: $raw_ty) -> Self {
+                    ParamsHeapless::Raw(val.into())
+                }
+            }
+        )+
+    };
+}
+
+from_conversions_for_raw!(
+    (u8, Self::U8),
+    ((u8, u8), Self::U8Pair),
+    ((u8, u8, u8), Self::U8Triplet),
+    (i8, Self::I8),
+    ((i8, i8), Self::I8Pair),
+    ((i8, i8, i8), Self::I8Triplet),
+    (u16, Self::U16),
+    ((u16, u16), Self::U16Pair),
+    ((u16, u16, u16), Self::U16Triplet),
+    (i16, Self::I16),
+    ((i16, i16), Self::I16Pair),
+    ((i16, i16, i16), Self::I16Triplet),
+    (u32, Self::U32),
+    ((u32, u32), Self::U32Pair),
+    ((u32, u32, u32), Self::U32Triplet),
+    (i32, Self::I32),
+    ((i32, i32), Self::I32Pair),
+    ((i32, i32, i32), Self::I32Triplet),
+    (f32, Self::F32),
+    ((f32, f32), Self::F32Pair),
+    ((f32, f32, f32), Self::F32Triplet),
+    (u64, Self::U64),
+    (f64, Self::F64),
+);
+
+#[cfg(feature = "alloc")]
+mod alloc_mod {
+    use super::*;
+    /// Generic enumeration for additional parameters, including parameters which rely on heap
+    /// allocations.
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "alloc")))]
+    #[derive(Debug, Clone)]
+    pub enum Params {
+        Heapless(ParamsHeapless),
+        Store(StoreAddr),
+        Vec(Vec<u8>),
+        String(String),
+    }
+
+    impl From<StoreAddr> for Params {
+        fn from(x: StoreAddr) -> Self {
+            Self::Store(x)
+        }
+    }
+
+    impl From<ParamsHeapless> for Params {
+        fn from(x: ParamsHeapless) -> Self {
+            Self::Heapless(x)
+        }
+    }
+
+    impl From<Vec<u8>> for Params {
+        fn from(val: Vec<u8>) -> Self {
+            Self::Vec(val)
+        }
+    }
+
+    /// Converts a byte slice into the [Params::Vec] variant
+    impl From<&[u8]> for Params {
+        fn from(val: &[u8]) -> Self {
+            Self::Vec(val.to_vec())
+        }
+    }
+
+    impl From<String> for Params {
+        fn from(val: String) -> Self {
+            Self::String(val)
+        }
+    }
+
+    /// Converts a string slice into the [Params::String] variant
+    impl From<&str> for Params {
+        fn from(val: &str) -> Self {
+            Self::String(val.to_string())
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_basic_u32_pair() {
+        let u32_pair = U32Pair(4, 8);
+        assert_eq!(u32_pair.0, 4);
+        assert_eq!(u32_pair.1, 8);
+        let raw = u32_pair.to_be_bytes();
+        let mut u32_conv_back = u32::from_be_bytes(raw[0..4].try_into().unwrap());
+        assert_eq!(u32_conv_back, 4);
+        u32_conv_back = u32::from_be_bytes(raw[4..8].try_into().unwrap());
+        assert_eq!(u32_conv_back, 8);
+    }
+
+    #[test]
+    fn basic_signed_test_pair() {
+        let i8_pair = I8Pair(-3, -16);
+        assert_eq!(i8_pair.0, -3);
+        assert_eq!(i8_pair.1, -16);
+        let raw = i8_pair.to_be_bytes();
+        let mut i8_conv_back = i8::from_be_bytes(raw[0..1].try_into().unwrap());
+        assert_eq!(i8_conv_back, -3);
+        i8_conv_back = i8::from_be_bytes(raw[1..2].try_into().unwrap());
+        assert_eq!(i8_conv_back, -16);
+    }
+
+    #[test]
+    fn basic_signed_test_triplet() {
+        let i8_triplet = I8Triplet(-3, -16, -126);
+        assert_eq!(i8_triplet.0, -3);
+        assert_eq!(i8_triplet.1, -16);
+        assert_eq!(i8_triplet.2, -126);
+        let raw = i8_triplet.to_be_bytes();
+        let mut i8_conv_back = i8::from_be_bytes(raw[0..1].try_into().unwrap());
+        assert_eq!(i8_conv_back, -3);
+        i8_conv_back = i8::from_be_bytes(raw[1..2].try_into().unwrap());
+        assert_eq!(i8_conv_back, -16);
+        i8_conv_back = i8::from_be_bytes(raw[2..3].try_into().unwrap());
+        assert_eq!(i8_conv_back, -126);
+    }
+
+    #[test]
+    fn conversion_test_string() {
+        let param: Params = "Test String".into();
+        if let Params::String(str) = param {
+            assert_eq!(str, String::from("Test String"));
+        } else {
+            panic!("Params type is not String")
+        }
+    }
+
+    #[test]
+    fn conversion_from_slice() {
+        let test_slice: [u8; 5] = [0; 5];
+        let vec_param: Params = test_slice.as_slice().into();
+        if let Params::Vec(vec) = vec_param {
+            assert_eq!(vec, test_slice.to_vec());
+        } else {
+            panic!("Params type is not a vector")
+        }
+    }
+}
diff --git a/fsrc-core/src/pool.rs b/satrs-core/src/pool.rs
similarity index 85%
rename from fsrc-core/src/pool.rs
rename to satrs-core/src/pool.rs
index 8411a35..d7253d5 100644
--- a/fsrc-core/src/pool.rs
+++ b/satrs-core/src/pool.rs
@@ -13,7 +13,7 @@
 //! # Example
 //!
 //! ```
-//! use fsrc_core::pool::{LocalPool, PoolCfg, PoolProvider};
+//! use satrs_core::pool::{LocalPool, PoolCfg, PoolProvider};
 //!
 //! // 4 buckets of 4 bytes, 2 of 8 bytes and 1 of 16 bytes
 //! let pool_cfg = PoolCfg::new(vec![(4, 4), (2, 8), (1, 16)]);
@@ -77,10 +77,15 @@ use alloc::format;
 use alloc::string::String;
 use alloc::vec;
 use alloc::vec::Vec;
+use core::fmt::{Display, Formatter};
 use delegate::delegate;
+#[cfg(feature = "serde")]
+use serde::{Deserialize, Serialize};
 #[cfg(feature = "std")]
 use std::boxed::Box;
 #[cfg(feature = "std")]
+use std::error::Error;
+#[cfg(feature = "std")]
 use std::sync::{Arc, RwLock};
 
 type NumBlocks = u16;
@@ -127,26 +132,55 @@ pub struct LocalPool {
 
 /// Simple address type used for transactions with the local pool.
 #[derive(Debug, Copy, Clone, PartialEq, Eq)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 pub struct StoreAddr {
-    pool_idx: u16,
-    packet_idx: NumBlocks,
+    pub(crate) pool_idx: u16,
+    pub(crate) packet_idx: NumBlocks,
+}
+
+impl Display for StoreAddr {
+    fn fmt(&self, f: &mut Formatter<'_>) -> core::fmt::Result {
+        write!(
+            f,
+            "StoreAddr(pool index: {}, packet index: {})",
+            self.pool_idx, self.packet_idx
+        )
+    }
 }
 
 impl StoreAddr {
     pub const INVALID_ADDR: u32 = 0xFFFFFFFF;
 
     pub fn raw(&self) -> u32 {
-        ((self.pool_idx as u32) << 16) as u32 | self.packet_idx as u32
+        ((self.pool_idx as u32) << 16) | self.packet_idx as u32
     }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 pub enum StoreIdError {
     InvalidSubpool(u16),
     InvalidPacketIdx(u16),
 }
 
+impl Display for StoreIdError {
+    fn fmt(&self, f: &mut Formatter<'_>) -> core::fmt::Result {
+        match self {
+            StoreIdError::InvalidSubpool(pool) => {
+                write!(f, "invalid subpool, index: {pool}")
+            }
+            StoreIdError::InvalidPacketIdx(packet_idx) => {
+                write!(f, "invalid packet index: {packet_idx}")
+            }
+        }
+    }
+}
+
+#[cfg(feature = "std")]
+impl Error for StoreIdError {}
+
 #[derive(Debug, Clone, PartialEq, Eq)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 pub enum StoreError {
     /// Requested data block is too large
     DataTooLarge(usize),
@@ -160,6 +194,38 @@ pub enum StoreError {
     InternalError(String),
 }
 
+impl Display for StoreError {
+    fn fmt(&self, f: &mut Formatter<'_>) -> core::fmt::Result {
+        match self {
+            StoreError::DataTooLarge(size) => {
+                write!(f, "data to store with size {size} is too large")
+            }
+            StoreError::StoreFull(u16) => {
+                write!(f, "store is too full. index for full subpool: {u16}")
+            }
+            StoreError::InvalidStoreId(id_e, addr) => {
+                write!(f, "invalid store ID: {id_e}, address: {addr:?}")
+            }
+            StoreError::DataDoesNotExist(addr) => {
+                write!(f, "no data exists at address {addr:?}")
+            }
+            StoreError::InternalError(e) => {
+                write!(f, "internal error: {e}")
+            }
+        }
+    }
+}
+
+#[cfg(feature = "std")]
+impl Error for StoreError {
+    fn source(&self) -> Option<&(dyn Error + 'static)> {
+        if let StoreError::InvalidStoreId(e, _) = self {
+            return Some(e);
+        }
+        None
+    }
+}
+
 pub trait PoolProvider {
     /// Add new data to the pool. The provider should attempt to reserve a memory block with the
     /// appropriate size and then copy the given data to the block. Yields a [StoreAddr] which can
@@ -201,6 +267,14 @@ pub trait PoolProvider {
     /// Delete data inside the pool given a [StoreAddr]
     fn delete(&mut self, addr: StoreAddr) -> Result<(), StoreError>;
     fn has_element_at(&self, addr: &StoreAddr) -> Result<bool, StoreError>;
+
+    /// Retrieve the length of the data at the given store address.
+    fn len_of_data(&self, addr: &StoreAddr) -> Result<usize, StoreError> {
+        if !self.has_element_at(addr)? {
+            return Err(StoreError::DataDoesNotExist(*addr));
+        }
+        Ok(self.read(addr)?.len())
+    }
 }
 
 impl LocalPool {
@@ -239,7 +313,7 @@ impl LocalPool {
 
     fn validate_addr(&self, addr: &StoreAddr) -> Result<(), StoreError> {
         let pool_idx = addr.pool_idx as usize;
-        if pool_idx as usize >= self.pool_cfg.cfg.len() {
+        if pool_idx >= self.pool_cfg.cfg.len() {
             return Err(StoreError::InvalidStoreId(
                 StoreIdError::InvalidSubpool(addr.pool_idx),
                 Some(*addr),
@@ -279,14 +353,12 @@ impl LocalPool {
     fn write(&mut self, addr: &StoreAddr, data: &[u8]) -> Result<(), StoreError> {
         let packet_pos = self.raw_pos(addr).ok_or_else(|| {
             StoreError::InternalError(format!(
-                "write: Error in raw_pos func with address {:?}",
-                addr
+                "write: Error in raw_pos func with address {addr:?}"
             ))
         })?;
         let subpool = self.pool.get_mut(addr.pool_idx as usize).ok_or_else(|| {
             StoreError::InternalError(format!(
-                "write: Error retrieving pool slice with address {:?}",
-                addr
+                "write: Error retrieving pool slice with address {addr:?}"
             ))
         })?;
         let pool_slice = &mut subpool[packet_pos..packet_pos + data.len()];
@@ -340,7 +412,8 @@ impl PoolProvider for LocalPool {
     fn modify(&mut self, addr: &StoreAddr) -> Result<&mut [u8], StoreError> {
         let curr_size = self.addr_check(addr)?;
         let raw_pos = self.raw_pos(addr).unwrap();
-        let block = &mut self.pool.get_mut(addr.pool_idx as usize).unwrap()[raw_pos..curr_size];
+        let block =
+            &mut self.pool.get_mut(addr.pool_idx as usize).unwrap()[raw_pos..raw_pos + curr_size];
         Ok(block)
     }
 
@@ -405,6 +478,8 @@ impl<'a> PoolGuard<'a> {
         self.pool.read(&self.addr)
     }
 
+    /// Releasing the pool guard will disable the automatic deletion of the data when the guard
+    /// is dropped.
     pub fn release(&mut self) {
         self.no_deletion = true;
     }
@@ -438,6 +513,8 @@ impl<'a> PoolRwGuard<'a> {
     delegate!(
         to self.guard {
             pub fn read(&self) -> Result<&[u8], StoreError>;
+            /// Releasing the pool guard will disable the automatic deletion of the data when the guard
+            /// is dropped.
             pub fn release(&mut self);
         }
     );
@@ -713,4 +790,25 @@ mod tests {
         drop(rw_guard);
         assert!(!local_pool.has_element_at(&addr).expect("Invalid address"));
     }
+
+    #[test]
+    fn modify_pool_index_above_0() {
+        let mut local_pool = basic_small_pool();
+        let test_buf_0: [u8; 4] = [1; 4];
+        let test_buf_1: [u8; 4] = [2; 4];
+        let test_buf_2: [u8; 4] = [3; 4];
+        let test_buf_3: [u8; 4] = [4; 4];
+        let addr0 = local_pool.add(&test_buf_0).expect("Adding data failed");
+        let addr1 = local_pool.add(&test_buf_1).expect("Adding data failed");
+        let addr2 = local_pool.add(&test_buf_2).expect("Adding data failed");
+        let addr3 = local_pool.add(&test_buf_3).expect("Adding data failed");
+        let tm0_raw = local_pool.modify(&addr0).expect("Modifying data failed");
+        assert_eq!(tm0_raw, test_buf_0);
+        let tm1_raw = local_pool.modify(&addr1).expect("Modifying data failed");
+        assert_eq!(tm1_raw, test_buf_1);
+        let tm2_raw = local_pool.modify(&addr2).expect("Modifying data failed");
+        assert_eq!(tm2_raw, test_buf_2);
+        let tm3_raw = local_pool.modify(&addr3).expect("Modifying data failed");
+        assert_eq!(tm3_raw, test_buf_3);
+    }
 }
diff --git a/satrs-core/src/power.rs b/satrs-core/src/power.rs
new file mode 100644
index 0000000..1675c01
--- /dev/null
+++ b/satrs-core/src/power.rs
@@ -0,0 +1,102 @@
+#[cfg(feature = "serde")]
+use serde::{Deserialize, Serialize};
+
+/// Generic trait for a device capable of switching itself on or off.
+pub trait PowerSwitch {
+    type Error;
+
+    fn switch_on(&mut self) -> Result<(), Self::Error>;
+    fn switch_off(&mut self) -> Result<(), Self::Error>;
+
+    fn is_switch_on(&self) -> bool {
+        self.switch_state() == SwitchState::On
+    }
+
+    fn switch_state(&self) -> SwitchState;
+}
+
+#[derive(Debug, Eq, PartialEq, Copy, Clone)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+pub enum SwitchState {
+    Off = 0,
+    On = 1,
+    Unknown = 2,
+    Faulty = 3,
+}
+
+pub type SwitchId = u16;
+
+/// Generic trait for a device capable of turning on and off switches.
+pub trait PowerSwitcherCommandSender {
+    type Error;
+
+    fn send_switch_on_cmd(&mut self, switch_id: SwitchId) -> Result<(), Self::Error>;
+    fn send_switch_off_cmd(&mut self, switch_id: SwitchId) -> Result<(), Self::Error>;
+}
+
+pub trait PowerSwitchInfo {
+    type Error;
+
+    /// Retrieve the switch state
+    fn get_switch_state(&mut self, switch_id: SwitchId) -> Result<SwitchState, Self::Error>;
+
+    fn get_is_switch_on(&mut self, switch_id: SwitchId) -> Result<bool, Self::Error> {
+        Ok(self.get_switch_state(switch_id)? == SwitchState::On)
+    }
+
+    /// The maximum delay it will take to change a switch.
+    ///
+    /// This may take into account the time to send a command, wait for it to be executed, and
+    /// see the switch changed.
+    fn switch_delay_ms(&self) -> u32;
+}
+
+#[cfg(test)]
+mod tests {
+    #![allow(dead_code)]
+    use super::*;
+    use std::boxed::Box;
+
+    struct Pcdu {
+        switch_rx: std::sync::mpsc::Receiver<(SwitchId, u16)>,
+    }
+
+    #[derive(Eq, PartialEq)]
+    enum DeviceState {
+        OFF,
+        SwitchingPower,
+        ON,
+        SETUP,
+        IDLE,
+    }
+    struct MyComplexDevice {
+        power_switcher: Box<dyn PowerSwitcherCommandSender<Error = ()>>,
+        power_info: Box<dyn PowerSwitchInfo<Error = ()>>,
+        switch_id: SwitchId,
+        some_state: u16,
+        dev_state: DeviceState,
+        mode: u32,
+        submode: u16,
+    }
+
+    impl MyComplexDevice {
+        pub fn periodic_op(&mut self) {
+            // .. mode command coming in
+            let mode = 1;
+            if mode == 1 {
+                if self.dev_state == DeviceState::OFF {
+                    self.power_switcher
+                        .send_switch_on_cmd(self.switch_id)
+                        .expect("sending siwthc cmd failed");
+                    self.dev_state = DeviceState::SwitchingPower;
+                }
+                if self.dev_state == DeviceState::SwitchingPower {
+                    if self.power_info.get_is_switch_on(0).unwrap() {
+                        self.dev_state = DeviceState::ON;
+                        self.mode = 1;
+                    }
+                }
+            }
+        }
+    }
+}
diff --git a/satrs-core/src/pus/event.rs b/satrs-core/src/pus/event.rs
new file mode 100644
index 0000000..c1dfc5d
--- /dev/null
+++ b/satrs-core/src/pus/event.rs
@@ -0,0 +1,449 @@
+use crate::pus::{source_buffer_large_enough, EcssTmtcError};
+use spacepackets::ecss::{EcssEnumeration, PusError};
+use spacepackets::tm::PusTm;
+use spacepackets::tm::PusTmSecondaryHeader;
+use spacepackets::{SpHeader, MAX_APID};
+
+use crate::pus::EcssTmSenderCore;
+#[cfg(feature = "alloc")]
+pub use alloc_mod::EventReporter;
+pub use spacepackets::ecss::event::*;
+
+pub struct EventReporterBase {
+    msg_count: u16,
+    apid: u16,
+    pub dest_id: u16,
+}
+
+impl EventReporterBase {
+    pub fn new(apid: u16) -> Option<Self> {
+        if apid > MAX_APID {
+            return None;
+        }
+        Some(Self {
+            msg_count: 0,
+            dest_id: 0,
+            apid,
+        })
+    }
+
+    pub fn event_info(
+        &mut self,
+        buf: &mut [u8],
+        sender: &mut (impl EcssTmSenderCore + ?Sized),
+        time_stamp: &[u8],
+        event_id: impl EcssEnumeration,
+        aux_data: Option<&[u8]>,
+    ) -> Result<(), EcssTmtcError> {
+        self.generate_and_send_generic_tm(
+            buf,
+            Subservice::TmInfoReport,
+            sender,
+            time_stamp,
+            event_id,
+            aux_data,
+        )
+    }
+
+    pub fn event_low_severity(
+        &mut self,
+        buf: &mut [u8],
+        sender: &mut (impl EcssTmSenderCore + ?Sized),
+        time_stamp: &[u8],
+        event_id: impl EcssEnumeration,
+        aux_data: Option<&[u8]>,
+    ) -> Result<(), EcssTmtcError> {
+        self.generate_and_send_generic_tm(
+            buf,
+            Subservice::TmLowSeverityReport,
+            sender,
+            time_stamp,
+            event_id,
+            aux_data,
+        )
+    }
+
+    pub fn event_medium_severity(
+        &mut self,
+        buf: &mut [u8],
+        sender: &mut (impl EcssTmSenderCore + ?Sized),
+        time_stamp: &[u8],
+        event_id: impl EcssEnumeration,
+        aux_data: Option<&[u8]>,
+    ) -> Result<(), EcssTmtcError> {
+        self.generate_and_send_generic_tm(
+            buf,
+            Subservice::TmMediumSeverityReport,
+            sender,
+            time_stamp,
+            event_id,
+            aux_data,
+        )
+    }
+
+    pub fn event_high_severity(
+        &mut self,
+        buf: &mut [u8],
+        sender: &mut (impl EcssTmSenderCore + ?Sized),
+        time_stamp: &[u8],
+        event_id: impl EcssEnumeration,
+        aux_data: Option<&[u8]>,
+    ) -> Result<(), EcssTmtcError> {
+        self.generate_and_send_generic_tm(
+            buf,
+            Subservice::TmHighSeverityReport,
+            sender,
+            time_stamp,
+            event_id,
+            aux_data,
+        )
+    }
+
+    fn generate_and_send_generic_tm(
+        &mut self,
+        buf: &mut [u8],
+        subservice: Subservice,
+        sender: &mut (impl EcssTmSenderCore + ?Sized),
+        time_stamp: &[u8],
+        event_id: impl EcssEnumeration,
+        aux_data: Option<&[u8]>,
+    ) -> Result<(), EcssTmtcError> {
+        let tm = self.generate_generic_event_tm(buf, subservice, time_stamp, event_id, aux_data)?;
+        sender.send_tm(tm.into())?;
+        self.msg_count += 1;
+        Ok(())
+    }
+
+    fn generate_generic_event_tm<'a>(
+        &'a self,
+        buf: &'a mut [u8],
+        subservice: Subservice,
+        time_stamp: &'a [u8],
+        event_id: impl EcssEnumeration,
+        aux_data: Option<&[u8]>,
+    ) -> Result<PusTm, EcssTmtcError> {
+        let mut src_data_len = event_id.size();
+        if let Some(aux_data) = aux_data {
+            src_data_len += aux_data.len();
+        }
+        source_buffer_large_enough(buf.len(), src_data_len)?;
+        let mut sp_header = SpHeader::tm_unseg(self.apid, 0, 0).unwrap();
+        let sec_header = PusTmSecondaryHeader::new(
+            5,
+            subservice.into(),
+            self.msg_count,
+            self.dest_id,
+            Some(time_stamp),
+        );
+        let mut current_idx = 0;
+        event_id
+            .write_to_be_bytes(&mut buf[0..event_id.size()])
+            .map_err(PusError::ByteConversion)?;
+        current_idx += event_id.size();
+        if let Some(aux_data) = aux_data {
+            buf[current_idx..current_idx + aux_data.len()].copy_from_slice(aux_data);
+            current_idx += aux_data.len();
+        }
+        Ok(PusTm::new(
+            &mut sp_header,
+            sec_header,
+            Some(&buf[0..current_idx]),
+            true,
+        ))
+    }
+}
+
+#[cfg(feature = "alloc")]
+mod alloc_mod {
+    use super::*;
+    use alloc::vec;
+    use alloc::vec::Vec;
+
+    pub struct EventReporter {
+        source_data_buf: Vec<u8>,
+        pub reporter: EventReporterBase,
+    }
+
+    impl EventReporter {
+        pub fn new(apid: u16, max_event_id_and_aux_data_size: usize) -> Option<Self> {
+            let reporter = EventReporterBase::new(apid)?;
+            Some(Self {
+                source_data_buf: vec![0; max_event_id_and_aux_data_size],
+                reporter,
+            })
+        }
+        pub fn event_info(
+            &mut self,
+            sender: &mut (impl EcssTmSenderCore + ?Sized),
+            time_stamp: &[u8],
+            event_id: impl EcssEnumeration,
+            aux_data: Option<&[u8]>,
+        ) -> Result<(), EcssTmtcError> {
+            self.reporter.event_info(
+                self.source_data_buf.as_mut_slice(),
+                sender,
+                time_stamp,
+                event_id,
+                aux_data,
+            )
+        }
+
+        pub fn event_low_severity(
+            &mut self,
+            sender: &mut (impl EcssTmSenderCore + ?Sized),
+            time_stamp: &[u8],
+            event_id: impl EcssEnumeration,
+            aux_data: Option<&[u8]>,
+        ) -> Result<(), EcssTmtcError> {
+            self.reporter.event_low_severity(
+                self.source_data_buf.as_mut_slice(),
+                sender,
+                time_stamp,
+                event_id,
+                aux_data,
+            )
+        }
+
+        pub fn event_medium_severity(
+            &mut self,
+            sender: &mut (impl EcssTmSenderCore + ?Sized),
+            time_stamp: &[u8],
+            event_id: impl EcssEnumeration,
+            aux_data: Option<&[u8]>,
+        ) -> Result<(), EcssTmtcError> {
+            self.reporter.event_medium_severity(
+                self.source_data_buf.as_mut_slice(),
+                sender,
+                time_stamp,
+                event_id,
+                aux_data,
+            )
+        }
+
+        pub fn event_high_severity(
+            &mut self,
+            sender: &mut (impl EcssTmSenderCore + ?Sized),
+            time_stamp: &[u8],
+            event_id: impl EcssEnumeration,
+            aux_data: Option<&[u8]>,
+        ) -> Result<(), EcssTmtcError> {
+            self.reporter.event_high_severity(
+                self.source_data_buf.as_mut_slice(),
+                sender,
+                time_stamp,
+                event_id,
+                aux_data,
+            )
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::events::{EventU32, Severity};
+    use crate::pus::tests::CommonTmInfo;
+    use crate::pus::{EcssChannel, PusTmWrapper};
+    use crate::ChannelId;
+    use spacepackets::ByteConversionError;
+    use std::cell::RefCell;
+    use std::collections::VecDeque;
+    use std::vec::Vec;
+
+    const EXAMPLE_APID: u16 = 0xee;
+    const EXAMPLE_GROUP_ID: u16 = 2;
+    const EXAMPLE_EVENT_ID_0: u16 = 1;
+    #[allow(dead_code)]
+    const EXAMPLE_EVENT_ID_1: u16 = 2;
+
+    #[derive(Debug, Eq, PartialEq, Clone)]
+    struct TmInfo {
+        pub common: CommonTmInfo,
+        pub event: EventU32,
+        pub aux_data: Vec<u8>,
+    }
+
+    #[derive(Default, Clone)]
+    struct TestSender {
+        pub service_queue: RefCell<VecDeque<TmInfo>>,
+    }
+
+    impl EcssChannel for TestSender {
+        fn id(&self) -> ChannelId {
+            0
+        }
+    }
+
+    impl EcssTmSenderCore for TestSender {
+        fn send_tm(&self, tm: PusTmWrapper) -> Result<(), EcssTmtcError> {
+            match tm {
+                PusTmWrapper::InStore(_) => {
+                    panic!("TestSender: unexpected call with address");
+                }
+                PusTmWrapper::Direct(tm) => {
+                    assert!(tm.source_data().is_some());
+                    let src_data = tm.source_data().unwrap();
+                    assert!(src_data.len() >= 4);
+                    let event =
+                        EventU32::from(u32::from_be_bytes(src_data[0..4].try_into().unwrap()));
+                    let mut aux_data = Vec::new();
+                    if src_data.len() > 4 {
+                        aux_data.extend_from_slice(&src_data[4..]);
+                    }
+                    self.service_queue.borrow_mut().push_back(TmInfo {
+                        common: CommonTmInfo::new_from_tm(&tm),
+                        event,
+                        aux_data,
+                    });
+                    Ok(())
+                }
+            }
+        }
+    }
+
+    fn severity_to_subservice(severity: Severity) -> Subservice {
+        match severity {
+            Severity::INFO => Subservice::TmInfoReport,
+            Severity::LOW => Subservice::TmLowSeverityReport,
+            Severity::MEDIUM => Subservice::TmMediumSeverityReport,
+            Severity::HIGH => Subservice::TmHighSeverityReport,
+        }
+    }
+
+    fn report_basic_event(
+        reporter: &mut EventReporter,
+        sender: &mut TestSender,
+        time_stamp: &[u8],
+        event: EventU32,
+        severity: Severity,
+        aux_data: Option<&[u8]>,
+    ) {
+        match severity {
+            Severity::INFO => {
+                reporter
+                    .event_info(sender, time_stamp, event, aux_data)
+                    .expect("Error reporting info event");
+            }
+            Severity::LOW => {
+                reporter
+                    .event_low_severity(sender, time_stamp, event, aux_data)
+                    .expect("Error reporting low event");
+            }
+            Severity::MEDIUM => {
+                reporter
+                    .event_medium_severity(sender, time_stamp, event, aux_data)
+                    .expect("Error reporting medium event");
+            }
+            Severity::HIGH => {
+                reporter
+                    .event_high_severity(sender, time_stamp, event, aux_data)
+                    .expect("Error reporting high event");
+            }
+        }
+    }
+
+    fn basic_event_test(
+        max_event_aux_data_buf: usize,
+        severity: Severity,
+        error_data: Option<&[u8]>,
+    ) {
+        let mut sender = TestSender::default();
+        let reporter = EventReporter::new(EXAMPLE_APID, max_event_aux_data_buf);
+        assert!(reporter.is_some());
+        let mut reporter = reporter.unwrap();
+        let time_stamp_empty: [u8; 7] = [0; 7];
+        let mut error_copy = Vec::new();
+        if let Some(err_data) = error_data {
+            error_copy.extend_from_slice(err_data);
+        }
+        let event = EventU32::new(severity, EXAMPLE_GROUP_ID, EXAMPLE_EVENT_ID_0)
+            .expect("Error creating example event");
+        report_basic_event(
+            &mut reporter,
+            &mut sender,
+            &time_stamp_empty,
+            event,
+            severity,
+            error_data,
+        );
+        let mut service_queue = sender.service_queue.borrow_mut();
+        assert_eq!(service_queue.len(), 1);
+        let tm_info = service_queue.pop_front().unwrap();
+        assert_eq!(
+            tm_info.common.subservice,
+            severity_to_subservice(severity) as u8
+        );
+        assert_eq!(tm_info.common.dest_id, 0);
+        assert_eq!(tm_info.common.time_stamp, time_stamp_empty);
+        assert_eq!(tm_info.common.msg_counter, 0);
+        assert_eq!(tm_info.common.apid, EXAMPLE_APID);
+        assert_eq!(tm_info.event, event);
+        assert_eq!(tm_info.aux_data, error_copy);
+    }
+
+    #[test]
+    fn basic_info_event_generation() {
+        basic_event_test(4, Severity::INFO, None);
+    }
+
+    #[test]
+    fn basic_low_severity_event() {
+        basic_event_test(4, Severity::LOW, None);
+    }
+
+    #[test]
+    fn basic_medium_severity_event() {
+        basic_event_test(4, Severity::MEDIUM, None);
+    }
+
+    #[test]
+    fn basic_high_severity_event() {
+        basic_event_test(4, Severity::HIGH, None);
+    }
+
+    #[test]
+    fn event_with_info_string() {
+        let info_string = "Test Information";
+        basic_event_test(32, Severity::INFO, Some(info_string.as_bytes()));
+    }
+
+    #[test]
+    fn low_severity_with_raw_err_data() {
+        let raw_err_param: i32 = -1;
+        let raw_err = raw_err_param.to_be_bytes();
+        basic_event_test(8, Severity::LOW, Some(&raw_err))
+    }
+
+    fn check_buf_too_small(
+        reporter: &mut EventReporter,
+        sender: &mut TestSender,
+        expected_found_len: usize,
+    ) {
+        let time_stamp_empty: [u8; 7] = [0; 7];
+        let event = EventU32::new(Severity::INFO, EXAMPLE_GROUP_ID, EXAMPLE_EVENT_ID_0)
+            .expect("Error creating example event");
+        let err = reporter.event_info(sender, &time_stamp_empty, event, None);
+        assert!(err.is_err());
+        let err = err.unwrap_err();
+        if let EcssTmtcError::Pus(PusError::ByteConversion(ByteConversionError::ToSliceTooSmall(
+            missmatch,
+        ))) = err
+        {
+            assert_eq!(missmatch.expected, 4);
+            assert_eq!(missmatch.found, expected_found_len);
+        } else {
+            panic!("Unexpected error {:?}", err);
+        }
+    }
+
+    #[test]
+    fn insufficient_buffer() {
+        let mut sender = TestSender::default();
+        for i in 0..3 {
+            let reporter = EventReporter::new(EXAMPLE_APID, i);
+            assert!(reporter.is_some());
+            let mut reporter = reporter.unwrap();
+            check_buf_too_small(&mut reporter, &mut sender, i);
+        }
+    }
+}
diff --git a/satrs-core/src/pus/event_man.rs b/satrs-core/src/pus/event_man.rs
new file mode 100644
index 0000000..132e24c
--- /dev/null
+++ b/satrs-core/src/pus/event_man.rs
@@ -0,0 +1,309 @@
+use crate::events::{EventU32, GenericEvent, Severity};
+#[cfg(feature = "alloc")]
+use crate::events::{EventU32TypedSev, HasSeverity};
+#[cfg(feature = "alloc")]
+use alloc::boxed::Box;
+#[cfg(feature = "alloc")]
+use core::hash::Hash;
+#[cfg(feature = "alloc")]
+use hashbrown::HashSet;
+
+#[cfg(feature = "alloc")]
+pub use crate::pus::event::EventReporter;
+use crate::pus::verification::TcStateToken;
+#[cfg(feature = "alloc")]
+use crate::pus::EcssTmSenderCore;
+use crate::pus::EcssTmtcError;
+#[cfg(feature = "alloc")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "alloc")))]
+pub use alloc_mod::*;
+#[cfg(feature = "heapless")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "heapless")))]
+pub use heapless_mod::*;
+
+/// This trait allows the PUS event manager implementation to stay generic over various types
+/// of backend containers.
+///
+/// These backend containers keep track on whether a particular event is enabled or disabled for
+/// reporting and also expose a simple API to enable or disable the event reporting.
+///
+/// For example, a straight forward implementation for host systems could use a
+/// [hash set](https://docs.rs/hashbrown/latest/hashbrown/struct.HashSet.html)
+/// structure to track disabled events. A more primitive and embedded friendly
+/// solution could track this information in a static or pre-allocated list which contains
+/// the disabled events.
+pub trait PusEventMgmtBackendProvider<Provider: GenericEvent> {
+    type Error;
+
+    fn event_enabled(&self, event: &Provider) -> bool;
+    fn enable_event_reporting(&mut self, event: &Provider) -> Result<bool, Self::Error>;
+    fn disable_event_reporting(&mut self, event: &Provider) -> Result<bool, Self::Error>;
+}
+
+#[cfg(feature = "heapless")]
+pub mod heapless_mod {
+    use super::*;
+    use crate::events::{GenericEvent, LargestEventRaw};
+    use std::marker::PhantomData;
+
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "heapless")))]
+    // TODO: After a new version of heapless is released which uses hash32 version 0.3, try using
+    //       regular Event type again.
+    #[derive(Default)]
+    pub struct HeaplessPusMgmtBackendProvider<const N: usize, Provider: GenericEvent> {
+        disabled: heapless::FnvIndexSet<LargestEventRaw, N>,
+        phantom: PhantomData<Provider>,
+    }
+
+    /// Safety: All contained field are [Send] as well
+    unsafe impl<const N: usize, Event: GenericEvent + Send> Send
+        for HeaplessPusMgmtBackendProvider<N, Event>
+    {
+    }
+
+    impl<const N: usize, Provider: GenericEvent> PusEventMgmtBackendProvider<Provider>
+        for HeaplessPusMgmtBackendProvider<N, Provider>
+    {
+        type Error = ();
+
+        fn event_enabled(&self, event: &Provider) -> bool {
+            self.disabled.contains(&event.raw_as_largest_type())
+        }
+
+        fn enable_event_reporting(&mut self, event: &Provider) -> Result<bool, Self::Error> {
+            self.disabled
+                .insert(event.raw_as_largest_type())
+                .map_err(|_| ())
+        }
+
+        fn disable_event_reporting(&mut self, event: &Provider) -> Result<bool, Self::Error> {
+            Ok(self.disabled.remove(&event.raw_as_largest_type()))
+        }
+    }
+}
+
+#[derive(Debug)]
+pub enum EventRequest<Event: GenericEvent = EventU32> {
+    Enable(Event),
+    Disable(Event),
+}
+
+#[derive(Debug)]
+pub struct EventRequestWithToken<Event: GenericEvent = EventU32> {
+    pub request: EventRequest<Event>,
+    pub token: TcStateToken,
+}
+
+#[derive(Debug)]
+pub enum EventManError {
+    EcssTmtcError(EcssTmtcError),
+    SeverityMissmatch(Severity, Severity),
+}
+
+impl From<EcssTmtcError> for EventManError {
+    fn from(v: EcssTmtcError) -> Self {
+        Self::EcssTmtcError(v)
+    }
+}
+
+#[cfg(feature = "alloc")]
+pub mod alloc_mod {
+    use super::*;
+
+    /// Default backend provider which uses a hash set as the event reporting status container
+    /// like mentioned in the example of the [PusEventMgmtBackendProvider] documentation.
+    ///
+    /// This provider is a good option for host systems or larger embedded systems where
+    /// the expected occasional memory allocation performed by the [HashSet] is not an issue.
+    pub struct DefaultPusMgmtBackendProvider<Event: GenericEvent = EventU32> {
+        disabled: HashSet<Event>,
+    }
+
+    /// Safety: All contained field are [Send] as well
+    unsafe impl<Event: GenericEvent + Send> Send for DefaultPusMgmtBackendProvider<Event> {}
+
+    impl<Event: GenericEvent> Default for DefaultPusMgmtBackendProvider<Event> {
+        fn default() -> Self {
+            Self {
+                disabled: HashSet::default(),
+            }
+        }
+    }
+
+    impl<Provider: GenericEvent + PartialEq + Eq + Hash + Copy + Clone>
+        PusEventMgmtBackendProvider<Provider> for DefaultPusMgmtBackendProvider<Provider>
+    {
+        type Error = ();
+        fn event_enabled(&self, event: &Provider) -> bool {
+            !self.disabled.contains(event)
+        }
+
+        fn enable_event_reporting(&mut self, event: &Provider) -> Result<bool, Self::Error> {
+            Ok(self.disabled.remove(event))
+        }
+
+        fn disable_event_reporting(&mut self, event: &Provider) -> Result<bool, Self::Error> {
+            Ok(self.disabled.insert(*event))
+        }
+    }
+
+    pub struct PusEventDispatcher<BackendError, Provider: GenericEvent> {
+        reporter: EventReporter,
+        backend: Box<dyn PusEventMgmtBackendProvider<Provider, Error = BackendError>>,
+    }
+
+    /// Safety: All contained fields are send as well.
+    unsafe impl<E: Send, Event: GenericEvent + Send> Send for PusEventDispatcher<E, Event> {}
+
+    impl<BackendError, Provider: GenericEvent> PusEventDispatcher<BackendError, Provider> {
+        pub fn new(
+            reporter: EventReporter,
+            backend: Box<dyn PusEventMgmtBackendProvider<Provider, Error = BackendError>>,
+        ) -> Self {
+            Self { reporter, backend }
+        }
+    }
+
+    impl<BackendError, Event: GenericEvent> PusEventDispatcher<BackendError, Event> {
+        pub fn enable_tm_for_event(&mut self, event: &Event) -> Result<bool, BackendError> {
+            self.backend.enable_event_reporting(event)
+        }
+
+        pub fn disable_tm_for_event(&mut self, event: &Event) -> Result<bool, BackendError> {
+            self.backend.disable_event_reporting(event)
+        }
+
+        pub fn generate_pus_event_tm_generic(
+            &mut self,
+            sender: &mut (impl EcssTmSenderCore + ?Sized),
+            time_stamp: &[u8],
+            event: Event,
+            aux_data: Option<&[u8]>,
+        ) -> Result<bool, EventManError> {
+            if !self.backend.event_enabled(&event) {
+                return Ok(false);
+            }
+            match event.severity() {
+                Severity::INFO => self
+                    .reporter
+                    .event_info(sender, time_stamp, event, aux_data)
+                    .map(|_| true)
+                    .map_err(|e| e.into()),
+                Severity::LOW => self
+                    .reporter
+                    .event_low_severity(sender, time_stamp, event, aux_data)
+                    .map(|_| true)
+                    .map_err(|e| e.into()),
+                Severity::MEDIUM => self
+                    .reporter
+                    .event_medium_severity(sender, time_stamp, event, aux_data)
+                    .map(|_| true)
+                    .map_err(|e| e.into()),
+                Severity::HIGH => self
+                    .reporter
+                    .event_high_severity(sender, time_stamp, event, aux_data)
+                    .map(|_| true)
+                    .map_err(|e| e.into()),
+            }
+        }
+    }
+
+    impl<BackendError> PusEventDispatcher<BackendError, EventU32> {
+        pub fn enable_tm_for_event_with_sev<Severity: HasSeverity>(
+            &mut self,
+            event: &EventU32TypedSev<Severity>,
+        ) -> Result<bool, BackendError> {
+            self.backend.enable_event_reporting(event.as_ref())
+        }
+
+        pub fn disable_tm_for_event_with_sev<Severity: HasSeverity>(
+            &mut self,
+            event: &EventU32TypedSev<Severity>,
+        ) -> Result<bool, BackendError> {
+            self.backend.disable_event_reporting(event.as_ref())
+        }
+
+        pub fn generate_pus_event_tm<Severity: HasSeverity>(
+            &mut self,
+            sender: &mut (impl EcssTmSenderCore + ?Sized),
+            time_stamp: &[u8],
+            event: EventU32TypedSev<Severity>,
+            aux_data: Option<&[u8]>,
+        ) -> Result<bool, EventManError> {
+            self.generate_pus_event_tm_generic(sender, time_stamp, event.into(), aux_data)
+        }
+    }
+}
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::events::SeverityInfo;
+    use crate::pus::MpscTmAsVecSender;
+    use std::sync::mpsc::{channel, TryRecvError};
+
+    const INFO_EVENT: EventU32TypedSev<SeverityInfo> =
+        EventU32TypedSev::<SeverityInfo>::const_new(1, 0);
+    const LOW_SEV_EVENT: EventU32 = EventU32::const_new(Severity::LOW, 1, 5);
+    const EMPTY_STAMP: [u8; 7] = [0; 7];
+
+    fn create_basic_man() -> PusEventDispatcher<(), EventU32> {
+        let reporter = EventReporter::new(0x02, 128).expect("Creating event repoter failed");
+        let backend = DefaultPusMgmtBackendProvider::<EventU32>::default();
+        PusEventDispatcher::new(reporter, Box::new(backend))
+    }
+
+    #[test]
+    fn test_basic() {
+        let mut event_man = create_basic_man();
+        let (event_tx, event_rx) = channel();
+        let mut sender = MpscTmAsVecSender::new(0, "test_sender", event_tx);
+        let event_sent = event_man
+            .generate_pus_event_tm(&mut sender, &EMPTY_STAMP, INFO_EVENT, None)
+            .expect("Sending info event failed");
+
+        assert!(event_sent);
+        // Will not check packet here, correctness of packet was tested somewhere else
+        event_rx.try_recv().expect("Receiving event TM failed");
+    }
+
+    #[test]
+    fn test_disable_event() {
+        let mut event_man = create_basic_man();
+        let (event_tx, event_rx) = channel();
+        let mut sender = MpscTmAsVecSender::new(0, "test", event_tx);
+        let res = event_man.disable_tm_for_event(&LOW_SEV_EVENT);
+        assert!(res.is_ok());
+        assert!(res.unwrap());
+        let mut event_sent = event_man
+            .generate_pus_event_tm_generic(&mut sender, &EMPTY_STAMP, LOW_SEV_EVENT, None)
+            .expect("Sending low severity event failed");
+        assert!(!event_sent);
+        let res = event_rx.try_recv();
+        assert!(res.is_err());
+        assert!(matches!(res.unwrap_err(), TryRecvError::Empty));
+        // Check that only the low severity event was disabled
+        event_sent = event_man
+            .generate_pus_event_tm(&mut sender, &EMPTY_STAMP, INFO_EVENT, None)
+            .expect("Sending info event failed");
+        assert!(event_sent);
+        event_rx.try_recv().expect("No info event received");
+    }
+
+    #[test]
+    fn test_reenable_event() {
+        let mut event_man = create_basic_man();
+        let (event_tx, event_rx) = channel();
+        let mut sender = MpscTmAsVecSender::new(0, "test", event_tx);
+        let mut res = event_man.disable_tm_for_event_with_sev(&INFO_EVENT);
+        assert!(res.is_ok());
+        assert!(res.unwrap());
+        res = event_man.enable_tm_for_event_with_sev(&INFO_EVENT);
+        assert!(res.is_ok());
+        assert!(res.unwrap());
+        let event_sent = event_man
+            .generate_pus_event_tm(&mut sender, &EMPTY_STAMP, INFO_EVENT, None)
+            .expect("Sending info event failed");
+        assert!(event_sent);
+        event_rx.try_recv().expect("No info event received");
+    }
+}
diff --git a/satrs-core/src/pus/event_srv.rs b/satrs-core/src/pus/event_srv.rs
new file mode 100644
index 0000000..8f3abb4
--- /dev/null
+++ b/satrs-core/src/pus/event_srv.rs
@@ -0,0 +1,133 @@
+use crate::events::EventU32;
+use crate::pool::{SharedPool, StoreAddr};
+use crate::pus::event_man::{EventRequest, EventRequestWithToken};
+use crate::pus::verification::{
+    StdVerifReporterWithSender, TcStateAccepted, TcStateToken, VerificationToken,
+};
+use crate::pus::{
+    EcssTcReceiver, EcssTmSender, PartialPusHandlingError, PusPacketHandlerResult,
+    PusPacketHandlingError, PusServiceBase, PusServiceHandler,
+};
+use spacepackets::ecss::event::Subservice;
+use spacepackets::ecss::PusPacket;
+use spacepackets::tc::PusTc;
+use std::boxed::Box;
+use std::sync::mpsc::Sender;
+
+pub struct PusService5EventHandler {
+    psb: PusServiceBase,
+    event_request_tx: Sender<EventRequestWithToken>,
+}
+
+impl PusService5EventHandler {
+    pub fn new(
+        tc_receiver: Box<dyn EcssTcReceiver>,
+        shared_tc_store: SharedPool,
+        tm_sender: Box<dyn EcssTmSender>,
+        tm_apid: u16,
+        verification_handler: StdVerifReporterWithSender,
+        event_request_tx: Sender<EventRequestWithToken>,
+    ) -> Self {
+        Self {
+            psb: PusServiceBase::new(
+                tc_receiver,
+                shared_tc_store,
+                tm_sender,
+                tm_apid,
+                verification_handler,
+            ),
+            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)?;
+        let (tc, _) = PusTc::from_bytes(&self.psb.pus_buf)?;
+        let subservice = tc.subservice();
+        let srv = Subservice::try_from(subservice);
+        if srv.is_err() {
+            return Ok(PusPacketHandlerResult::CustomSubservice(
+                tc.subservice(),
+                token,
+            ));
+        }
+        let handle_enable_disable_request = |enable: bool, stamp: [u8; 7]| {
+            if tc.user_data().is_none() || tc.user_data().unwrap().len() < 4 {
+                return Err(PusPacketHandlingError::NotEnoughAppData(
+                    "At least 4 bytes event ID expected".into(),
+                ));
+            }
+            let user_data = tc.user_data().unwrap();
+            let event_u32 = EventU32::from(u32::from_be_bytes(user_data[0..4].try_into().unwrap()));
+            let start_token = self
+                .psb
+                .verification_handler
+                .borrow_mut()
+                .start_success(token, Some(&stamp))
+                .map_err(|_| PartialPusHandlingError::Verification);
+            let partial_error = start_token.clone().err();
+            let mut token: TcStateToken = token.into();
+            if let Ok(start_token) = start_token {
+                token = start_token.into();
+            }
+            let event_req_with_token = if enable {
+                EventRequestWithToken {
+                    request: EventRequest::Enable(event_u32),
+                    token,
+                }
+            } else {
+                EventRequestWithToken {
+                    request: EventRequest::Disable(event_u32),
+                    token,
+                }
+            };
+            self.event_request_tx
+                .send(event_req_with_token)
+                .map_err(|_| {
+                    PusPacketHandlingError::Other("Forwarding event request failed".into())
+                })?;
+            if let Some(partial_error) = partial_error {
+                return Ok(PusPacketHandlerResult::RequestHandledPartialSuccess(
+                    partial_error,
+                ));
+            }
+            Ok(PusPacketHandlerResult::RequestHandled)
+        };
+        let mut partial_error = None;
+        let time_stamp = self.psb().get_current_timestamp(&mut partial_error);
+        match srv.unwrap() {
+            Subservice::TmInfoReport
+            | Subservice::TmLowSeverityReport
+            | Subservice::TmMediumSeverityReport
+            | Subservice::TmHighSeverityReport => {
+                return Err(PusPacketHandlingError::InvalidSubservice(tc.subservice()))
+            }
+            Subservice::TcEnableEventGeneration => {
+                handle_enable_disable_request(true, time_stamp)?;
+            }
+            Subservice::TcDisableEventGeneration => {
+                handle_enable_disable_request(false, time_stamp)?;
+            }
+            Subservice::TcReportDisabledList | Subservice::TmDisabledEventsReport => {
+                return Ok(PusPacketHandlerResult::SubserviceNotImplemented(
+                    subservice, token,
+                ));
+            }
+        }
+
+        Ok(PusPacketHandlerResult::RequestHandled)
+    }
+}
diff --git a/satrs-core/src/pus/hk.rs b/satrs-core/src/pus/hk.rs
new file mode 100644
index 0000000..50dbc86
--- /dev/null
+++ b/satrs-core/src/pus/hk.rs
@@ -0,0 +1 @@
+pub use spacepackets::ecss::hk::*;
diff --git a/satrs-core/src/pus/mod.rs b/satrs-core/src/pus/mod.rs
new file mode 100644
index 0000000..7325b43
--- /dev/null
+++ b/satrs-core/src/pus/mod.rs
@@ -0,0 +1,669 @@
+//! # PUS support modules
+//!
+//! This module contains structures to make working with the PUS C standard easier.
+//! The satrs-example application contains various usage examples of these components.
+use crate::ChannelId;
+use core::fmt::{Display, Formatter};
+#[cfg(feature = "alloc")]
+use downcast_rs::{impl_downcast, Downcast};
+#[cfg(feature = "alloc")]
+use dyn_clone::DynClone;
+use spacepackets::ecss::PusError;
+use spacepackets::tc::PusTc;
+use spacepackets::tm::PusTm;
+use spacepackets::{ByteConversionError, SizeMissmatch, SpHeader};
+use std::error::Error;
+
+pub mod event;
+pub mod event_man;
+pub mod event_srv;
+pub mod hk;
+pub mod mode;
+pub mod scheduler;
+pub mod scheduler_srv;
+#[cfg(feature = "std")]
+pub mod test;
+pub mod verification;
+
+#[cfg(feature = "alloc")]
+pub use alloc_mod::*;
+
+use crate::pool::{StoreAddr, StoreError};
+use crate::pus::verification::{TcStateAccepted, TcStateToken, VerificationToken};
+#[cfg(feature = "std")]
+pub use std_mod::*;
+
+#[derive(Debug, PartialEq, Eq, Clone)]
+pub enum PusTmWrapper<'tm> {
+    InStore(StoreAddr),
+    Direct(PusTm<'tm>),
+}
+
+impl From<StoreAddr> for PusTmWrapper<'_> {
+    fn from(value: StoreAddr) -> Self {
+        Self::InStore(value)
+    }
+}
+
+impl<'tm> From<PusTm<'tm>> for PusTmWrapper<'tm> {
+    fn from(value: PusTm<'tm>) -> Self {
+        Self::Direct(value)
+    }
+}
+
+pub type TcAddrWithToken = (StoreAddr, TcStateToken);
+
+/// Generic abstraction for a telecommand being sent around after is has been accepted.
+/// The actual telecommand is stored inside a pre-allocated pool structure.
+pub type AcceptedTc = (StoreAddr, VerificationToken<TcStateAccepted>);
+
+/// Generic error type for sending something via a message queue.
+#[derive(Debug, Copy, Clone)]
+pub enum GenericSendError {
+    RxDisconnected,
+    QueueFull(u32),
+}
+
+impl Display for GenericSendError {
+    fn fmt(&self, f: &mut Formatter<'_>) -> core::fmt::Result {
+        match self {
+            GenericSendError::RxDisconnected => {
+                write!(f, "rx side has disconnected")
+            }
+            GenericSendError::QueueFull(max_cap) => {
+                write!(f, "queue with max capacity of {max_cap} is full")
+            }
+        }
+    }
+}
+
+#[cfg(feature = "std")]
+impl Error for GenericSendError {}
+
+/// Generic error type for sending something via a message queue.
+#[derive(Debug, Copy, Clone)]
+pub enum GenericRecvError {
+    Empty,
+    TxDisconnected,
+}
+
+impl Display for GenericRecvError {
+    fn fmt(&self, f: &mut Formatter<'_>) -> core::fmt::Result {
+        match self {
+            Self::TxDisconnected => {
+                write!(f, "tx side has disconnected")
+            }
+            Self::Empty => {
+                write!(f, "nothing to receive")
+            }
+        }
+    }
+}
+
+#[cfg(feature = "std")]
+impl Error for GenericRecvError {}
+
+#[derive(Debug, Clone)]
+pub enum EcssTmtcError {
+    StoreLock,
+    Store(StoreError),
+    Pus(PusError),
+    CantSendAddr(StoreAddr),
+    Send(GenericSendError),
+    Recv(GenericRecvError),
+}
+
+impl Display for EcssTmtcError {
+    fn fmt(&self, f: &mut Formatter<'_>) -> core::fmt::Result {
+        match self {
+            EcssTmtcError::StoreLock => {
+                write!(f, "store lock error")
+            }
+            EcssTmtcError::Store(store) => {
+                write!(f, "store error: {store}")
+            }
+            EcssTmtcError::Pus(pus_e) => {
+                write!(f, "PUS error: {pus_e}")
+            }
+            EcssTmtcError::CantSendAddr(addr) => {
+                write!(f, "can not send address {addr}")
+            }
+            EcssTmtcError::Send(send_e) => {
+                write!(f, "send error {send_e}")
+            }
+            EcssTmtcError::Recv(recv_e) => {
+                write!(f, "recv error {recv_e}")
+            }
+        }
+    }
+}
+
+impl From<StoreError> for EcssTmtcError {
+    fn from(value: StoreError) -> Self {
+        Self::Store(value)
+    }
+}
+
+impl From<PusError> for EcssTmtcError {
+    fn from(value: PusError) -> Self {
+        Self::Pus(value)
+    }
+}
+
+impl From<GenericSendError> for EcssTmtcError {
+    fn from(value: GenericSendError) -> Self {
+        Self::Send(value)
+    }
+}
+
+impl From<GenericRecvError> for EcssTmtcError {
+    fn from(value: GenericRecvError) -> Self {
+        Self::Recv(value)
+    }
+}
+
+#[cfg(feature = "std")]
+impl Error for EcssTmtcError {
+    fn source(&self) -> Option<&(dyn Error + 'static)> {
+        match self {
+            EcssTmtcError::Store(e) => Some(e),
+            EcssTmtcError::Pus(e) => Some(e),
+            EcssTmtcError::Send(e) => Some(e),
+            _ => None,
+        }
+    }
+}
+pub trait EcssChannel: Send {
+    /// Each sender can have an ID associated with it
+    fn id(&self) -> ChannelId;
+    fn name(&self) -> &'static str {
+        "unset"
+    }
+}
+
+/// Generic trait for a user supplied sender object.
+///
+/// This sender object is responsible for sending PUS telemetry to a TM sink.
+pub trait EcssTmSenderCore: EcssChannel {
+    fn send_tm(&self, tm: PusTmWrapper) -> Result<(), EcssTmtcError>;
+}
+
+/// Generic trait for a user supplied sender object.
+///
+/// This sender object is responsible for sending PUS telecommands to a TC recipient. Each
+/// telecommand can optionally have a token which contains its verification state.
+pub trait EcssTcSenderCore: EcssChannel {
+    fn send_tc(&self, tc: PusTc, token: Option<TcStateToken>) -> Result<(), EcssTmtcError>;
+}
+
+pub struct ReceivedTcWrapper {
+    pub store_addr: StoreAddr,
+    pub token: Option<TcStateToken>,
+}
+
+#[derive(Debug, Clone)]
+pub enum TryRecvTmtcError {
+    Error(EcssTmtcError),
+    Empty,
+}
+
+impl From<EcssTmtcError> for TryRecvTmtcError {
+    fn from(value: EcssTmtcError) -> Self {
+        Self::Error(value)
+    }
+}
+
+impl From<PusError> for TryRecvTmtcError {
+    fn from(value: PusError) -> Self {
+        Self::Error(value.into())
+    }
+}
+
+impl From<StoreError> for TryRecvTmtcError {
+    fn from(value: StoreError) -> Self {
+        Self::Error(value.into())
+    }
+}
+
+/// Generic trait for a user supplied receiver object.
+pub trait EcssTcReceiverCore: EcssChannel {
+    fn recv_tc(&self) -> Result<ReceivedTcWrapper, TryRecvTmtcError>;
+}
+
+/// Generic trait for objects which can receive ECSS PUS telecommands. This trait is
+/// implemented by the [crate::tmtc::pus_distrib::PusDistributor] objects to allow passing PUS TC
+/// packets into it.
+pub trait ReceivesEcssPusTc {
+    type Error;
+    fn pass_pus_tc(&mut self, header: &SpHeader, pus_tc: &PusTc) -> Result<(), Self::Error>;
+}
+
+#[cfg(feature = "alloc")]
+mod alloc_mod {
+    use super::*;
+
+    /// Extension trait for [EcssTmSenderCore].
+    ///
+    /// It provides additional functionality, for example by implementing the [Downcast] trait
+    /// and the [DynClone] trait.
+    ///
+    /// [Downcast] is implemented to allow passing the sender as a boxed trait object and still
+    /// retrieve the concrete type at a later point.
+    ///
+    /// [DynClone] allows cloning the trait object as long as the boxed object implements
+    /// [Clone].
+    #[cfg(feature = "alloc")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "alloc")))]
+    pub trait EcssTmSender: EcssTmSenderCore + Downcast + DynClone {}
+
+    /// Blanket implementation for all types which implement [EcssTmSenderCore] and are clonable.
+    impl<T> EcssTmSender for T where T: EcssTmSenderCore + Clone + 'static {}
+
+    dyn_clone::clone_trait_object!(EcssTmSender);
+    impl_downcast!(EcssTmSender);
+
+    /// Extension trait for [EcssTcSenderCore].
+    ///
+    /// It provides additional functionality, for example by implementing the [Downcast] trait
+    /// and the [DynClone] trait.
+    ///
+    /// [Downcast] is implemented to allow passing the sender as a boxed trait object and still
+    /// retrieve the concrete type at a later point.
+    ///
+    /// [DynClone] allows cloning the trait object as long as the boxed object implements
+    /// [Clone].
+    #[cfg(feature = "alloc")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "alloc")))]
+    pub trait EcssTcSender: EcssTcSenderCore + Downcast + DynClone {}
+
+    /// Blanket implementation for all types which implement [EcssTcSenderCore] and are clonable.
+    impl<T> EcssTcSender for T where T: EcssTcSenderCore + Clone + 'static {}
+
+    dyn_clone::clone_trait_object!(EcssTcSender);
+    impl_downcast!(EcssTcSender);
+
+    /// Extension trait for [EcssTcReceiverCore].
+    ///
+    /// It provides additional functionality, for example by implementing the [Downcast] trait
+    /// and the [DynClone] trait.
+    ///
+    /// [Downcast] is implemented to allow passing the sender as a boxed trait object and still
+    /// retrieve the concrete type at a later point.
+    ///
+    /// [DynClone] allows cloning the trait object as long as the boxed object implements
+    /// [Clone].
+    #[cfg(feature = "alloc")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "alloc")))]
+    pub trait EcssTcReceiver: EcssTcReceiverCore + Downcast {}
+
+    /// Blanket implementation for all types which implement [EcssTcReceiverCore] and are clonable.
+    impl<T> EcssTcReceiver for T where T: EcssTcReceiverCore + 'static {}
+
+    impl_downcast!(EcssTcReceiver);
+}
+
+#[cfg(feature = "std")]
+pub mod std_mod {
+    use crate::pool::{SharedPool, StoreAddr};
+    use crate::pus::verification::{
+        StdVerifReporterWithSender, TcStateAccepted, VerificationToken,
+    };
+    use crate::pus::{
+        EcssChannel, EcssTcReceiver, EcssTcReceiverCore, EcssTmSender, EcssTmSenderCore,
+        EcssTmtcError, GenericRecvError, GenericSendError, PusTmWrapper, ReceivedTcWrapper,
+        TcAddrWithToken, TryRecvTmtcError,
+    };
+    use crate::tmtc::tm_helper::SharedTmStore;
+    use crate::ChannelId;
+    use alloc::boxed::Box;
+    use alloc::vec::Vec;
+    use spacepackets::ecss::PusError;
+    use spacepackets::time::cds::TimeProvider;
+    use spacepackets::time::StdTimestampError;
+    use spacepackets::time::TimeWriter;
+    use spacepackets::tm::PusTm;
+    use std::cell::RefCell;
+    use std::string::String;
+    use std::sync::mpsc;
+    use std::sync::mpsc::{SendError, TryRecvError};
+    use thiserror::Error;
+
+    #[derive(Clone)]
+    pub struct MpscTmInStoreSender {
+        id: ChannelId,
+        name: &'static str,
+        shared_tm_store: SharedTmStore,
+        sender: mpsc::Sender<StoreAddr>,
+        pub ignore_poison_errors: bool,
+    }
+
+    impl EcssChannel for MpscTmInStoreSender {
+        fn id(&self) -> ChannelId {
+            self.id
+        }
+
+        fn name(&self) -> &'static str {
+            self.name
+        }
+    }
+
+    impl From<SendError<StoreAddr>> for EcssTmtcError {
+        fn from(_: SendError<StoreAddr>) -> Self {
+            Self::Send(GenericSendError::RxDisconnected)
+        }
+    }
+    impl MpscTmInStoreSender {
+        pub fn send_direct_tm(&self, tm: PusTm) -> Result<(), EcssTmtcError> {
+            let addr = self.shared_tm_store.add_pus_tm(&tm)?;
+            self.sender
+                .send(addr)
+                .map_err(|_| EcssTmtcError::Send(GenericSendError::RxDisconnected))
+        }
+    }
+
+    impl EcssTmSenderCore for MpscTmInStoreSender {
+        fn send_tm(&self, tm: PusTmWrapper) -> Result<(), EcssTmtcError> {
+            match tm {
+                PusTmWrapper::InStore(addr) => self.sender.send(addr).map_err(|e| e.into()),
+                PusTmWrapper::Direct(tm) => self.send_direct_tm(tm),
+            }
+        }
+    }
+
+    impl MpscTmInStoreSender {
+        pub fn new(
+            id: ChannelId,
+            name: &'static str,
+            shared_tm_store: SharedTmStore,
+            sender: mpsc::Sender<StoreAddr>,
+        ) -> Self {
+            Self {
+                id,
+                name,
+                shared_tm_store,
+                sender,
+                ignore_poison_errors: false,
+            }
+        }
+    }
+
+    pub struct MpscTcInStoreReceiver {
+        id: ChannelId,
+        name: &'static str,
+        receiver: mpsc::Receiver<TcAddrWithToken>,
+        pub ignore_poison_errors: bool,
+    }
+
+    impl EcssChannel for MpscTcInStoreReceiver {
+        fn id(&self) -> ChannelId {
+            self.id
+        }
+
+        fn name(&self) -> &'static str {
+            self.name
+        }
+    }
+
+    impl EcssTcReceiverCore for MpscTcInStoreReceiver {
+        fn recv_tc(&self) -> Result<ReceivedTcWrapper, TryRecvTmtcError> {
+            let (store_addr, token) = self.receiver.try_recv().map_err(|e| match e {
+                TryRecvError::Empty => TryRecvTmtcError::Empty,
+                TryRecvError::Disconnected => {
+                    TryRecvTmtcError::Error(EcssTmtcError::from(GenericRecvError::TxDisconnected))
+                }
+            })?;
+            Ok(ReceivedTcWrapper {
+                store_addr,
+                token: Some(token),
+            })
+        }
+    }
+
+    impl MpscTcInStoreReceiver {
+        pub fn new(
+            id: ChannelId,
+            name: &'static str,
+            receiver: mpsc::Receiver<TcAddrWithToken>,
+        ) -> Self {
+            Self {
+                id,
+                name,
+                receiver,
+                ignore_poison_errors: false,
+            }
+        }
+    }
+
+    /// This class can be used if frequent heap allocations during run-time are not an issue.
+    /// PUS TM packets will be sent around as [Vec]s. Please note that the current implementation
+    /// of this class can not deal with store addresses, so it is assumed that is is always
+    /// going to be called with direct packets.
+    #[derive(Clone)]
+    pub struct MpscTmAsVecSender {
+        id: ChannelId,
+        sender: mpsc::Sender<Vec<u8>>,
+        name: &'static str,
+    }
+
+    impl From<SendError<Vec<u8>>> for EcssTmtcError {
+        fn from(_: SendError<Vec<u8>>) -> Self {
+            Self::Send(GenericSendError::RxDisconnected)
+        }
+    }
+
+    impl MpscTmAsVecSender {
+        pub fn new(id: u32, name: &'static str, sender: mpsc::Sender<Vec<u8>>) -> Self {
+            Self { id, sender, name }
+        }
+    }
+
+    impl EcssChannel for MpscTmAsVecSender {
+        fn id(&self) -> ChannelId {
+            self.id
+        }
+        fn name(&self) -> &'static str {
+            self.name
+        }
+    }
+
+    impl EcssTmSenderCore for MpscTmAsVecSender {
+        fn send_tm(&self, tm: PusTmWrapper) -> Result<(), EcssTmtcError> {
+            match tm {
+                PusTmWrapper::InStore(addr) => Err(EcssTmtcError::CantSendAddr(addr)),
+                PusTmWrapper::Direct(tm) => {
+                    let mut vec = Vec::new();
+                    tm.append_to_vec(&mut vec).map_err(EcssTmtcError::Pus)?;
+                    self.sender.send(vec)?;
+                    Ok(())
+                }
+            }
+        }
+    }
+
+    #[derive(Debug, Clone, Error)]
+    pub enum PusPacketHandlingError {
+        #[error("generic PUS error: {0}")]
+        Pus(#[from] PusError),
+        #[error("wrong service number {0} for packet handler")]
+        WrongService(u8),
+        #[error("invalid subservice {0}")]
+        InvalidSubservice(u8),
+        #[error("not enough application data available: {0}")]
+        NotEnoughAppData(String),
+        #[error("invalid application data")]
+        InvalidAppData(String),
+        #[error("generic ECSS tmtc error: {0}")]
+        EcssTmtc(#[from] EcssTmtcError),
+        #[error("invalid verification token")]
+        InvalidVerificationToken,
+        #[error("other error {0}")]
+        Other(String),
+    }
+
+    #[derive(Debug, Clone, Error)]
+    pub enum PartialPusHandlingError {
+        #[error("generic timestamp generation error")]
+        Time(#[from] StdTimestampError),
+        #[error("error sending telemetry: {0}")]
+        TmSend(#[from] EcssTmtcError),
+        #[error("error sending verification message")]
+        Verification,
+        #[error("invalid verification token")]
+        NoVerificationToken,
+    }
+
+    /// Generic result type for handlers which can process PUS packets.
+    #[derive(Debug, Clone)]
+    pub enum PusPacketHandlerResult {
+        RequestHandled,
+        RequestHandledPartialSuccess(PartialPusHandlingError),
+        SubserviceNotImplemented(u8, VerificationToken<TcStateAccepted>),
+        CustomSubservice(u8, VerificationToken<TcStateAccepted>),
+        Empty,
+    }
+
+    impl From<PartialPusHandlingError> for PusPacketHandlerResult {
+        fn from(value: PartialPusHandlingError) -> Self {
+            Self::RequestHandledPartialSuccess(value)
+        }
+    }
+
+    /// 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 tc_receiver: Box<dyn EcssTcReceiver>,
+        pub shared_tc_store: SharedPool,
+        pub tm_sender: Box<dyn EcssTmSender>,
+        pub tm_apid: u16,
+        /// The verification handler is wrapped in a [RefCell] to allow the interior mutability
+        /// pattern. This makes writing methods which are not mutable a lot easier.
+        pub verification_handler: RefCell<StdVerifReporterWithSender>,
+        pub pus_buf: [u8; 2048],
+        pub pus_size: usize,
+    }
+
+    impl PusServiceBase {
+        pub fn new(
+            tc_receiver: Box<dyn EcssTcReceiver>,
+            shared_tc_store: SharedPool,
+            tm_sender: Box<dyn EcssTmSender>,
+            tm_apid: u16,
+            verification_handler: StdVerifReporterWithSender,
+        ) -> Self {
+            Self {
+                tc_receiver,
+                shared_tc_store,
+                tm_apid,
+                tm_sender,
+                verification_handler: RefCell::new(verification_handler),
+                pus_buf: [0; 2048],
+                pus_size: 0,
+            }
+        }
+
+        pub fn get_current_timestamp(
+            &self,
+            partial_error: &mut Option<PartialPusHandlingError>,
+        ) -> [u8; 7] {
+            let mut time_stamp: [u8; 7] = [0; 7];
+            let time_provider =
+                TimeProvider::from_now_with_u16_days().map_err(PartialPusHandlingError::Time);
+            if let Ok(time_provider) = time_provider {
+                // Can't fail, we have a buffer with the exact required size.
+                time_provider.write_to_bytes(&mut time_stamp).unwrap();
+            } else {
+                *partial_error = Some(time_provider.unwrap_err());
+            }
+            time_stamp
+        }
+
+        pub fn get_current_timestamp_ignore_error(&self) -> [u8; 7] {
+            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> {
+            // Keep locked section as short as possible.
+            let psb_mut = self.psb_mut();
+            let mut tc_pool = psb_mut
+                .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);
+            Ok(())
+        }
+
+        fn handle_next_packet(&mut self) -> Result<PusPacketHandlerResult, PusPacketHandlingError> {
+            match self.psb().tc_receiver.recv_tc() {
+                Ok(ReceivedTcWrapper { store_addr, token }) => {
+                    if token.is_none() {
+                        return Err(PusPacketHandlingError::InvalidVerificationToken);
+                    }
+                    let token = token.unwrap();
+                    let accepted_token = VerificationToken::<TcStateAccepted>::try_from(token)
+                        .map_err(|_| PusPacketHandlingError::InvalidVerificationToken)?;
+                    self.handle_one_tc(store_addr, accepted_token)
+                }
+                Err(e) => match e {
+                    TryRecvTmtcError::Error(e) => Err(PusPacketHandlingError::EcssTmtc(e)),
+                    TryRecvTmtcError::Empty => Ok(PusPacketHandlerResult::Empty),
+                },
+            }
+        }
+    }
+}
+
+pub(crate) fn source_buffer_large_enough(cap: usize, len: usize) -> Result<(), EcssTmtcError> {
+    if len > cap {
+        return Err(
+            PusError::ByteConversion(ByteConversionError::ToSliceTooSmall(SizeMissmatch {
+                found: cap,
+                expected: len,
+            }))
+            .into(),
+        );
+    }
+    Ok(())
+}
+
+#[cfg(test)]
+pub(crate) mod tests {
+    use spacepackets::tm::{GenericPusTmSecondaryHeader, PusTm};
+    use spacepackets::CcsdsPacket;
+
+    #[derive(Debug, Eq, PartialEq, Clone)]
+    pub(crate) struct CommonTmInfo {
+        pub subservice: u8,
+        pub apid: u16,
+        pub msg_counter: u16,
+        pub dest_id: u16,
+        pub time_stamp: [u8; 7],
+    }
+
+    impl CommonTmInfo {
+        pub fn new_from_tm(tm: &PusTm) -> Self {
+            let mut time_stamp = [0; 7];
+            time_stamp.clone_from_slice(&tm.timestamp().unwrap()[0..7]);
+            Self {
+                subservice: tm.subservice(),
+                apid: tm.apid(),
+                msg_counter: tm.msg_counter(),
+                dest_id: tm.dest_id(),
+                time_stamp,
+            }
+        }
+    }
+}
diff --git a/satrs-core/src/pus/mode.rs b/satrs-core/src/pus/mode.rs
new file mode 100644
index 0000000..1ab46ef
--- /dev/null
+++ b/satrs-core/src/pus/mode.rs
@@ -0,0 +1,16 @@
+use num_enum::{IntoPrimitive, TryFromPrimitive};
+#[cfg(feature = "serde")]
+use serde::{Deserialize, Serialize};
+
+#[derive(Debug, Eq, PartialEq, Copy, Clone, IntoPrimitive, TryFromPrimitive)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[repr(u8)]
+pub enum Subservice {
+    TcSetMode = 1,
+    TcReadMode = 3,
+    TcAnnounceMode = 4,
+    TcAnnounceModeRecursive = 5,
+    TmModeReply = 6,
+    TmCantReachMode = 7,
+    TmWrongModeReply = 8,
+}
diff --git a/satrs-core/src/pus/scheduler.rs b/satrs-core/src/pus/scheduler.rs
new file mode 100644
index 0000000..0406f83
--- /dev/null
+++ b/satrs-core/src/pus/scheduler.rs
@@ -0,0 +1,1683 @@
+//! # PUS Service 11 Scheduling Module
+//!
+//! 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 crate::pool::{StoreAddr, StoreError};
+use core::fmt::{Debug, Display, Formatter};
+use core::time::Duration;
+#[cfg(feature = "serde")]
+use serde::{Deserialize, Serialize};
+use spacepackets::ecss::scheduling::TimeWindowType;
+use spacepackets::ecss::PusError;
+use spacepackets::tc::{GenericPusTcSecondaryHeader, PusTc};
+use spacepackets::time::{CcsdsTimeProvider, TimestampError, UnixTimestamp};
+use spacepackets::CcsdsPacket;
+#[cfg(feature = "std")]
+use std::error::Error;
+
+//#[cfg(feature = "std")]
+//pub use std_mod::*;
+
+#[cfg(feature = "alloc")]
+pub use alloc_mod::*;
+
+/// This is the request ID as specified in ECSS-E-ST-70-41C 5.4.11.2 of the standard.
+///
+/// This version of the request ID is used to identify scheduled  commands and also contains
+/// the source ID found in the secondary header of PUS telecommands.
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+pub struct RequestId {
+    pub(crate) source_id: u16,
+    pub(crate) apid: u16,
+    pub(crate) seq_count: u16,
+}
+
+impl RequestId {
+    pub fn source_id(&self) -> u16 {
+        self.source_id
+    }
+
+    pub fn apid(&self) -> u16 {
+        self.apid
+    }
+
+    pub fn seq_count(&self) -> u16 {
+        self.seq_count
+    }
+
+    pub fn from_tc(tc: &PusTc) -> Self {
+        RequestId {
+            source_id: tc.source_id(),
+            apid: tc.apid(),
+            seq_count: tc.seq_count(),
+        }
+    }
+
+    pub fn as_u64(&self) -> u64 {
+        ((self.source_id as u64) << 32) | ((self.apid as u64) << 16) | self.seq_count as u64
+    }
+
+    /*
+    pub fn from_bytes(buf: &[u8]) -> Result<Self, ByteConversionError> {
+        if buf.len() < core::mem::size_of::<u64>() {
+            return Err(ByteConversionError::FromSliceTooSmall(SizeMissmatch {
+                found: buf.len(),
+                expected: core::mem::size_of::<u64>(),
+            }));
+        }
+        Ok(Self {
+            source_id: u16::from_be_bytes(buf[0..2].try_into().unwrap()),
+            apid: u16::from_be_bytes(buf[2..4].try_into().unwrap()),
+            seq_count: u16::from_be_bytes(buf[4..6].try_into().unwrap()),
+        })
+    }
+     */
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+pub enum ScheduleError {
+    PusError(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.
+    ReleaseTimeInTimeMargin(UnixTimestamp, Duration, UnixTimestamp),
+    /// Nested time-tagged commands are not allowed.
+    NestedScheduledTc,
+    StoreError(StoreError),
+    TcDataEmpty,
+    TimestampError(TimestampError),
+    WrongSubservice,
+    WrongService,
+}
+
+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, margin, timestamp) => {
+                write!(
+                    f,
+                    "Error: time margin too short, current time: {current_time:?}, time margin: {margin:?}, release time: {timestamp:?}"
+                )
+            }
+            ScheduleError::NestedScheduledTc => {
+                write!(f, "Error: nested scheduling is not allowed")
+            }
+            ScheduleError::StoreError(e) => {
+                write!(f, "Store Error: {e}")
+            }
+            ScheduleError::TcDataEmpty => {
+                write!(f, "Error: empty Tc Data field")
+            }
+            ScheduleError::TimestampError(e) => {
+                write!(f, "Timestamp Error: {e}")
+            }
+            ScheduleError::WrongService => {
+                write!(f, "Error: Service not 11.")
+            }
+            ScheduleError::WrongSubservice => {
+                write!(f, "Error: Subservice not 4.")
+            }
+        }
+    }
+}
+
+impl From<PusError> for ScheduleError {
+    fn from(e: PusError) -> Self {
+        ScheduleError::PusError(e)
+    }
+}
+
+impl From<StoreError> for ScheduleError {
+    fn from(e: StoreError) -> Self {
+        ScheduleError::StoreError(e)
+    }
+}
+
+impl From<TimestampError> for ScheduleError {
+    fn from(e: TimestampError) -> Self {
+        ScheduleError::TimestampError(e)
+    }
+}
+
+#[cfg(feature = "std")]
+impl Error for ScheduleError {}
+
+/// This is the format stored internally by the TC scheduler for each scheduled telecommand.
+/// It consists of the address of that telecommand in the TC pool and a request ID.
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+pub struct TcInfo {
+    addr: StoreAddr,
+    request_id: RequestId,
+}
+
+impl TcInfo {
+    pub fn addr(&self) -> StoreAddr {
+        self.addr
+    }
+
+    pub fn request_id(&self) -> RequestId {
+        self.request_id
+    }
+
+    pub fn new(addr: StoreAddr, request_id: RequestId) -> Self {
+        TcInfo { addr, request_id }
+    }
+}
+
+enum DeletionResult {
+    WithoutStoreDeletion(Option<StoreAddr>),
+    WithStoreDeletion(Result<bool, StoreError>),
+}
+
+pub struct TimeWindow<TimeProvder> {
+    time_window_type: TimeWindowType,
+    start_time: Option<TimeProvder>,
+    end_time: Option<TimeProvder>,
+}
+
+impl<TimeProvider> TimeWindow<TimeProvider> {
+    pub fn new_select_all() -> Self {
+        Self {
+            time_window_type: TimeWindowType::SelectAll,
+            start_time: None,
+            end_time: None,
+        }
+    }
+
+    pub fn time_window_type(&self) -> TimeWindowType {
+        self.time_window_type
+    }
+
+    pub fn start_time(&self) -> Option<&TimeProvider> {
+        self.start_time.as_ref()
+    }
+
+    pub fn end_time(&self) -> Option<&TimeProvider> {
+        self.end_time.as_ref()
+    }
+}
+
+impl<TimeProvider: CcsdsTimeProvider + Clone> TimeWindow<TimeProvider> {
+    pub fn new_from_time_to_time(start_time: &TimeProvider, end_time: &TimeProvider) -> Self {
+        Self {
+            time_window_type: TimeWindowType::TimeTagToTimeTag,
+            start_time: Some(start_time.clone()),
+            end_time: Some(end_time.clone()),
+        }
+    }
+
+    pub fn new_from_time(start_time: &TimeProvider) -> Self {
+        Self {
+            time_window_type: TimeWindowType::FromTimeTag,
+            start_time: Some(start_time.clone()),
+            end_time: None,
+        }
+    }
+
+    pub fn new_to_time(end_time: &TimeProvider) -> Self {
+        Self {
+            time_window_type: TimeWindowType::ToTimeTag,
+            start_time: None,
+            end_time: Some(end_time.clone()),
+        }
+    }
+}
+
+#[cfg(feature = "alloc")]
+pub mod alloc_mod {
+    use crate::pool::{PoolProvider, StoreAddr, StoreError};
+    use crate::pus::scheduler::{DeletionResult, RequestId, ScheduleError, TcInfo, TimeWindow};
+    use alloc::collections::btree_map::{Entry, Range};
+    use alloc::collections::BTreeMap;
+    use alloc::vec;
+    use alloc::vec::Vec;
+    use core::time::Duration;
+    use spacepackets::ecss::scheduling::TimeWindowType;
+    use spacepackets::ecss::PusPacket;
+    use spacepackets::tc::PusTc;
+    use spacepackets::time::cds::DaysLen24Bits;
+    use spacepackets::time::{cds, CcsdsTimeProvider, TimeReader, UnixTimestamp};
+
+    #[cfg(feature = "std")]
+    use std::time::SystemTimeError;
+
+    /// This is the core data structure for scheduling PUS telecommands with [alloc] support.
+    ///
+    /// It is assumed that the actual telecommand data is stored in a separate TC pool offering
+    /// a [crate::pool::PoolProvider] API. This data structure just tracks the store addresses and their
+    /// release times and offers a convenient API to insert and release telecommands and perform
+    /// other functionality specified by the ECSS standard in section 6.11. The time is tracked
+    /// as a [spacepackets::time::UnixTimestamp] but the only requirement to the timekeeping of
+    /// the user is that it is convertible to that timestamp.
+    ///
+    /// The standard also specifies that the PUS scheduler can be enabled and disabled.
+    /// A disabled scheduler should still delete commands where the execution time has been reached
+    /// but should not release them to be executed.
+    ///
+    /// The implementation uses an ordered map internally with the release timestamp being the key.
+    /// This allows efficient time based insertions and extractions which should be the primary use-case
+    /// for a time-based command scheduler.
+    /// There is no way to avoid duplicate [RequestId]s during insertion, which can occur even if the
+    /// user always correctly increment for sequence counter due to overflows. To avoid this issue,
+    /// it can make sense to split up telecommand groups by the APID to avoid overflows.
+    ///
+    /// Currently, sub-schedules and groups are not supported.
+    #[derive(Debug)]
+    pub struct PusScheduler {
+        tc_map: BTreeMap<UnixTimestamp, Vec<TcInfo>>,
+        pub(crate) current_time: UnixTimestamp,
+        time_margin: Duration,
+        enabled: bool,
+    }
+    impl PusScheduler {
+        /// Create a new PUS scheduler.
+        ///
+        /// # Arguments
+        ///
+        /// * `init_current_time` - The time to initialize the scheduler with.
+        /// * `time_margin` - This time margin is used when inserting new telecommands into the
+        ///      schedule. If the release time of a new telecommand is earlier than the time margin
+        ///      added to the current time, it will not be inserted into the schedule.
+        pub fn new(init_current_time: UnixTimestamp, time_margin: Duration) -> Self {
+            PusScheduler {
+                tc_map: Default::default(),
+                current_time: init_current_time,
+                time_margin,
+                enabled: true,
+            }
+        }
+
+        /// Like [Self::new], but sets the `init_current_time` parameter to the current system time.
+        #[cfg(feature = "std")]
+        #[cfg_attr(doc_cfg, doc(cfg(feature = "std")))]
+        pub fn new_with_current_init_time(time_margin: Duration) -> Result<Self, SystemTimeError> {
+            Ok(Self::new(UnixTimestamp::from_now()?, time_margin))
+        }
+
+        pub fn num_scheduled_telecommands(&self) -> u64 {
+            let mut num_entries = 0;
+            for entries in &self.tc_map {
+                num_entries += entries.1.len() as u64;
+            }
+            num_entries
+        }
+
+        pub fn is_enabled(&self) -> bool {
+            self.enabled
+        }
+
+        pub fn enable(&mut self) {
+            self.enabled = true;
+        }
+
+        /// A disabled scheduler should still delete commands where the execution time has been reached
+        /// but should not release them to be executed.
+        pub fn disable(&mut self) {
+            self.enabled = false;
+        }
+
+        /// This will disable the scheduler and clear the schedule as specified in 6.11.4.4.
+        /// Be careful with this command as it will delete all the commands in the schedule.
+        ///
+        /// The holding store for the telecommands needs to be passed so all the stored telecommands
+        /// can be deleted to avoid a memory leak. If at last one deletion operation fails, the error
+        /// will be returned but the method will still try to delete all the commands in the schedule.
+        pub fn reset(
+            &mut self,
+            store: &mut (impl PoolProvider + ?Sized),
+        ) -> Result<(), StoreError> {
+            self.enabled = false;
+            let mut deletion_ok = Ok(());
+            for tc_lists in &mut self.tc_map {
+                for tc in tc_lists.1 {
+                    let res = store.delete(tc.addr);
+                    if res.is_err() {
+                        deletion_ok = res;
+                    }
+                }
+            }
+            self.tc_map.clear();
+            deletion_ok
+        }
+
+        pub fn update_time(&mut self, current_time: UnixTimestamp) {
+            self.current_time = current_time;
+        }
+
+        pub fn current_time(&self) -> &UnixTimestamp {
+            &self.current_time
+        }
+
+        /// Insert a telecommand which was already unwrapped from the outer Service 11 packet and stored
+        /// inside the telecommand packet pool.
+        pub fn insert_unwrapped_and_stored_tc(
+            &mut self,
+            time_stamp: UnixTimestamp,
+            info: TcInfo,
+        ) -> Result<(), ScheduleError> {
+            if time_stamp < self.current_time + self.time_margin {
+                return Err(ScheduleError::ReleaseTimeInTimeMargin(
+                    self.current_time,
+                    self.time_margin,
+                    time_stamp,
+                ));
+            }
+            match self.tc_map.entry(time_stamp) {
+                Entry::Vacant(e) => {
+                    e.insert(vec![info]);
+                }
+                Entry::Occupied(mut v) => {
+                    v.get_mut().push(info);
+                }
+            }
+            Ok(())
+        }
+
+        /// Insert a telecommand which was already unwrapped from the outer Service 11 packet but still
+        /// needs to be stored inside the telecommand pool.
+        pub fn insert_unwrapped_tc(
+            &mut self,
+            time_stamp: UnixTimestamp,
+            tc: &[u8],
+            pool: &mut (impl PoolProvider + ?Sized),
+        ) -> Result<TcInfo, ScheduleError> {
+            let check_tc = PusTc::from_bytes(tc)?;
+            if PusPacket::service(&check_tc.0) == 11 && PusPacket::subservice(&check_tc.0) == 4 {
+                return Err(ScheduleError::NestedScheduledTc);
+            }
+            let req_id = RequestId::from_tc(&check_tc.0);
+
+            match pool.add(tc) {
+                Ok(addr) => {
+                    let info = TcInfo::new(addr, req_id);
+                    self.insert_unwrapped_and_stored_tc(time_stamp, info)?;
+                    Ok(info)
+                }
+                Err(err) => Err(err.into()),
+            }
+        }
+
+        /// Insert a telecommand based on the fully wrapped time-tagged telecommand. The timestamp
+        /// provider needs to be supplied via a generic.
+        pub fn insert_wrapped_tc<TimeStamp: CcsdsTimeProvider + TimeReader>(
+            &mut self,
+            pus_tc: &PusTc,
+            pool: &mut (impl PoolProvider + ?Sized),
+        ) -> Result<TcInfo, ScheduleError> {
+            if PusPacket::service(pus_tc) != 11 {
+                return Err(ScheduleError::WrongService);
+            }
+            if PusPacket::subservice(pus_tc) != 4 {
+                return Err(ScheduleError::WrongSubservice);
+            }
+            return if let Some(user_data) = pus_tc.user_data() {
+                let stamp: TimeStamp = TimeReader::from_bytes(user_data)?;
+                let unix_stamp = stamp.unix_stamp();
+                let stamp_len = stamp.len_as_bytes();
+                self.insert_unwrapped_tc(unix_stamp, &user_data[stamp_len..], pool)
+            } else {
+                Err(ScheduleError::TcDataEmpty)
+            };
+        }
+
+        /// Insert a telecommand based on the fully wrapped time-tagged telecommand using a CDS
+        /// short timestamp with 16-bit length of days field.
+        pub fn insert_wrapped_tc_cds_short(
+            &mut self,
+            pus_tc: &PusTc,
+            pool: &mut (impl PoolProvider + ?Sized),
+        ) -> Result<TcInfo, ScheduleError> {
+            self.insert_wrapped_tc::<cds::TimeProvider>(pus_tc, pool)
+        }
+
+        /// Insert a telecommand based on the fully wrapped time-tagged telecommand using a CDS
+        /// long timestamp with a 24-bit length of days field.
+        pub fn insert_wrapped_tc_cds_long(
+            &mut self,
+            pus_tc: &PusTc,
+            pool: &mut (impl PoolProvider + ?Sized),
+        ) -> Result<TcInfo, ScheduleError> {
+            self.insert_wrapped_tc::<cds::TimeProvider<DaysLen24Bits>>(pus_tc, pool)
+        }
+
+        /// This function uses [Self::retrieve_by_time_filter] to extract all scheduled commands inside
+        /// the time range and then deletes them from the provided store.
+        ///
+        /// Like specified in the documentation of [Self::retrieve_by_time_filter], the range extraction
+        /// for deletion is always inclusive.
+        ///
+        /// This function returns the number of deleted commands on success. In case any deletion fails,
+        /// the last deletion will be supplied in addition to the number of deleted commands.
+        pub fn delete_by_time_filter<TimeProvider: CcsdsTimeProvider + Clone>(
+            &mut self,
+            time_window: TimeWindow<TimeProvider>,
+            pool: &mut (impl PoolProvider + ?Sized),
+        ) -> Result<u64, (u64, StoreError)> {
+            let range = self.retrieve_by_time_filter(time_window);
+            let mut del_packets = 0;
+            let mut res_if_fails = None;
+            let mut keys_to_delete = Vec::new();
+            for time_bucket in range {
+                for tc in time_bucket.1 {
+                    match pool.delete(tc.addr) {
+                        Ok(_) => del_packets += 1,
+                        Err(e) => res_if_fails = Some(e),
+                    }
+                }
+                keys_to_delete.push(*time_bucket.0);
+            }
+            for key in keys_to_delete {
+                self.tc_map.remove(&key);
+            }
+            if let Some(err) = res_if_fails {
+                return Err((del_packets, err));
+            }
+            Ok(del_packets)
+        }
+
+        /// Deletes all the scheduled commands. This also deletes the packets from the passed TC pool.
+        ///
+        /// This function returns the number of deleted commands on success. In case any deletion fails,
+        /// the last deletion will be supplied in addition to the number of deleted commands.
+        pub fn delete_all(
+            &mut self,
+            pool: &mut (impl PoolProvider + ?Sized),
+        ) -> Result<u64, (u64, StoreError)> {
+            self.delete_by_time_filter(TimeWindow::<cds::TimeProvider>::new_select_all(), pool)
+        }
+
+        /// Retrieve a range over all scheduled commands.
+        pub fn retrieve_all(&mut self) -> Range<'_, UnixTimestamp, Vec<TcInfo>> {
+            self.tc_map.range(..)
+        }
+
+        /// This retrieves scheduled telecommands which are inside the provided time window.
+        ///
+        /// It should be noted that the ranged extraction is always inclusive. For example, a range
+        /// from 50 to 100 unix seconds would also include command scheduled at 100 unix seconds.
+        pub fn retrieve_by_time_filter<TimeProvider: CcsdsTimeProvider>(
+            &mut self,
+            time_window: TimeWindow<TimeProvider>,
+        ) -> Range<'_, UnixTimestamp, Vec<TcInfo>> {
+            match time_window.time_window_type() {
+                TimeWindowType::SelectAll => self.tc_map.range(..),
+                TimeWindowType::TimeTagToTimeTag => {
+                    // This should be guaranteed to be valid by library API, so unwrap is okay
+                    let start_time = time_window.start_time().unwrap().unix_stamp();
+                    let end_time = time_window.end_time().unwrap().unix_stamp();
+                    self.tc_map.range(start_time..=end_time)
+                }
+                TimeWindowType::FromTimeTag => {
+                    // This should be guaranteed to be valid by library API, so unwrap is okay
+                    let start_time = time_window.start_time().unwrap().unix_stamp();
+                    self.tc_map.range(start_time..)
+                }
+                TimeWindowType::ToTimeTag => {
+                    // This should be guaranteed to be valid by library API, so unwrap is okay
+                    let end_time = time_window.end_time().unwrap().unix_stamp();
+                    self.tc_map.range(..=end_time)
+                }
+            }
+        }
+
+        /// Deletes a scheduled command with the given request  ID. Returns the store address if a
+        /// scheduled command was found in the map and deleted, and None otherwise.
+        ///
+        /// Please note that this function will stop on the first telecommand with a request ID match.
+        /// In case of duplicate IDs (which should generally not happen), this function needs to be
+        /// called repeatedly.
+        pub fn delete_by_request_id(&mut self, req_id: &RequestId) -> Option<StoreAddr> {
+            if let DeletionResult::WithoutStoreDeletion(v) =
+                self.delete_by_request_id_internal(req_id, None::<&mut dyn PoolProvider>)
+            {
+                return v;
+            }
+            panic!("unexpected deletion result");
+        }
+
+        /// This behaves like [Self::delete_by_request_id] but deletes the packet from the pool as well.
+        pub fn delete_by_request_id_and_from_pool(
+            &mut self,
+            req_id: &RequestId,
+            pool: &mut (impl PoolProvider + ?Sized),
+        ) -> Result<bool, StoreError> {
+            if let DeletionResult::WithStoreDeletion(v) =
+                self.delete_by_request_id_internal(req_id, Some(pool))
+            {
+                return v;
+            }
+            panic!("unexpected deletion result");
+        }
+
+        fn delete_by_request_id_internal(
+            &mut self,
+            req_id: &RequestId,
+            pool: Option<&mut (impl PoolProvider + ?Sized)>,
+        ) -> DeletionResult {
+            let mut idx_found = None;
+            for time_bucket in &mut self.tc_map {
+                for (idx, tc_info) in time_bucket.1.iter().enumerate() {
+                    if &tc_info.request_id == req_id {
+                        idx_found = Some(idx);
+                    }
+                }
+                if let Some(idx) = idx_found {
+                    let addr = time_bucket.1.remove(idx).addr;
+                    if let Some(pool) = pool {
+                        return match pool.delete(addr) {
+                            Ok(_) => DeletionResult::WithStoreDeletion(Ok(true)),
+                            Err(e) => DeletionResult::WithStoreDeletion(Err(e)),
+                        };
+                    }
+                    return DeletionResult::WithoutStoreDeletion(Some(addr));
+                }
+            }
+            if pool.is_none() {
+                DeletionResult::WithoutStoreDeletion(None)
+            } else {
+                DeletionResult::WithStoreDeletion(Ok(false))
+            }
+        }
+        /// Retrieve all telecommands which should be release based on the current time.
+        pub fn telecommands_to_release(&self) -> Range<'_, UnixTimestamp, Vec<TcInfo>> {
+            self.tc_map.range(..=self.current_time)
+        }
+
+        #[cfg(feature = "std")]
+        #[cfg_attr(doc_cfg, doc(cfg(feature = "std")))]
+        pub fn update_time_from_now(&mut self) -> Result<(), SystemTimeError> {
+            self.current_time = UnixTimestamp::from_now()?;
+            Ok(())
+        }
+
+        /// Utility method which calls [Self::telecommands_to_release] and then calls a releaser
+        /// closure for each telecommand which should be released. This function will also delete
+        /// the telecommands from the holding store after calling the release closure, if the scheduler
+        /// is disabled.
+        ///
+        /// # Arguments
+        ///
+        /// * `releaser` - Closure where the first argument is whether the scheduler is enabled and
+        ///     the second argument is the telecommand information also containing the store address.
+        ///     This closure should return whether the command should be deleted if the scheduler is
+        ///     disabled to prevent memory leaks.
+        /// * `store` - The holding store of the telecommands.
+        pub fn release_telecommands<R: FnMut(bool, &TcInfo) -> bool>(
+            &mut self,
+            mut releaser: R,
+            tc_store: &mut (impl PoolProvider + ?Sized),
+        ) -> Result<u64, (u64, StoreError)> {
+            let tcs_to_release = self.telecommands_to_release();
+            let mut released_tcs = 0;
+            let mut store_error = Ok(());
+            for tc in tcs_to_release {
+                for info in tc.1 {
+                    let should_delete = releaser(self.enabled, info);
+                    released_tcs += 1;
+                    if should_delete && !self.is_enabled() {
+                        let res = tc_store.delete(info.addr);
+                        if res.is_err() {
+                            store_error = res;
+                        }
+                    }
+                }
+            }
+            self.tc_map.retain(|k, _| k > &self.current_time);
+            store_error
+                .map(|_| released_tcs)
+                .map_err(|e| (released_tcs, e))
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::pool::{LocalPool, PoolCfg, PoolProvider, StoreAddr, StoreError};
+    use alloc::collections::btree_map::Range;
+    use spacepackets::ecss::SerializablePusPacket;
+    use spacepackets::tc::{PusTc, PusTcSecondaryHeader};
+    use spacepackets::time::{cds, TimeWriter, UnixTimestamp};
+    use spacepackets::SpHeader;
+    use std::time::Duration;
+    use std::vec::Vec;
+    #[allow(unused_imports)]
+    use std::{println, vec};
+
+    fn pus_tc_base(timestamp: UnixTimestamp, buf: &mut [u8]) -> (SpHeader, usize) {
+        let cds_time = cds::TimeProvider::from_unix_secs_with_u16_days(&timestamp).unwrap();
+        let len_time_stamp = cds_time.write_to_bytes(buf).unwrap();
+        let len_packet = base_ping_tc_simple_ctor(0, None)
+            .write_to_bytes(&mut buf[len_time_stamp..])
+            .unwrap();
+        (
+            SpHeader::tc_unseg(0x02, 0x34, len_packet as u16).unwrap(),
+            len_packet + len_time_stamp,
+        )
+    }
+
+    fn scheduled_tc(timestamp: UnixTimestamp, buf: &mut [u8]) -> PusTc {
+        let (mut sph, len_app_data) = pus_tc_base(timestamp, buf);
+        PusTc::new_simple(&mut sph, 11, 4, Some(&buf[..len_app_data]), true)
+    }
+
+    fn wrong_tc_service(timestamp: UnixTimestamp, buf: &mut [u8]) -> PusTc {
+        let (mut sph, len_app_data) = pus_tc_base(timestamp, buf);
+        PusTc::new_simple(&mut sph, 12, 4, Some(&buf[..len_app_data]), true)
+    }
+
+    fn wrong_tc_subservice(timestamp: UnixTimestamp, buf: &mut [u8]) -> PusTc {
+        let (mut sph, len_app_data) = pus_tc_base(timestamp, buf);
+        PusTc::new_simple(&mut sph, 11, 5, Some(&buf[..len_app_data]), true)
+    }
+
+    fn double_wrapped_time_tagged_tc(timestamp: UnixTimestamp, buf: &mut [u8]) -> PusTc {
+        let cds_time = cds::TimeProvider::from_unix_secs_with_u16_days(&timestamp).unwrap();
+        let len_time_stamp = cds_time.write_to_bytes(buf).unwrap();
+        let mut sph = SpHeader::tc_unseg(0x02, 0x34, 0).unwrap();
+        // app data should not matter, double wrapped time-tagged commands should be rejected right
+        // away
+        let inner_time_tagged_tc = PusTc::new_simple(&mut sph, 11, 4, None, true);
+        let packet_len = inner_time_tagged_tc
+            .write_to_bytes(&mut buf[len_time_stamp..])
+            .expect("writing inner time tagged tc failed");
+        PusTc::new_simple(
+            &mut sph,
+            11,
+            4,
+            Some(&buf[..len_time_stamp + packet_len]),
+            true,
+        )
+    }
+
+    fn invalid_time_tagged_cmd() -> PusTc<'static> {
+        let mut sph = SpHeader::tc_unseg(0x02, 0x34, 1).unwrap();
+        PusTc::new_simple(&mut sph, 11, 4, None, true)
+    }
+
+    fn base_ping_tc_simple_ctor(seq_count: u16, app_data: Option<&'static [u8]>) -> PusTc<'static> {
+        let mut sph = SpHeader::tc_unseg(0x02, seq_count, 0).unwrap();
+        PusTc::new_simple(&mut sph, 17, 1, app_data, true)
+    }
+
+    fn ping_tc_to_store(
+        pool: &mut LocalPool,
+        buf: &mut [u8],
+        seq_count: u16,
+        app_data: Option<&'static [u8]>,
+    ) -> TcInfo {
+        let ping_tc = base_ping_tc_simple_ctor(seq_count, app_data);
+        let ping_size = ping_tc.write_to_bytes(buf).expect("writing ping TC failed");
+        let first_addr = pool.add(&buf[0..ping_size]).unwrap();
+        TcInfo::new(first_addr, RequestId::from_tc(&ping_tc))
+    }
+
+    #[test]
+    fn basic() {
+        let mut scheduler =
+            PusScheduler::new(UnixTimestamp::new_only_seconds(0), Duration::from_secs(5));
+        assert!(scheduler.is_enabled());
+        scheduler.disable();
+        assert!(!scheduler.is_enabled());
+        scheduler.enable();
+        assert!(scheduler.is_enabled());
+    }
+
+    #[test]
+    fn reset() {
+        let mut pool = LocalPool::new(PoolCfg::new(vec![(10, 32), (5, 64)]));
+        let mut scheduler =
+            PusScheduler::new(UnixTimestamp::new_only_seconds(0), Duration::from_secs(5));
+
+        let mut buf: [u8; 32] = [0; 32];
+        let tc_info_0 = ping_tc_to_store(&mut pool, &mut buf, 0, None);
+
+        scheduler
+            .insert_unwrapped_and_stored_tc(
+                UnixTimestamp::new_only_seconds(100),
+                TcInfo::new(tc_info_0.addr.clone(), tc_info_0.request_id),
+            )
+            .unwrap();
+
+        let app_data = &[0, 1, 2];
+        let tc_info_1 = ping_tc_to_store(&mut pool, &mut buf, 1, Some(app_data));
+        scheduler
+            .insert_unwrapped_and_stored_tc(
+                UnixTimestamp::new_only_seconds(200),
+                TcInfo::new(tc_info_1.addr.clone(), tc_info_1.request_id),
+            )
+            .unwrap();
+
+        let app_data = &[0, 1, 2];
+        let tc_info_2 = ping_tc_to_store(&mut pool, &mut buf, 2, Some(app_data));
+        scheduler
+            .insert_unwrapped_and_stored_tc(
+                UnixTimestamp::new_only_seconds(300),
+                TcInfo::new(tc_info_2.addr().clone(), tc_info_2.request_id()),
+            )
+            .unwrap();
+
+        assert_eq!(scheduler.num_scheduled_telecommands(), 3);
+        assert!(scheduler.is_enabled());
+        scheduler.reset(&mut pool).expect("deletion of TCs failed");
+        assert!(!scheduler.is_enabled());
+        assert_eq!(scheduler.num_scheduled_telecommands(), 0);
+        assert!(!pool.has_element_at(&tc_info_0.addr()).unwrap());
+        assert!(!pool.has_element_at(&tc_info_1.addr()).unwrap());
+        assert!(!pool.has_element_at(&tc_info_2.addr()).unwrap());
+    }
+
+    #[test]
+    fn insert_multi_with_same_time() {
+        let mut scheduler =
+            PusScheduler::new(UnixTimestamp::new_only_seconds(0), Duration::from_secs(5));
+
+        scheduler
+            .insert_unwrapped_and_stored_tc(
+                UnixTimestamp::new_only_seconds(100),
+                TcInfo::new(
+                    StoreAddr {
+                        pool_idx: 0,
+                        packet_idx: 1,
+                    },
+                    RequestId {
+                        seq_count: 1,
+                        apid: 0,
+                        source_id: 0,
+                    },
+                ),
+            )
+            .unwrap();
+
+        scheduler
+            .insert_unwrapped_and_stored_tc(
+                UnixTimestamp::new_only_seconds(100),
+                TcInfo::new(
+                    StoreAddr {
+                        pool_idx: 0,
+                        packet_idx: 2,
+                    },
+                    RequestId {
+                        seq_count: 2,
+                        apid: 1,
+                        source_id: 5,
+                    },
+                ),
+            )
+            .unwrap();
+
+        scheduler
+            .insert_unwrapped_and_stored_tc(
+                UnixTimestamp::new_only_seconds(300),
+                TcInfo::new(
+                    StoreAddr {
+                        pool_idx: 0,
+                        packet_idx: 2,
+                    },
+                    RequestId {
+                        source_id: 10,
+                        seq_count: 20,
+                        apid: 23,
+                    },
+                ),
+            )
+            .unwrap();
+
+        assert_eq!(scheduler.num_scheduled_telecommands(), 3);
+    }
+
+    #[test]
+    fn time() {
+        let mut scheduler =
+            PusScheduler::new(UnixTimestamp::new_only_seconds(0), Duration::from_secs(5));
+        let time = UnixTimestamp::new(1, 2).unwrap();
+        scheduler.update_time(time);
+        assert_eq!(scheduler.current_time(), &time);
+    }
+
+    fn common_check(
+        enabled: bool,
+        store_addr: &StoreAddr,
+        expected_store_addrs: Vec<StoreAddr>,
+        counter: &mut usize,
+    ) {
+        assert_eq!(enabled, true);
+        assert!(expected_store_addrs.contains(store_addr));
+        *counter += 1;
+    }
+    fn common_check_disabled(
+        enabled: bool,
+        store_addr: &StoreAddr,
+        expected_store_addrs: Vec<StoreAddr>,
+        counter: &mut usize,
+    ) {
+        assert_eq!(enabled, false);
+        assert!(expected_store_addrs.contains(store_addr));
+        *counter += 1;
+    }
+
+    #[test]
+    fn request_id() {
+        let src_id_to_set = 12;
+        let apid_to_set = 0x22;
+        let seq_count = 105;
+        let mut sp_header = SpHeader::tc_unseg(apid_to_set, 105, 0).unwrap();
+        let mut sec_header = PusTcSecondaryHeader::new_simple(17, 1);
+        sec_header.source_id = src_id_to_set;
+        let ping_tc = PusTc::new(&mut sp_header, sec_header, None, true);
+        let req_id = RequestId::from_tc(&ping_tc);
+        assert_eq!(req_id.source_id(), src_id_to_set);
+        assert_eq!(req_id.apid(), apid_to_set);
+        assert_eq!(req_id.seq_count(), seq_count);
+        assert_eq!(
+            req_id.as_u64(),
+            ((src_id_to_set as u64) << 32) | (apid_to_set as u64) << 16 | seq_count as u64
+        );
+    }
+    #[test]
+    fn release_basic() {
+        let mut pool = LocalPool::new(PoolCfg::new(vec![(10, 32), (5, 64)]));
+        let mut scheduler =
+            PusScheduler::new(UnixTimestamp::new_only_seconds(0), Duration::from_secs(5));
+
+        let mut buf: [u8; 32] = [0; 32];
+        let tc_info_0 = ping_tc_to_store(&mut pool, &mut buf, 0, None);
+
+        scheduler
+            .insert_unwrapped_and_stored_tc(UnixTimestamp::new_only_seconds(100), tc_info_0)
+            .expect("insertion failed");
+
+        let tc_info_1 = ping_tc_to_store(&mut pool, &mut buf, 1, None);
+        scheduler
+            .insert_unwrapped_and_stored_tc(UnixTimestamp::new_only_seconds(200), tc_info_1)
+            .expect("insertion failed");
+
+        let mut i = 0;
+        let mut test_closure_1 = |boolvar: bool, tc_info: &TcInfo| {
+            common_check(boolvar, &tc_info.addr, vec![tc_info_0.addr()], &mut i);
+            true
+        };
+
+        // test 1: too early, no tcs
+        scheduler.update_time(UnixTimestamp::new_only_seconds(99));
+
+        scheduler
+            .release_telecommands(&mut test_closure_1, &mut pool)
+            .expect("deletion failed");
+
+        // test 2: exact time stamp of tc, releases 1 tc
+        scheduler.update_time(UnixTimestamp::new_only_seconds(100));
+
+        let mut released = scheduler
+            .release_telecommands(&mut test_closure_1, &mut pool)
+            .expect("deletion failed");
+        assert_eq!(released, 1);
+        assert!(pool.has_element_at(&tc_info_0.addr()).unwrap());
+
+        // test 3, late timestamp, release 1 overdue tc
+        let mut test_closure_2 = |boolvar: bool, tc_info: &TcInfo| {
+            common_check(boolvar, &tc_info.addr, vec![tc_info_1.addr()], &mut i);
+            true
+        };
+
+        scheduler.update_time(UnixTimestamp::new_only_seconds(206));
+
+        released = scheduler
+            .release_telecommands(&mut test_closure_2, &mut pool)
+            .expect("deletion failed");
+        assert_eq!(released, 1);
+        assert!(pool.has_element_at(&tc_info_1.addr()).unwrap());
+
+        //test 4: no tcs left
+        scheduler
+            .release_telecommands(&mut test_closure_2, &mut pool)
+            .expect("deletion failed");
+
+        // check that 2 total tcs have been released
+        assert_eq!(i, 2);
+    }
+
+    #[test]
+    fn release_multi_with_same_time() {
+        let mut pool = LocalPool::new(PoolCfg::new(vec![(10, 32), (5, 64)]));
+        let mut scheduler =
+            PusScheduler::new(UnixTimestamp::new_only_seconds(0), Duration::from_secs(5));
+
+        let mut buf: [u8; 32] = [0; 32];
+        let tc_info_0 = ping_tc_to_store(&mut pool, &mut buf, 0, None);
+
+        scheduler
+            .insert_unwrapped_and_stored_tc(UnixTimestamp::new_only_seconds(100), tc_info_0)
+            .expect("insertion failed");
+
+        let tc_info_1 = ping_tc_to_store(&mut pool, &mut buf, 1, None);
+        scheduler
+            .insert_unwrapped_and_stored_tc(UnixTimestamp::new_only_seconds(100), tc_info_1)
+            .expect("insertion failed");
+
+        let mut i = 0;
+        let mut test_closure = |boolvar: bool, store_addr: &TcInfo| {
+            common_check(
+                boolvar,
+                &store_addr.addr,
+                vec![tc_info_0.addr(), tc_info_1.addr()],
+                &mut i,
+            );
+            true
+        };
+
+        // test 1: too early, no tcs
+        scheduler.update_time(UnixTimestamp::new_only_seconds(99));
+
+        let mut released = scheduler
+            .release_telecommands(&mut test_closure, &mut pool)
+            .expect("deletion failed");
+        assert_eq!(released, 0);
+
+        // test 2: exact time stamp of tc, releases 2 tc
+        scheduler.update_time(UnixTimestamp::new_only_seconds(100));
+
+        released = scheduler
+            .release_telecommands(&mut test_closure, &mut pool)
+            .expect("deletion failed");
+        assert_eq!(released, 2);
+        assert!(pool.has_element_at(&tc_info_0.addr()).unwrap());
+        assert!(pool.has_element_at(&tc_info_1.addr()).unwrap());
+
+        //test 3: no tcs left
+        released = scheduler
+            .release_telecommands(&mut test_closure, &mut pool)
+            .expect("deletion failed");
+        assert_eq!(released, 0);
+
+        // check that 2 total tcs have been released
+        assert_eq!(i, 2);
+    }
+
+    #[test]
+    fn release_with_scheduler_disabled() {
+        let mut pool = LocalPool::new(PoolCfg::new(vec![(10, 32), (5, 64)]));
+        let mut scheduler =
+            PusScheduler::new(UnixTimestamp::new_only_seconds(0), Duration::from_secs(5));
+
+        scheduler.disable();
+
+        let mut buf: [u8; 32] = [0; 32];
+        let tc_info_0 = ping_tc_to_store(&mut pool, &mut buf, 0, None);
+
+        scheduler
+            .insert_unwrapped_and_stored_tc(UnixTimestamp::new_only_seconds(100), tc_info_0)
+            .expect("insertion failed");
+
+        let tc_info_1 = ping_tc_to_store(&mut pool, &mut buf, 1, None);
+        scheduler
+            .insert_unwrapped_and_stored_tc(UnixTimestamp::new_only_seconds(200), tc_info_1)
+            .expect("insertion failed");
+
+        let mut i = 0;
+        let mut test_closure_1 = |boolvar: bool, tc_info: &TcInfo| {
+            common_check_disabled(boolvar, &tc_info.addr, vec![tc_info_0.addr()], &mut i);
+            true
+        };
+
+        // test 1: too early, no tcs
+        scheduler.update_time(UnixTimestamp::new_only_seconds(99));
+
+        scheduler
+            .release_telecommands(&mut test_closure_1, &mut pool)
+            .expect("deletion failed");
+
+        // test 2: exact time stamp of tc, releases 1 tc
+        scheduler.update_time(UnixTimestamp::new_only_seconds(100));
+
+        let mut released = scheduler
+            .release_telecommands(&mut test_closure_1, &mut pool)
+            .expect("deletion failed");
+        assert_eq!(released, 1);
+        assert!(!pool.has_element_at(&tc_info_0.addr()).unwrap());
+
+        // test 3, late timestamp, release 1 overdue tc
+        let mut test_closure_2 = |boolvar: bool, tc_info: &TcInfo| {
+            common_check_disabled(boolvar, &tc_info.addr, vec![tc_info_1.addr()], &mut i);
+            true
+        };
+
+        scheduler.update_time(UnixTimestamp::new_only_seconds(206));
+
+        released = scheduler
+            .release_telecommands(&mut test_closure_2, &mut pool)
+            .expect("deletion failed");
+        assert_eq!(released, 1);
+        assert!(!pool.has_element_at(&tc_info_1.addr()).unwrap());
+
+        //test 4: no tcs left
+        scheduler
+            .release_telecommands(&mut test_closure_2, &mut pool)
+            .expect("deletion failed");
+
+        // check that 2 total tcs have been released
+        assert_eq!(i, 2);
+    }
+
+    #[test]
+    fn insert_unwrapped_tc() {
+        let mut scheduler =
+            PusScheduler::new(UnixTimestamp::new_only_seconds(0), Duration::from_secs(5));
+
+        let mut pool = LocalPool::new(PoolCfg::new(vec![(10, 32), (5, 64)]));
+        let mut buf: [u8; 32] = [0; 32];
+        let tc_info_0 = ping_tc_to_store(&mut pool, &mut buf, 0, None);
+
+        let info = scheduler
+            .insert_unwrapped_tc(
+                UnixTimestamp::new_only_seconds(100),
+                &buf[..pool.len_of_data(&tc_info_0.addr()).unwrap()],
+                &mut pool,
+            )
+            .unwrap();
+
+        assert!(pool.has_element_at(&tc_info_0.addr()).unwrap());
+
+        let data = pool.read(&tc_info_0.addr()).unwrap();
+        let check_tc = PusTc::from_bytes(&data).expect("incorrect Pus tc raw data");
+        assert_eq!(check_tc.0, base_ping_tc_simple_ctor(0, None));
+
+        assert_eq!(scheduler.num_scheduled_telecommands(), 1);
+
+        scheduler.update_time(UnixTimestamp::new_only_seconds(101));
+
+        let mut addr_vec = Vec::new();
+
+        let mut i = 0;
+        let mut test_closure = |boolvar: bool, tc_info: &TcInfo| {
+            common_check(boolvar, &tc_info.addr, vec![info.addr], &mut i);
+            // check that tc remains unchanged
+            addr_vec.push(tc_info.addr);
+            false
+        };
+
+        scheduler
+            .release_telecommands(&mut test_closure, &mut pool)
+            .unwrap();
+
+        let data = pool.read(&addr_vec[0]).unwrap();
+        let check_tc = PusTc::from_bytes(&data).expect("incorrect Pus tc raw data");
+        assert_eq!(check_tc.0, base_ping_tc_simple_ctor(0, None));
+    }
+
+    #[test]
+    fn insert_wrapped_tc() {
+        let mut scheduler =
+            PusScheduler::new(UnixTimestamp::new_only_seconds(0), Duration::from_secs(5));
+
+        let mut pool = LocalPool::new(PoolCfg::new(vec![(10, 32), (5, 64)]));
+
+        let mut buf: [u8; 32] = [0; 32];
+        let tc = scheduled_tc(UnixTimestamp::new_only_seconds(100), &mut buf);
+
+        let info = match scheduler.insert_wrapped_tc::<cds::TimeProvider>(&tc, &mut pool) {
+            Ok(addr) => addr,
+            Err(e) => {
+                panic!("unexpected error {e}");
+            }
+        };
+
+        assert!(pool.has_element_at(&info.addr).unwrap());
+
+        let data = pool.read(&info.addr).unwrap();
+        let check_tc = PusTc::from_bytes(&data).expect("incorrect Pus tc raw data");
+        assert_eq!(check_tc.0, base_ping_tc_simple_ctor(0, None));
+
+        assert_eq!(scheduler.num_scheduled_telecommands(), 1);
+
+        scheduler.update_time(UnixTimestamp::new_only_seconds(101));
+
+        let mut addr_vec = Vec::new();
+
+        let mut i = 0;
+        let mut test_closure = |boolvar: bool, tc_info: &TcInfo| {
+            common_check(boolvar, &tc_info.addr, vec![info.addr], &mut i);
+            // check that tc remains unchanged
+            addr_vec.push(tc_info.addr);
+            false
+        };
+
+        scheduler
+            .release_telecommands(&mut test_closure, &mut pool)
+            .unwrap();
+
+        let data = pool.read(&addr_vec[0]).unwrap();
+        let check_tc = PusTc::from_bytes(&data).expect("incorrect Pus tc raw data");
+        assert_eq!(check_tc.0, base_ping_tc_simple_ctor(0, None));
+    }
+
+    #[test]
+    fn insert_wrong_service() {
+        let mut scheduler =
+            PusScheduler::new(UnixTimestamp::new_only_seconds(0), Duration::from_secs(5));
+
+        let mut pool = LocalPool::new(PoolCfg::new(vec![(10, 32), (5, 64)]));
+
+        let mut buf: [u8; 32] = [0; 32];
+        let tc = wrong_tc_service(UnixTimestamp::new_only_seconds(100), &mut buf);
+
+        let err = scheduler.insert_wrapped_tc::<cds::TimeProvider>(&tc, &mut pool);
+        assert!(err.is_err());
+        let err = err.unwrap_err();
+        match err {
+            ScheduleError::WrongService => {}
+            _ => {
+                panic!("unexpected error")
+            }
+        }
+    }
+
+    #[test]
+    fn insert_wrong_subservice() {
+        let mut scheduler =
+            PusScheduler::new(UnixTimestamp::new_only_seconds(0), Duration::from_secs(5));
+
+        let mut pool = LocalPool::new(PoolCfg::new(vec![(10, 32), (5, 64)]));
+
+        let mut buf: [u8; 32] = [0; 32];
+        let tc = wrong_tc_subservice(UnixTimestamp::new_only_seconds(100), &mut buf);
+
+        let err = scheduler.insert_wrapped_tc::<cds::TimeProvider>(&tc, &mut pool);
+        assert!(err.is_err());
+        let err = err.unwrap_err();
+        match err {
+            ScheduleError::WrongSubservice => {}
+            _ => {
+                panic!("unexpected error")
+            }
+        }
+    }
+
+    #[test]
+    fn insert_wrapped_tc_faulty_app_data() {
+        let mut scheduler =
+            PusScheduler::new(UnixTimestamp::new_only_seconds(0), Duration::from_secs(5));
+        let mut pool = LocalPool::new(PoolCfg::new(vec![(10, 32), (5, 64)]));
+        let tc = invalid_time_tagged_cmd();
+        let insert_res = scheduler.insert_wrapped_tc::<cds::TimeProvider>(&tc, &mut pool);
+        assert!(insert_res.is_err());
+        let err = insert_res.unwrap_err();
+        match err {
+            ScheduleError::TcDataEmpty => {}
+            _ => panic!("unexpected error {err}"),
+        }
+    }
+
+    #[test]
+    fn insert_doubly_wrapped_time_tagged_cmd() {
+        let mut scheduler =
+            PusScheduler::new(UnixTimestamp::new_only_seconds(0), Duration::from_secs(5));
+        let mut pool = LocalPool::new(PoolCfg::new(vec![(10, 32), (5, 64)]));
+        let mut buf: [u8; 64] = [0; 64];
+        let tc = double_wrapped_time_tagged_tc(UnixTimestamp::new_only_seconds(50), &mut buf);
+        let insert_res = scheduler.insert_wrapped_tc::<cds::TimeProvider>(&tc, &mut pool);
+        assert!(insert_res.is_err());
+        let err = insert_res.unwrap_err();
+        match err {
+            ScheduleError::NestedScheduledTc => {}
+            _ => panic!("unexpected error {err}"),
+        }
+    }
+
+    #[test]
+    fn test_ctor_from_current() {
+        let scheduler = PusScheduler::new_with_current_init_time(Duration::from_secs(5))
+            .expect("creation from current time failed");
+        let current_time = scheduler.current_time;
+        assert!(current_time.unix_seconds > 0);
+    }
+
+    #[test]
+    fn test_update_from_current() {
+        let mut scheduler =
+            PusScheduler::new(UnixTimestamp::new_only_seconds(0), Duration::from_secs(5));
+        assert_eq!(scheduler.current_time.unix_seconds, 0);
+        scheduler
+            .update_time_from_now()
+            .expect("updating scheduler time from now failed");
+        assert!(scheduler.current_time.unix_seconds > 0);
+    }
+
+    #[test]
+    fn release_time_within_time_margin() {
+        let mut scheduler =
+            PusScheduler::new(UnixTimestamp::new_only_seconds(0), Duration::from_secs(5));
+
+        let mut pool = LocalPool::new(PoolCfg::new(vec![(10, 32), (5, 64)]));
+
+        let mut buf: [u8; 32] = [0; 32];
+
+        let tc = scheduled_tc(UnixTimestamp::new_only_seconds(4), &mut buf);
+        let insert_res = scheduler.insert_wrapped_tc::<cds::TimeProvider>(&tc, &mut pool);
+        assert!(insert_res.is_err());
+        let err = insert_res.unwrap_err();
+        match err {
+            ScheduleError::ReleaseTimeInTimeMargin(curr_time, margin, release_time) => {
+                assert_eq!(curr_time, UnixTimestamp::new_only_seconds(0));
+                assert_eq!(margin, Duration::from_secs(5));
+                assert_eq!(release_time, UnixTimestamp::new_only_seconds(4));
+            }
+            _ => panic!("unexepcted error {err}"),
+        }
+    }
+
+    #[test]
+    fn test_store_error_propagation_release() {
+        let mut pool = LocalPool::new(PoolCfg::new(vec![(10, 32), (5, 64)]));
+        let mut scheduler =
+            PusScheduler::new(UnixTimestamp::new_only_seconds(0), Duration::from_secs(5));
+        let mut buf: [u8; 32] = [0; 32];
+        let tc_info_0 = ping_tc_to_store(&mut pool, &mut buf, 0, None);
+        scheduler
+            .insert_unwrapped_and_stored_tc(UnixTimestamp::new_only_seconds(100), tc_info_0)
+            .expect("insertion failed");
+
+        let mut i = 0;
+        let test_closure_1 = |boolvar: bool, tc_info: &TcInfo| {
+            common_check_disabled(boolvar, &tc_info.addr, vec![tc_info_0.addr()], &mut i);
+            true
+        };
+
+        // premature deletion
+        pool.delete(tc_info_0.addr()).expect("deletion failed");
+        // scheduler will only auto-delete if it is disabled.
+        scheduler.disable();
+        scheduler.update_time(UnixTimestamp::new_only_seconds(100));
+        let release_res = scheduler.release_telecommands(test_closure_1, &mut pool);
+        assert!(release_res.is_err());
+        let err = release_res.unwrap_err();
+        assert_eq!(err.0, 1);
+        match err.1 {
+            StoreError::DataDoesNotExist(addr) => {
+                assert_eq!(tc_info_0.addr(), addr);
+            }
+            _ => panic!("unexpected error {}", err.1),
+        }
+    }
+
+    #[test]
+    fn test_store_error_propagation_reset() {
+        let mut pool = LocalPool::new(PoolCfg::new(vec![(10, 32), (5, 64)]));
+        let mut scheduler =
+            PusScheduler::new(UnixTimestamp::new_only_seconds(0), Duration::from_secs(5));
+        let mut buf: [u8; 32] = [0; 32];
+        let tc_info_0 = ping_tc_to_store(&mut pool, &mut buf, 0, None);
+        scheduler
+            .insert_unwrapped_and_stored_tc(UnixTimestamp::new_only_seconds(100), tc_info_0)
+            .expect("insertion failed");
+
+        // premature deletion
+        pool.delete(tc_info_0.addr()).expect("deletion failed");
+        let reset_res = scheduler.reset(&mut pool);
+        assert!(reset_res.is_err());
+        let err = reset_res.unwrap_err();
+        match err {
+            StoreError::DataDoesNotExist(addr) => {
+                assert_eq!(addr, tc_info_0.addr());
+            }
+            _ => panic!("unexpected error {err}"),
+        }
+    }
+
+    #[test]
+    fn test_delete_by_req_id_simple_retrieve_addr() {
+        let mut pool = LocalPool::new(PoolCfg::new(vec![(10, 32), (5, 64)]));
+        let mut scheduler =
+            PusScheduler::new(UnixTimestamp::new_only_seconds(0), Duration::from_secs(5));
+        let mut buf: [u8; 32] = [0; 32];
+        let tc_info_0 = ping_tc_to_store(&mut pool, &mut buf, 0, None);
+        scheduler
+            .insert_unwrapped_and_stored_tc(UnixTimestamp::new_only_seconds(100), tc_info_0)
+            .expect("inserting tc failed");
+        assert_eq!(scheduler.num_scheduled_telecommands(), 1);
+        let addr = scheduler
+            .delete_by_request_id(&tc_info_0.request_id())
+            .unwrap();
+        assert!(pool.has_element_at(&tc_info_0.addr()).unwrap());
+        assert_eq!(tc_info_0.addr(), addr);
+        assert_eq!(scheduler.num_scheduled_telecommands(), 0);
+    }
+
+    #[test]
+    fn test_delete_by_req_id_simple_delete_all() {
+        let mut pool = LocalPool::new(PoolCfg::new(vec![(10, 32), (5, 64)]));
+        let mut scheduler =
+            PusScheduler::new(UnixTimestamp::new_only_seconds(0), Duration::from_secs(5));
+        let mut buf: [u8; 32] = [0; 32];
+        let tc_info_0 = ping_tc_to_store(&mut pool, &mut buf, 0, None);
+        scheduler
+            .insert_unwrapped_and_stored_tc(UnixTimestamp::new_only_seconds(100), tc_info_0)
+            .expect("inserting tc failed");
+        assert_eq!(scheduler.num_scheduled_telecommands(), 1);
+        let del_res =
+            scheduler.delete_by_request_id_and_from_pool(&tc_info_0.request_id(), &mut pool);
+        assert!(del_res.is_ok());
+        assert_eq!(del_res.unwrap(), true);
+        assert!(!pool.has_element_at(&tc_info_0.addr()).unwrap());
+        assert_eq!(scheduler.num_scheduled_telecommands(), 0);
+    }
+
+    #[test]
+    fn test_delete_by_req_id_complex() {
+        let mut pool = LocalPool::new(PoolCfg::new(vec![(10, 32), (5, 64)]));
+        let mut scheduler =
+            PusScheduler::new(UnixTimestamp::new_only_seconds(0), Duration::from_secs(5));
+        let mut buf: [u8; 32] = [0; 32];
+        let tc_info_0 = ping_tc_to_store(&mut pool, &mut buf, 0, None);
+        scheduler
+            .insert_unwrapped_and_stored_tc(UnixTimestamp::new_only_seconds(100), tc_info_0)
+            .expect("inserting tc failed");
+        let tc_info_1 = ping_tc_to_store(&mut pool, &mut buf, 1, None);
+        scheduler
+            .insert_unwrapped_and_stored_tc(UnixTimestamp::new_only_seconds(100), tc_info_1)
+            .expect("inserting tc failed");
+        let tc_info_2 = ping_tc_to_store(&mut pool, &mut buf, 2, None);
+        scheduler
+            .insert_unwrapped_and_stored_tc(UnixTimestamp::new_only_seconds(100), tc_info_2)
+            .expect("inserting tc failed");
+        assert_eq!(scheduler.num_scheduled_telecommands(), 3);
+
+        // Delete first packet
+        let addr_0 = scheduler.delete_by_request_id(&tc_info_0.request_id());
+        assert!(addr_0.is_some());
+        assert_eq!(addr_0.unwrap(), tc_info_0.addr());
+        assert!(pool.has_element_at(&tc_info_0.addr()).unwrap());
+        assert_eq!(scheduler.num_scheduled_telecommands(), 2);
+
+        // Delete next packet
+        let del_res =
+            scheduler.delete_by_request_id_and_from_pool(&tc_info_2.request_id(), &mut pool);
+        assert!(del_res.is_ok());
+        assert_eq!(del_res.unwrap(), true);
+        assert!(!pool.has_element_at(&tc_info_2.addr()).unwrap());
+        assert_eq!(scheduler.num_scheduled_telecommands(), 1);
+
+        // Delete last packet
+        let addr_1 =
+            scheduler.delete_by_request_id_and_from_pool(&tc_info_1.request_id(), &mut pool);
+        assert!(addr_1.is_ok());
+        assert_eq!(addr_1.unwrap(), true);
+        assert!(!pool.has_element_at(&tc_info_1.addr()).unwrap());
+        assert_eq!(scheduler.num_scheduled_telecommands(), 0);
+    }
+
+    #[test]
+    fn insert_full_store_test() {
+        let mut scheduler =
+            PusScheduler::new(UnixTimestamp::new_only_seconds(0), Duration::from_secs(5));
+
+        let mut pool = LocalPool::new(PoolCfg::new(vec![(1, 64)]));
+
+        let mut buf: [u8; 32] = [0; 32];
+        // Store is full after this.
+        pool.add(&[0, 1, 2]).unwrap();
+        let tc = scheduled_tc(UnixTimestamp::new_only_seconds(100), &mut buf);
+
+        let insert_res = scheduler.insert_wrapped_tc::<cds::TimeProvider>(&tc, &mut pool);
+        assert!(insert_res.is_err());
+        let err = insert_res.unwrap_err();
+        match err {
+            ScheduleError::StoreError(e) => match e {
+                StoreError::StoreFull(_) => {}
+                _ => panic!("unexpected store error {e}"),
+            },
+            _ => panic!("unexpected error {err}"),
+        }
+    }
+
+    fn insert_command_with_release_time(
+        pool: &mut LocalPool,
+        scheduler: &mut PusScheduler,
+        seq_count: u16,
+        release_secs: u64,
+    ) -> TcInfo {
+        let mut buf: [u8; 32] = [0; 32];
+        let tc_info = ping_tc_to_store(pool, &mut buf, seq_count, None);
+
+        scheduler
+            .insert_unwrapped_and_stored_tc(
+                UnixTimestamp::new_only_seconds(release_secs as i64),
+                tc_info,
+            )
+            .expect("inserting tc failed");
+        tc_info
+    }
+
+    #[test]
+    fn test_time_window_retrieval_select_all() {
+        let mut pool = LocalPool::new(PoolCfg::new(vec![(10, 32), (5, 64)]));
+        let mut scheduler =
+            PusScheduler::new(UnixTimestamp::new_only_seconds(0), Duration::from_secs(5));
+        let tc_info_0 = insert_command_with_release_time(&mut pool, &mut scheduler, 0, 50);
+        let tc_info_1 = insert_command_with_release_time(&mut pool, &mut scheduler, 0, 100);
+        assert_eq!(scheduler.num_scheduled_telecommands(), 2);
+        let check_range = |range: Range<UnixTimestamp, Vec<TcInfo>>| {
+            let mut tcs_in_range = 0;
+            for (idx, time_bucket) in range.enumerate() {
+                tcs_in_range += 1;
+                if idx == 0 {
+                    assert_eq!(*time_bucket.0, UnixTimestamp::new_only_seconds(50));
+                    assert_eq!(time_bucket.1.len(), 1);
+                    assert_eq!(time_bucket.1[0].request_id, tc_info_0.request_id);
+                } else if idx == 1 {
+                    assert_eq!(*time_bucket.0, UnixTimestamp::new_only_seconds(100));
+                    assert_eq!(time_bucket.1.len(), 1);
+                    assert_eq!(time_bucket.1[0].request_id, tc_info_1.request_id);
+                }
+            }
+            assert_eq!(tcs_in_range, 2);
+        };
+        let range = scheduler.retrieve_all();
+        check_range(range);
+        let range =
+            scheduler.retrieve_by_time_filter(TimeWindow::<cds::TimeProvider>::new_select_all());
+        check_range(range);
+    }
+
+    #[test]
+    fn test_time_window_retrieval_select_from_stamp() {
+        let mut pool = LocalPool::new(PoolCfg::new(vec![(10, 32), (5, 64)]));
+        let mut scheduler =
+            PusScheduler::new(UnixTimestamp::new_only_seconds(0), Duration::from_secs(5));
+        let _ = insert_command_with_release_time(&mut pool, &mut scheduler, 0, 50);
+        let tc_info_1 = insert_command_with_release_time(&mut pool, &mut scheduler, 0, 100);
+        let tc_info_2 = insert_command_with_release_time(&mut pool, &mut scheduler, 0, 150);
+        let start_stamp =
+            cds::TimeProvider::from_unix_secs_with_u16_days(&UnixTimestamp::new_only_seconds(100))
+                .expect("creating start stamp failed");
+        let time_window = TimeWindow::new_from_time(&start_stamp);
+        assert_eq!(scheduler.num_scheduled_telecommands(), 3);
+
+        let range = scheduler.retrieve_by_time_filter(time_window);
+        let mut tcs_in_range = 0;
+        for (idx, time_bucket) in range.enumerate() {
+            tcs_in_range += 1;
+            if idx == 0 {
+                assert_eq!(*time_bucket.0, UnixTimestamp::new_only_seconds(100));
+                assert_eq!(time_bucket.1.len(), 1);
+                assert_eq!(time_bucket.1[0].request_id, tc_info_1.request_id());
+            } else if idx == 1 {
+                assert_eq!(*time_bucket.0, UnixTimestamp::new_only_seconds(150));
+                assert_eq!(time_bucket.1.len(), 1);
+                assert_eq!(time_bucket.1[0].request_id, tc_info_2.request_id());
+            }
+        }
+        assert_eq!(tcs_in_range, 2);
+    }
+
+    #[test]
+    fn test_time_window_retrieval_select_to_time() {
+        let mut pool = LocalPool::new(PoolCfg::new(vec![(10, 32), (5, 64)]));
+        let mut scheduler =
+            PusScheduler::new(UnixTimestamp::new_only_seconds(0), Duration::from_secs(5));
+        let tc_info_0 = insert_command_with_release_time(&mut pool, &mut scheduler, 0, 50);
+        let tc_info_1 = insert_command_with_release_time(&mut pool, &mut scheduler, 0, 100);
+        let _ = insert_command_with_release_time(&mut pool, &mut scheduler, 0, 150);
+        assert_eq!(scheduler.num_scheduled_telecommands(), 3);
+
+        let end_stamp =
+            cds::TimeProvider::from_unix_secs_with_u16_days(&UnixTimestamp::new_only_seconds(100))
+                .expect("creating start stamp failed");
+        let time_window = TimeWindow::new_to_time(&end_stamp);
+        let range = scheduler.retrieve_by_time_filter(time_window);
+        let mut tcs_in_range = 0;
+        for (idx, time_bucket) in range.enumerate() {
+            tcs_in_range += 1;
+            if idx == 0 {
+                assert_eq!(*time_bucket.0, UnixTimestamp::new_only_seconds(50));
+                assert_eq!(time_bucket.1.len(), 1);
+                assert_eq!(time_bucket.1[0].request_id, tc_info_0.request_id());
+            } else if idx == 1 {
+                assert_eq!(*time_bucket.0, UnixTimestamp::new_only_seconds(100));
+                assert_eq!(time_bucket.1.len(), 1);
+                assert_eq!(time_bucket.1[0].request_id, tc_info_1.request_id());
+            }
+        }
+        assert_eq!(tcs_in_range, 2);
+    }
+
+    #[test]
+    fn test_time_window_retrieval_select_from_time_to_time() {
+        let mut pool = LocalPool::new(PoolCfg::new(vec![(10, 32), (5, 64)]));
+        let mut scheduler =
+            PusScheduler::new(UnixTimestamp::new_only_seconds(0), Duration::from_secs(5));
+        let _ = insert_command_with_release_time(&mut pool, &mut scheduler, 0, 50);
+        let tc_info_1 = insert_command_with_release_time(&mut pool, &mut scheduler, 0, 100);
+        let tc_info_2 = insert_command_with_release_time(&mut pool, &mut scheduler, 0, 150);
+        let _ = insert_command_with_release_time(&mut pool, &mut scheduler, 0, 200);
+        assert_eq!(scheduler.num_scheduled_telecommands(), 4);
+
+        let start_stamp =
+            cds::TimeProvider::from_unix_secs_with_u16_days(&UnixTimestamp::new_only_seconds(100))
+                .expect("creating start stamp failed");
+        let end_stamp =
+            cds::TimeProvider::from_unix_secs_with_u16_days(&UnixTimestamp::new_only_seconds(150))
+                .expect("creating end stamp failed");
+        let time_window = TimeWindow::new_from_time_to_time(&start_stamp, &end_stamp);
+        let range = scheduler.retrieve_by_time_filter(time_window);
+        let mut tcs_in_range = 0;
+        for (idx, time_bucket) in range.enumerate() {
+            tcs_in_range += 1;
+            if idx == 0 {
+                assert_eq!(*time_bucket.0, UnixTimestamp::new_only_seconds(100));
+                assert_eq!(time_bucket.1.len(), 1);
+                assert_eq!(time_bucket.1[0].request_id, tc_info_1.request_id());
+            } else if idx == 1 {
+                assert_eq!(*time_bucket.0, UnixTimestamp::new_only_seconds(150));
+                assert_eq!(time_bucket.1.len(), 1);
+                assert_eq!(time_bucket.1[0].request_id, tc_info_2.request_id());
+            }
+        }
+        assert_eq!(tcs_in_range, 2);
+    }
+
+    #[test]
+    fn test_deletion_all() {
+        let mut pool = LocalPool::new(PoolCfg::new(vec![(10, 32), (5, 64)]));
+        let mut scheduler =
+            PusScheduler::new(UnixTimestamp::new_only_seconds(0), Duration::from_secs(5));
+        insert_command_with_release_time(&mut pool, &mut scheduler, 0, 50);
+        insert_command_with_release_time(&mut pool, &mut scheduler, 0, 100);
+        assert_eq!(scheduler.num_scheduled_telecommands(), 2);
+        let del_res = scheduler.delete_all(&mut pool);
+        assert!(del_res.is_ok());
+        assert_eq!(del_res.unwrap(), 2);
+        assert_eq!(scheduler.num_scheduled_telecommands(), 0);
+        // Contrary to reset, this does not disable the scheduler.
+        assert!(scheduler.is_enabled());
+
+        insert_command_with_release_time(&mut pool, &mut scheduler, 0, 50);
+        insert_command_with_release_time(&mut pool, &mut scheduler, 0, 100);
+        assert_eq!(scheduler.num_scheduled_telecommands(), 2);
+        let del_res = scheduler
+            .delete_by_time_filter(TimeWindow::<cds::TimeProvider>::new_select_all(), &mut pool);
+        assert!(del_res.is_ok());
+        assert_eq!(del_res.unwrap(), 2);
+        assert_eq!(scheduler.num_scheduled_telecommands(), 0);
+        // Contrary to reset, this does not disable the scheduler.
+        assert!(scheduler.is_enabled());
+    }
+
+    #[test]
+    fn test_deletion_from_start_time() {
+        let mut pool = LocalPool::new(PoolCfg::new(vec![(10, 32), (5, 64)]));
+        let mut scheduler =
+            PusScheduler::new(UnixTimestamp::new_only_seconds(0), Duration::from_secs(5));
+        insert_command_with_release_time(&mut pool, &mut scheduler, 0, 50);
+        let cmd_0_to_delete = insert_command_with_release_time(&mut pool, &mut scheduler, 0, 100);
+        let cmd_1_to_delete = insert_command_with_release_time(&mut pool, &mut scheduler, 0, 150);
+        assert_eq!(scheduler.num_scheduled_telecommands(), 3);
+        let start_stamp =
+            cds::TimeProvider::from_unix_secs_with_u16_days(&UnixTimestamp::new_only_seconds(100))
+                .expect("creating start stamp failed");
+        let time_window = TimeWindow::new_from_time(&start_stamp);
+        let del_res = scheduler.delete_by_time_filter(time_window, &mut pool);
+        assert!(del_res.is_ok());
+        assert_eq!(del_res.unwrap(), 2);
+        assert_eq!(scheduler.num_scheduled_telecommands(), 1);
+        assert!(!pool.has_element_at(&cmd_0_to_delete.addr()).unwrap());
+        assert!(!pool.has_element_at(&cmd_1_to_delete.addr()).unwrap());
+    }
+
+    #[test]
+    fn test_deletion_to_end_time() {
+        let mut pool = LocalPool::new(PoolCfg::new(vec![(10, 32), (5, 64)]));
+        let mut scheduler =
+            PusScheduler::new(UnixTimestamp::new_only_seconds(0), Duration::from_secs(5));
+        let cmd_0_to_delete = insert_command_with_release_time(&mut pool, &mut scheduler, 0, 50);
+        let cmd_1_to_delete = insert_command_with_release_time(&mut pool, &mut scheduler, 0, 100);
+        insert_command_with_release_time(&mut pool, &mut scheduler, 0, 150);
+        assert_eq!(scheduler.num_scheduled_telecommands(), 3);
+
+        let end_stamp =
+            cds::TimeProvider::from_unix_secs_with_u16_days(&UnixTimestamp::new_only_seconds(100))
+                .expect("creating start stamp failed");
+        let time_window = TimeWindow::new_to_time(&end_stamp);
+        let del_res = scheduler.delete_by_time_filter(time_window, &mut pool);
+        assert!(del_res.is_ok());
+        assert_eq!(del_res.unwrap(), 2);
+        assert_eq!(scheduler.num_scheduled_telecommands(), 1);
+        assert!(!pool.has_element_at(&cmd_0_to_delete.addr()).unwrap());
+        assert!(!pool.has_element_at(&cmd_1_to_delete.addr()).unwrap());
+    }
+
+    #[test]
+    fn test_deletion_from_start_time_to_end_time() {
+        let mut pool = LocalPool::new(PoolCfg::new(vec![(10, 32), (5, 64)]));
+        let mut scheduler =
+            PusScheduler::new(UnixTimestamp::new_only_seconds(0), Duration::from_secs(5));
+        let cmd_out_of_range_0 = insert_command_with_release_time(&mut pool, &mut scheduler, 0, 50);
+        let cmd_0_to_delete = insert_command_with_release_time(&mut pool, &mut scheduler, 0, 100);
+        let cmd_1_to_delete = insert_command_with_release_time(&mut pool, &mut scheduler, 0, 150);
+        let cmd_out_of_range_1 =
+            insert_command_with_release_time(&mut pool, &mut scheduler, 0, 200);
+        assert_eq!(scheduler.num_scheduled_telecommands(), 4);
+
+        let start_stamp =
+            cds::TimeProvider::from_unix_secs_with_u16_days(&UnixTimestamp::new_only_seconds(100))
+                .expect("creating start stamp failed");
+        let end_stamp =
+            cds::TimeProvider::from_unix_secs_with_u16_days(&UnixTimestamp::new_only_seconds(150))
+                .expect("creating end stamp failed");
+        let time_window = TimeWindow::new_from_time_to_time(&start_stamp, &end_stamp);
+        let del_res = scheduler.delete_by_time_filter(time_window, &mut pool);
+        assert!(del_res.is_ok());
+        assert_eq!(del_res.unwrap(), 2);
+        assert_eq!(scheduler.num_scheduled_telecommands(), 2);
+        assert!(pool.has_element_at(&cmd_out_of_range_0.addr()).unwrap());
+        assert!(!pool.has_element_at(&cmd_0_to_delete.addr()).unwrap());
+        assert!(!pool.has_element_at(&cmd_1_to_delete.addr()).unwrap());
+        assert!(pool.has_element_at(&cmd_out_of_range_1.addr()).unwrap());
+    }
+}
diff --git a/satrs-core/src/pus/scheduler_srv.rs b/satrs-core/src/pus/scheduler_srv.rs
new file mode 100644
index 0000000..52fc33a
--- /dev/null
+++ b/satrs-core/src/pus/scheduler_srv.rs
@@ -0,0 +1,184 @@
+use crate::pool::{SharedPool, StoreAddr};
+use crate::pus::scheduler::PusScheduler;
+use crate::pus::verification::{StdVerifReporterWithSender, TcStateAccepted, VerificationToken};
+use crate::pus::{
+    EcssTcReceiver, EcssTmSender, PusPacketHandlerResult, PusPacketHandlingError, PusServiceBase,
+    PusServiceHandler,
+};
+use spacepackets::ecss::{scheduling, PusPacket};
+use spacepackets::tc::PusTc;
+use spacepackets::time::cds::TimeProvider;
+use std::boxed::Box;
+
+/// This is a helper class for [std] environments to handle generic PUS 11 (scheduling service)
+/// packets. This handler is constrained to using the [PusScheduler], but is able to process
+/// the most important PUS requests for a scheduling service.
+///
+/// Please note that this class does not do the regular periodic handling like releasing any
+/// telecommands inside the scheduler. The user can retrieve the wrapped scheduler via the
+/// [Self::scheduler] and [Self::scheduler_mut] function and then use the scheduler API to release
+/// telecommands when applicable.
+pub struct PusService11SchedHandler {
+    psb: PusServiceBase,
+    scheduler: PusScheduler,
+}
+
+impl PusService11SchedHandler {
+    pub fn new(
+        tc_receiver: Box<dyn EcssTcReceiver>,
+        shared_tc_store: SharedPool,
+        tm_sender: Box<dyn EcssTmSender>,
+        tm_apid: u16,
+        verification_handler: StdVerifReporterWithSender,
+        scheduler: PusScheduler,
+    ) -> Self {
+        Self {
+            psb: PusServiceBase::new(
+                tc_receiver,
+                shared_tc_store,
+                tm_sender,
+                tm_apid,
+                verification_handler,
+            ),
+            scheduler,
+        }
+    }
+
+    pub fn scheduler_mut(&mut self) -> &mut PusScheduler {
+        &mut self.scheduler
+    }
+
+    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)?;
+        let (tc, _) = PusTc::from_bytes(&self.psb.pus_buf)?;
+        let subservice = tc.subservice();
+        let std_service = scheduling::Subservice::try_from(subservice);
+        if std_service.is_err() {
+            return Ok(PusPacketHandlerResult::CustomSubservice(
+                tc.subservice(),
+                token,
+            ));
+        }
+        let mut partial_error = None;
+        let time_stamp = self.psb().get_current_timestamp(&mut partial_error);
+        match std_service.unwrap() {
+            scheduling::Subservice::TcEnableScheduling => {
+                let start_token = self
+                    .psb
+                    .verification_handler
+                    .get_mut()
+                    .start_success(token, Some(&time_stamp))
+                    .expect("Error sending start success");
+
+                self.scheduler.enable();
+                if self.scheduler.is_enabled() {
+                    self.psb
+                        .verification_handler
+                        .get_mut()
+                        .completion_success(start_token, Some(&time_stamp))
+                        .expect("Error sending completion success");
+                } else {
+                    panic!("Failed to enable scheduler");
+                }
+            }
+            scheduling::Subservice::TcDisableScheduling => {
+                let start_token = self
+                    .psb
+                    .verification_handler
+                    .get_mut()
+                    .start_success(token, Some(&time_stamp))
+                    .expect("Error sending start success");
+
+                self.scheduler.disable();
+                if !self.scheduler.is_enabled() {
+                    self.psb
+                        .verification_handler
+                        .get_mut()
+                        .completion_success(start_token, Some(&time_stamp))
+                        .expect("Error sending completion success");
+                } else {
+                    panic!("Failed to disable scheduler");
+                }
+            }
+            scheduling::Subservice::TcResetScheduling => {
+                let start_token = self
+                    .psb
+                    .verification_handler
+                    .get_mut()
+                    .start_success(token, Some(&time_stamp))
+                    .expect("Error sending start success");
+
+                let mut pool = self
+                    .psb
+                    .shared_tc_store
+                    .write()
+                    .expect("Locking pool failed");
+
+                self.scheduler
+                    .reset(pool.as_mut())
+                    .expect("Error resetting TC Pool");
+
+                self.psb
+                    .verification_handler
+                    .get_mut()
+                    .completion_success(start_token, Some(&time_stamp))
+                    .expect("Error sending completion success");
+            }
+            scheduling::Subservice::TcInsertActivity => {
+                let start_token = self
+                    .psb
+                    .verification_handler
+                    .get_mut()
+                    .start_success(token, Some(&time_stamp))
+                    .expect("error sending start success");
+
+                let mut pool = self
+                    .psb
+                    .shared_tc_store
+                    .write()
+                    .expect("locking pool failed");
+                self.scheduler
+                    .insert_wrapped_tc::<TimeProvider>(&tc, pool.as_mut())
+                    .expect("insertion of activity into pool failed");
+
+                self.psb
+                    .verification_handler
+                    .get_mut()
+                    .completion_success(start_token, Some(&time_stamp))
+                    .expect("sending completion success failed");
+            }
+            _ => {
+                return Ok(PusPacketHandlerResult::CustomSubservice(
+                    tc.subservice(),
+                    token,
+                ));
+            }
+        }
+        if let Some(partial_error) = partial_error {
+            return Ok(PusPacketHandlerResult::RequestHandledPartialSuccess(
+                partial_error,
+            ));
+        }
+        Ok(PusPacketHandlerResult::CustomSubservice(
+            tc.subservice(),
+            token,
+        ))
+    }
+}
diff --git a/satrs-core/src/pus/test.rs b/satrs-core/src/pus/test.rs
new file mode 100644
index 0000000..178493b
--- /dev/null
+++ b/satrs-core/src/pus/test.rs
@@ -0,0 +1,218 @@
+use crate::pool::{SharedPool, StoreAddr};
+use crate::pus::verification::{StdVerifReporterWithSender, TcStateAccepted, VerificationToken};
+use crate::pus::{
+    EcssTcReceiver, EcssTmSender, PartialPusHandlingError, PusPacketHandlerResult,
+    PusPacketHandlingError, PusServiceBase, PusServiceHandler, PusTmWrapper,
+};
+use spacepackets::ecss::PusPacket;
+use spacepackets::tc::PusTc;
+use spacepackets::tm::{PusTm, PusTmSecondaryHeader};
+use spacepackets::SpHeader;
+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,
+}
+
+impl PusService17TestHandler {
+    pub fn new(
+        tc_receiver: Box<dyn EcssTcReceiver>,
+        shared_tc_store: SharedPool,
+        tm_sender: Box<dyn EcssTmSender>,
+        tm_apid: u16,
+        verification_handler: StdVerifReporterWithSender,
+    ) -> Self {
+        Self {
+            psb: PusServiceBase::new(
+                tc_receiver,
+                shared_tc_store,
+                tm_sender,
+                tm_apid,
+                verification_handler,
+            ),
+        }
+    }
+}
+
+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)?;
+        let (tc, _) = PusTc::from_bytes(&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 result = self
+                .psb
+                .verification_handler
+                .get_mut()
+                .start_success(token, Some(&time_stamp))
+                .map_err(|_| PartialPusHandlingError::Verification);
+            let start_token = if let Ok(result) = result {
+                Some(result)
+            } else {
+                partial_error = Some(result.unwrap_err());
+                None
+            };
+            // Sequence count will be handled centrally in TM funnel.
+            let mut reply_header = SpHeader::tm_unseg(self.psb.tm_apid, 0, 0).unwrap();
+            let tc_header = PusTmSecondaryHeader::new_simple(17, 2, &time_stamp);
+            let ping_reply = PusTm::new(&mut reply_header, tc_header, None, true);
+            let result = self
+                .psb
+                .tm_sender
+                .send_tm(PusTmWrapper::Direct(ping_reply))
+                .map_err(PartialPusHandlingError::TmSend);
+            if let Err(err) = result {
+                partial_error = Some(err);
+            }
+
+            if let Some(start_token) = start_token {
+                if self
+                    .psb
+                    .verification_handler
+                    .get_mut()
+                    .completion_success(start_token, Some(&time_stamp))
+                    .is_err()
+                {
+                    partial_error = Some(PartialPusHandlingError::Verification)
+                }
+            }
+            if let Some(partial_error) = partial_error {
+                return Ok(PusPacketHandlerResult::RequestHandledPartialSuccess(
+                    partial_error,
+                ));
+            };
+            return Ok(PusPacketHandlerResult::RequestHandled);
+        }
+        Ok(PusPacketHandlerResult::CustomSubservice(
+            tc.subservice(),
+            token,
+        ))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::pool::{LocalPool, PoolCfg, SharedPool};
+    use crate::pus::test::PusService17TestHandler;
+    use crate::pus::verification::{
+        RequestId, StdVerifReporterWithSender, VerificationReporterCfg,
+    };
+    use crate::pus::{MpscTcInStoreReceiver, MpscTmInStoreSender, PusServiceHandler};
+    use crate::tmtc::tm_helper::SharedTmStore;
+    use spacepackets::ecss::{PusPacket, SerializablePusPacket};
+    use spacepackets::tc::{PusTc, PusTcSecondaryHeader};
+    use spacepackets::tm::PusTm;
+    use spacepackets::{SequenceFlags, SpHeader};
+    use std::boxed::Box;
+    use std::sync::{mpsc, RwLock};
+    use std::vec;
+
+    const TEST_APID: u16 = 0x101;
+
+    #[test]
+    fn test_basic_ping_processing() {
+        let mut pus_buf: [u8; 64] = [0; 64];
+        let pool_cfg = PoolCfg::new(vec![(16, 16), (8, 32), (4, 64)]);
+        let tc_pool = LocalPool::new(pool_cfg.clone());
+        let tm_pool = LocalPool::new(pool_cfg);
+        let tc_pool_shared = SharedPool::new(RwLock::new(Box::new(tc_pool)));
+        let shared_tm_store = SharedTmStore::new(Box::new(tm_pool));
+        let tm_pool_shared = shared_tm_store.clone_backing_pool();
+        let (test_srv_tc_tx, test_srv_tc_rx) = mpsc::channel();
+        let (tm_tx, tm_rx) = mpsc::channel();
+        let verif_sender =
+            MpscTmInStoreSender::new(0, "verif_sender", shared_tm_store.clone(), tm_tx.clone());
+        let verif_cfg = VerificationReporterCfg::new(TEST_APID, 1, 2, 8).unwrap();
+        let mut verification_handler =
+            StdVerifReporterWithSender::new(&verif_cfg, Box::new(verif_sender));
+        let test_srv_tm_sender = MpscTmInStoreSender::new(0, "TEST_SENDER", shared_tm_store, tm_tx);
+        let test_srv_tc_receiver = MpscTcInStoreReceiver::new(0, "TEST_RECEIVER", test_srv_tc_rx);
+        let mut pus_17_handler = PusService17TestHandler::new(
+            Box::new(test_srv_tc_receiver),
+            tc_pool_shared.clone(),
+            Box::new(test_srv_tm_sender),
+            TEST_APID,
+            verification_handler.clone(),
+        );
+        // Create a ping TC, verify acceptance.
+        let mut sp_header = SpHeader::tc(TEST_APID, SequenceFlags::Unsegmented, 0, 0).unwrap();
+        let sec_header = PusTcSecondaryHeader::new_simple(17, 1);
+        let ping_tc = PusTc::new(&mut sp_header, sec_header, None, true);
+        let token = verification_handler.add_tc(&ping_tc);
+        let token = verification_handler
+            .acceptance_success(token, None)
+            .unwrap();
+        let tc_size = ping_tc.write_to_bytes(&mut pus_buf).unwrap();
+        let mut tc_pool = tc_pool_shared.write().unwrap();
+        let addr = tc_pool.add(&pus_buf[..tc_size]).unwrap();
+        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();
+        assert!(result.is_ok());
+        // We should see 4 replies in the TM queue now: Acceptance TM, Start TM, ping reply and
+        // Completion TM
+        let mut next_msg = tm_rx.try_recv();
+        assert!(next_msg.is_ok());
+        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, _) = PusTm::from_bytes(&tm_raw, 0).unwrap();
+        assert_eq!(tm.service(), 1);
+        assert_eq!(tm.subservice(), 1);
+        let req_id = RequestId::from_bytes(tm.user_data().unwrap()).unwrap();
+        assert_eq!(req_id, token.req_id());
+
+        // Acceptance TM
+        next_msg = tm_rx.try_recv();
+        assert!(next_msg.is_ok());
+        tm_addr = next_msg.unwrap();
+        let tm_raw = tm_pool.read(&tm_addr).unwrap();
+        // Is generated with CDS short timestamp.
+        let (tm, _) = PusTm::from_bytes(&tm_raw, 7).unwrap();
+        assert_eq!(tm.service(), 1);
+        assert_eq!(tm.subservice(), 3);
+        let req_id = RequestId::from_bytes(tm.user_data().unwrap()).unwrap();
+        assert_eq!(req_id, token.req_id());
+
+        // Ping reply
+        next_msg = tm_rx.try_recv();
+        assert!(next_msg.is_ok());
+        tm_addr = next_msg.unwrap();
+        let tm_raw = tm_pool.read(&tm_addr).unwrap();
+        // Is generated with CDS short timestamp.
+        let (tm, _) = PusTm::from_bytes(&tm_raw, 7).unwrap();
+        assert_eq!(tm.service(), 17);
+        assert_eq!(tm.subservice(), 2);
+        assert!(tm.user_data().is_none());
+
+        // TM completion
+        next_msg = tm_rx.try_recv();
+        assert!(next_msg.is_ok());
+        tm_addr = next_msg.unwrap();
+        let tm_raw = tm_pool.read(&tm_addr).unwrap();
+        // Is generated with CDS short timestamp.
+        let (tm, _) = PusTm::from_bytes(&tm_raw, 7).unwrap();
+        assert_eq!(tm.service(), 1);
+        assert_eq!(tm.subservice(), 7);
+        let req_id = RequestId::from_bytes(tm.user_data().unwrap()).unwrap();
+        assert_eq!(req_id, token.req_id());
+    }
+}
diff --git a/satrs-core/src/pus/verification.rs b/satrs-core/src/pus/verification.rs
new file mode 100644
index 0000000..1f25c90
--- /dev/null
+++ b/satrs-core/src/pus/verification.rs
@@ -0,0 +1,2378 @@
+//! # PUS Service 1 Verification Module
+//!
+//! This module allows packaging and sending PUS Service 1 packets. It is conforming to section
+//! 8 of the PUS standard ECSS-E-ST-70-41C.
+//!
+//! The core object to report TC verification progress is the [VerificationReporter]. It exposes
+//! an API which uses type-state programming to avoid calling the verification steps in
+//! an invalid order.
+//!
+//! # Examples
+//!
+//! Basic single-threaded example where a full success sequence for a given ping telecommand is
+//! executed. Note that the verification part could also be done in a separate thread.
+//!
+//! ```
+//! use std::sync::{Arc, mpsc, RwLock};
+//! use std::time::Duration;
+//! use satrs_core::pool::{LocalPool, PoolCfg, PoolProvider, SharedPool};
+//! use satrs_core::pus::verification::{VerificationReporterCfg, VerificationReporterWithSender};
+//! use satrs_core::seq_count::SeqCountProviderSimple;
+//! use satrs_core::pus::MpscTmInStoreSender;
+//! use satrs_core::tmtc::tm_helper::SharedTmStore;
+//! use spacepackets::ecss::PusPacket;
+//! use spacepackets::SpHeader;
+//! use spacepackets::tc::{PusTc, PusTcSecondaryHeader};
+//! use spacepackets::tm::PusTm;
+//!
+//! const EMPTY_STAMP: [u8; 7] = [0; 7];
+//! const TEST_APID: u16 = 0x02;
+//!
+//! let pool_cfg = PoolCfg::new(vec![(10, 32), (10, 64), (10, 128), (10, 1024)]);
+//! let tm_pool = LocalPool::new(pool_cfg.clone());
+//! let shared_tm_store = SharedTmStore::new(Box::new(tm_pool));
+//! let tm_store = shared_tm_store.clone_backing_pool();
+//! let (verif_tx, verif_rx) = mpsc::channel();
+//! let sender = MpscTmInStoreSender::new(0, "Test Sender", shared_tm_store, verif_tx);
+//! let cfg = VerificationReporterCfg::new(TEST_APID, 1, 2, 8).unwrap();
+//! let mut  reporter = VerificationReporterWithSender::new(&cfg , Box::new(sender));
+//!
+//! let mut sph = SpHeader::tc_unseg(TEST_APID, 0, 0).unwrap();
+//! let tc_header = PusTcSecondaryHeader::new_simple(17, 1);
+//! let pus_tc_0 = PusTc::new(&mut sph, tc_header, None, true);
+//! let init_token = reporter.add_tc(&pus_tc_0);
+//!
+//! // Complete success sequence for a telecommand
+//! let accepted_token = reporter.acceptance_success(init_token, Some(&EMPTY_STAMP)).unwrap();
+//! let started_token = reporter.start_success(accepted_token, Some(&EMPTY_STAMP)).unwrap();
+//! reporter.completion_success(started_token, Some(&EMPTY_STAMP)).unwrap();
+//!
+//! // Verify it arrives correctly on receiver end
+//! let mut tm_buf: [u8; 1024] = [0; 1024];
+//! let mut packet_idx = 0;
+//! while packet_idx < 3 {
+//!     let addr = verif_rx.recv_timeout(Duration::from_millis(10)).unwrap();
+//!     let tm_len;
+//!     {
+//!         let mut rg = tm_store.write().expect("Error locking shared pool");
+//!         let store_guard = rg.read_with_guard(addr);
+//!         let slice = store_guard.read().expect("Error reading TM slice");
+//!         tm_len = slice.len();
+//!         tm_buf[0..tm_len].copy_from_slice(slice);
+//!     }
+//!     let (pus_tm, _) = PusTm::from_bytes(&tm_buf[0..tm_len], 7)
+//!        .expect("Error reading verification TM");
+//!     if packet_idx == 0 {
+//!         assert_eq!(pus_tm.subservice(), 1);
+//!     } else if packet_idx == 1 {
+//!         assert_eq!(pus_tm.subservice(), 3);
+//!     } else if packet_idx == 2 {
+//!         assert_eq!(pus_tm.subservice(), 7);
+//!     }
+//!     packet_idx += 1;
+//! }
+//! ```
+//!
+//! The [integration test](https://egit.irs.uni-stuttgart.de/rust/fsrc-launchpad/src/branch/main/fsrc-core/tests/verification_test.rs)
+//! for the verification module contains examples how this module could be used in a more complex
+//! context involving multiple threads
+use crate::pus::{source_buffer_large_enough, EcssTmSenderCore, EcssTmtcError};
+use core::fmt::{Debug, Display, Formatter};
+use core::hash::{Hash, Hasher};
+use core::marker::PhantomData;
+use core::mem::size_of;
+#[cfg(feature = "alloc")]
+use delegate::delegate;
+#[cfg(feature = "serde")]
+use serde::{Deserialize, Serialize};
+use spacepackets::ecss::{EcssEnumeration, PusError, SerializablePusPacket};
+use spacepackets::tc::PusTc;
+use spacepackets::tm::{PusTm, PusTmSecondaryHeader};
+use spacepackets::{CcsdsPacket, PacketId, PacketSequenceCtrl};
+use spacepackets::{SpHeader, MAX_APID};
+
+pub use crate::seq_count::SeqCountProviderSimple;
+pub use spacepackets::ecss::verification::*;
+
+#[cfg(feature = "alloc")]
+pub use alloc_mod::{
+    VerificationReporter, VerificationReporterCfg, VerificationReporterWithSender,
+};
+#[cfg(feature = "std")]
+pub use std_mod::*;
+
+/// This is a request identifier as specified in 5.4.11.2 c. of the PUS standard.
+///
+/// This field equivalent to the first two bytes of the CCSDS space packet header.
+/// This version of the request ID is supplied in the verification reports and does not contain
+/// the source ID.
+#[derive(Debug, Eq, Copy, Clone)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+pub struct RequestId {
+    version_number: u8,
+    packet_id: PacketId,
+    psc: PacketSequenceCtrl,
+}
+
+impl Display for RequestId {
+    fn fmt(&self, f: &mut Formatter<'_>) -> core::fmt::Result {
+        write!(f, "{:#08x}", self.raw())
+    }
+}
+
+impl Hash for RequestId {
+    fn hash<H: Hasher>(&self, state: &mut H) {
+        self.raw().hash(state);
+    }
+}
+
+// Implement manually to satisfy derive_hash_xor_eq lint
+impl PartialEq for RequestId {
+    fn eq(&self, other: &Self) -> bool {
+        self.version_number == other.version_number
+            && self.packet_id == other.packet_id
+            && self.psc == other.psc
+    }
+}
+
+impl RequestId {
+    pub const SIZE_AS_BYTES: usize = size_of::<u32>();
+
+    pub fn raw(&self) -> u32 {
+        ((self.version_number as u32) << 29)
+            | ((self.packet_id.raw() as u32) << 16)
+            | self.psc.raw() as u32
+    }
+
+    pub fn to_bytes(&self, buf: &mut [u8]) {
+        let raw = self.raw();
+        buf.copy_from_slice(raw.to_be_bytes().as_slice());
+    }
+
+    pub fn from_bytes(buf: &[u8]) -> Option<Self> {
+        if buf.len() < 4 {
+            return None;
+        }
+        let raw = u32::from_be_bytes(buf[0..Self::SIZE_AS_BYTES].try_into().unwrap());
+        Some(Self {
+            version_number: ((raw >> 29) & 0b111) as u8,
+            packet_id: PacketId::from(((raw >> 16) & 0xffff) as u16),
+            psc: PacketSequenceCtrl::from((raw & 0xffff) as u16),
+        })
+    }
+}
+impl RequestId {
+    /// This allows extracting the request ID from a given PUS telecommand.
+    pub fn new(tc: &PusTc) -> Self {
+        RequestId {
+            version_number: tc.ccsds_version(),
+            packet_id: tc.packet_id(),
+            psc: tc.psc(),
+        }
+    }
+}
+
+/// If a verification operation fails, the passed token will be returned as well. This allows
+/// re-trying the operation at a later point.
+#[derive(Debug, Clone)]
+pub struct VerificationOrSendErrorWithToken<T>(pub EcssTmtcError, pub VerificationToken<T>);
+
+#[derive(Debug, Clone)]
+pub struct VerificationErrorWithToken<T>(pub EcssTmtcError, pub VerificationToken<T>);
+
+impl<T> From<VerificationErrorWithToken<T>> for VerificationOrSendErrorWithToken<T> {
+    fn from(value: VerificationErrorWithToken<T>) -> Self {
+        VerificationOrSendErrorWithToken(value.0, value.1)
+    }
+}
+/// Support token to allow type-state programming. This prevents calling the verification
+/// steps in an invalid order.
+#[derive(Debug, Clone, Copy, Eq, PartialEq)]
+pub struct VerificationToken<STATE> {
+    state: PhantomData<STATE>,
+    req_id: RequestId,
+}
+
+pub trait WasAtLeastAccepted {}
+
+#[derive(Copy, Clone, Debug, Eq, PartialEq)]
+pub struct TcStateNone;
+#[derive(Copy, Clone, Debug, Eq, PartialEq)]
+pub struct TcStateAccepted;
+#[derive(Copy, Clone, Debug, Eq, PartialEq)]
+pub struct TcStateStarted;
+#[derive(Copy, Clone, Debug, Eq, PartialEq)]
+pub struct TcStateCompleted;
+
+impl WasAtLeastAccepted for TcStateAccepted {}
+impl WasAtLeastAccepted for TcStateStarted {}
+impl WasAtLeastAccepted for TcStateCompleted {}
+
+#[derive(Debug, Copy, Clone, Eq, PartialEq)]
+pub enum TcStateToken {
+    None(VerificationToken<TcStateNone>),
+    Accepted(VerificationToken<TcStateAccepted>),
+    Started(VerificationToken<TcStateStarted>),
+    Completed(VerificationToken<TcStateCompleted>),
+}
+
+impl From<VerificationToken<TcStateNone>> for TcStateToken {
+    fn from(t: VerificationToken<TcStateNone>) -> Self {
+        TcStateToken::None(t)
+    }
+}
+
+impl TryFrom<TcStateToken> for VerificationToken<TcStateAccepted> {
+    type Error = ();
+
+    fn try_from(value: TcStateToken) -> Result<Self, Self::Error> {
+        if let TcStateToken::Accepted(token) = value {
+            Ok(token)
+        } else {
+            Err(())
+        }
+    }
+}
+
+impl TryFrom<TcStateToken> for VerificationToken<TcStateStarted> {
+    type Error = ();
+
+    fn try_from(value: TcStateToken) -> Result<Self, Self::Error> {
+        if let TcStateToken::Started(token) = value {
+            Ok(token)
+        } else {
+            Err(())
+        }
+    }
+}
+
+impl From<VerificationToken<TcStateAccepted>> for TcStateToken {
+    fn from(t: VerificationToken<TcStateAccepted>) -> Self {
+        TcStateToken::Accepted(t)
+    }
+}
+
+impl From<VerificationToken<TcStateStarted>> for TcStateToken {
+    fn from(t: VerificationToken<TcStateStarted>) -> Self {
+        TcStateToken::Started(t)
+    }
+}
+
+impl From<VerificationToken<TcStateCompleted>> for TcStateToken {
+    fn from(t: VerificationToken<TcStateCompleted>) -> Self {
+        TcStateToken::Completed(t)
+    }
+}
+
+impl<STATE> VerificationToken<STATE> {
+    fn new(req_id: RequestId) -> VerificationToken<TcStateNone> {
+        VerificationToken {
+            state: PhantomData,
+            req_id,
+        }
+    }
+
+    pub fn req_id(&self) -> RequestId {
+        self.req_id
+    }
+}
+
+/// Composite helper struct to pass failure parameters to the [VerificationReporter]
+pub struct FailParams<'stamp, 'fargs> {
+    time_stamp: Option<&'stamp [u8]>,
+    failure_code: &'fargs dyn EcssEnumeration,
+    failure_data: Option<&'fargs [u8]>,
+}
+
+impl<'stamp, 'fargs> FailParams<'stamp, 'fargs> {
+    pub fn new(
+        time_stamp: Option<&'stamp [u8]>,
+        failure_code: &'fargs impl EcssEnumeration,
+        failure_data: Option<&'fargs [u8]>,
+    ) -> Self {
+        Self {
+            time_stamp,
+            failure_code,
+            failure_data,
+        }
+    }
+}
+
+/// Composite helper struct to pass step failure parameters to the [VerificationReporter]
+pub struct FailParamsWithStep<'stamp, 'fargs> {
+    bp: FailParams<'stamp, 'fargs>,
+    step: &'fargs dyn EcssEnumeration,
+}
+
+impl<'stamp, 'fargs> FailParamsWithStep<'stamp, 'fargs> {
+    pub fn new(
+        time_stamp: Option<&'stamp [u8]>,
+        step: &'fargs impl EcssEnumeration,
+        failure_code: &'fargs impl EcssEnumeration,
+        failure_data: Option<&'fargs [u8]>,
+    ) -> Self {
+        Self {
+            bp: FailParams::new(time_stamp, failure_code, failure_data),
+            step,
+        }
+    }
+}
+
+#[derive(Clone)]
+pub struct VerificationReporterCore {
+    pub dest_id: u16,
+    apid: u16,
+}
+
+pub enum VerifSuccess {}
+pub enum VerifFailure {}
+
+/// Abstraction for a sendable PUS TM. The user is expected to send the TM packet to a TM sink.
+///
+/// This struct generally mutably borrows the source data buffer.
+pub struct VerificationSendable<'src_data, State, SuccessOrFailure> {
+    token: Option<VerificationToken<State>>,
+    pus_tm: Option<PusTm<'src_data>>,
+    phantom: PhantomData<SuccessOrFailure>,
+}
+
+impl<'src_data, State, SuccessOrFailure> VerificationSendable<'src_data, State, SuccessOrFailure> {
+    pub(crate) fn new(pus_tm: PusTm<'src_data>, token: VerificationToken<State>) -> Self {
+        Self {
+            token: Some(token),
+            pus_tm: Some(pus_tm),
+            phantom: PhantomData,
+        }
+    }
+    pub(crate) fn new_no_token(pus_tm: PusTm<'src_data>) -> Self {
+        Self {
+            token: None,
+            pus_tm: Some(pus_tm),
+            phantom: PhantomData,
+        }
+    }
+
+    pub fn len_packed(&self) -> usize {
+        self.pus_tm.as_ref().unwrap().len_packed()
+    }
+
+    pub fn pus_tm(&self) -> &PusTm<'src_data> {
+        self.pus_tm.as_ref().unwrap()
+    }
+
+    pub fn pus_tm_mut(&mut self) -> &mut PusTm<'src_data> {
+        self.pus_tm.as_mut().unwrap()
+    }
+}
+
+impl<'src_data, State> VerificationSendable<'src_data, State, VerifFailure> {
+    pub fn send_success_verif_failure(self) {}
+}
+
+impl<'src_data, State> VerificationSendable<'src_data, State, VerifFailure> {
+    pub fn send_failure(self) -> (PusTm<'src_data>, VerificationToken<State>) {
+        (self.pus_tm.unwrap(), self.token.unwrap())
+    }
+}
+
+impl<'src_data> VerificationSendable<'src_data, TcStateNone, VerifSuccess> {
+    pub fn send_success_acceptance_success(self) -> VerificationToken<TcStateAccepted> {
+        VerificationToken {
+            state: PhantomData,
+            req_id: self.token.unwrap().req_id(),
+        }
+    }
+}
+
+impl<'src_data> VerificationSendable<'src_data, TcStateAccepted, VerifSuccess> {
+    pub fn send_success_start_success(self) -> VerificationToken<TcStateStarted> {
+        VerificationToken {
+            state: PhantomData,
+            req_id: self.token.unwrap().req_id(),
+        }
+    }
+}
+
+impl<'src_data, TcState: WasAtLeastAccepted + Copy>
+    VerificationSendable<'src_data, TcState, VerifSuccess>
+{
+    pub fn send_success_step_or_completion_success(self) {}
+}
+
+/// Primary verification handler. It provides an API to send PUS 1 verification telemetry packets
+/// and verify the various steps of telecommand handling as specified in the PUS standard.
+///
+/// This is the core component which can be used without [`alloc`] support. Please note that
+/// the buffer passed to the API exposes by this struct will be used to serialize the source data.
+/// This buffer may not be re-used to serialize the whole telemetry because that would overwrite
+/// the source data itself.
+impl VerificationReporterCore {
+    pub fn new(apid: u16) -> Option<Self> {
+        if apid > MAX_APID {
+            return None;
+        }
+        Some(Self { apid, dest_id: 0 })
+    }
+
+    pub fn set_apid(&mut self, apid: u16) -> bool {
+        if apid > MAX_APID {
+            return false;
+        }
+        self.apid = apid;
+        true
+    }
+
+    pub fn apid(&self) -> u16 {
+        self.apid
+    }
+
+    pub fn dest_id(&self) -> u16 {
+        self.dest_id
+    }
+
+    pub fn set_dest_id(&mut self, dest_id: u16) {
+        self.dest_id = dest_id;
+    }
+
+    /// Initialize verification handling by passing a TC reference. This returns a token required
+    /// to call the acceptance functions
+    pub fn add_tc(&mut self, pus_tc: &PusTc) -> VerificationToken<TcStateNone> {
+        self.add_tc_with_req_id(RequestId::new(pus_tc))
+    }
+
+    /// Same as [Self::add_tc] but pass a request ID instead of the direct telecommand.
+    /// This can be useful if the executing thread does not have full access to the telecommand.
+    pub fn add_tc_with_req_id(&mut self, req_id: RequestId) -> VerificationToken<TcStateNone> {
+        VerificationToken::<TcStateNone>::new(req_id)
+    }
+
+    fn sendable_success_no_step<'src_data, State: Copy>(
+        &mut self,
+        src_data_buf: &'src_data mut [u8],
+        subservice: u8,
+        token: VerificationToken<State>,
+        seq_count: u16,
+        msg_count: u16,
+        time_stamp: Option<&'src_data [u8]>,
+    ) -> Result<
+        VerificationSendable<'src_data, State, VerifSuccess>,
+        VerificationErrorWithToken<State>,
+    > {
+        Ok(VerificationSendable::new(
+            self.create_pus_verif_success_tm(
+                src_data_buf,
+                subservice,
+                seq_count,
+                msg_count,
+                &token.req_id,
+                time_stamp,
+                None::<&dyn EcssEnumeration>,
+            )
+            .map_err(|e| VerificationErrorWithToken(e, token))?,
+            token,
+        ))
+    }
+
+    // Internal helper function, too many arguments is acceptable for this case.
+    #[allow(clippy::too_many_arguments)]
+    fn sendable_failure_no_step<'src_data, State: Copy>(
+        &self,
+        src_data_buf: &'src_data mut [u8],
+        subservice: u8,
+        token: VerificationToken<State>,
+        seq_count: u16,
+        msg_count: u16,
+        step: Option<&(impl EcssEnumeration + ?Sized)>,
+        params: &FailParams<'src_data, '_>,
+    ) -> Result<
+        VerificationSendable<'src_data, State, VerifFailure>,
+        VerificationErrorWithToken<State>,
+    > {
+        Ok(VerificationSendable::new(
+            self.create_pus_verif_fail_tm(
+                src_data_buf,
+                subservice,
+                seq_count,
+                msg_count,
+                &token.req_id,
+                step,
+                params,
+            )
+            .map_err(|e| VerificationErrorWithToken(e, token))?,
+            token,
+        ))
+    }
+
+    /// Package a PUS TM\[1, 1\] packet, see 8.1.2.1 of the PUS standard.
+    pub fn acceptance_success<'src_data>(
+        &mut self,
+        src_data_buf: &'src_data mut [u8],
+        token: VerificationToken<TcStateNone>,
+        seq_count: u16,
+        msg_count: u16,
+        time_stamp: Option<&'src_data [u8]>,
+    ) -> Result<
+        VerificationSendable<'src_data, TcStateNone, VerifSuccess>,
+        VerificationErrorWithToken<TcStateNone>,
+    > {
+        self.sendable_success_no_step(
+            src_data_buf,
+            Subservice::TmAcceptanceSuccess.into(),
+            token,
+            seq_count,
+            msg_count,
+            time_stamp,
+        )
+    }
+
+    pub fn send_acceptance_success(
+        &self,
+        mut sendable: VerificationSendable<'_, TcStateNone, VerifSuccess>,
+        sender: &mut (impl EcssTmSenderCore + ?Sized),
+    ) -> Result<VerificationToken<TcStateAccepted>, VerificationOrSendErrorWithToken<TcStateNone>>
+    {
+        sender
+            .send_tm(sendable.pus_tm.take().unwrap().into())
+            .map_err(|e| VerificationOrSendErrorWithToken(e, sendable.token.unwrap()))?;
+        Ok(sendable.send_success_acceptance_success())
+    }
+
+    pub fn send_acceptance_failure(
+        &self,
+        mut sendable: VerificationSendable<'_, TcStateNone, VerifFailure>,
+        sender: &mut (impl EcssTmSenderCore + ?Sized),
+    ) -> Result<(), VerificationOrSendErrorWithToken<TcStateNone>> {
+        sender
+            .send_tm(sendable.pus_tm.take().unwrap().into())
+            .map_err(|e| VerificationOrSendErrorWithToken(e, sendable.token.unwrap()))?;
+        sendable.send_success_verif_failure();
+        Ok(())
+    }
+
+    /// Package a PUS TM\[1, 2\] packet, see 8.1.2.2 of the PUS standard.
+    pub fn acceptance_failure<'src_data>(
+        &mut self,
+        src_data_buf: &'src_data mut [u8],
+        token: VerificationToken<TcStateNone>,
+        seq_count: u16,
+        msg_count: u16,
+        params: FailParams<'src_data, '_>,
+    ) -> Result<
+        VerificationSendable<'src_data, TcStateNone, VerifFailure>,
+        VerificationErrorWithToken<TcStateNone>,
+    > {
+        self.sendable_failure_no_step(
+            src_data_buf,
+            Subservice::TmAcceptanceFailure.into(),
+            token,
+            seq_count,
+            msg_count,
+            None::<&dyn EcssEnumeration>,
+            &params,
+        )
+    }
+
+    /// Package and send a PUS TM\[1, 3\] packet, see 8.1.2.3 of the PUS standard.
+    ///
+    /// Requires a token previously acquired by calling [Self::acceptance_success].
+    pub fn start_success<'src_data>(
+        &mut self,
+        src_data_buf: &'src_data mut [u8],
+        token: VerificationToken<TcStateAccepted>,
+        seq_count: u16,
+        msg_count: u16,
+        time_stamp: Option<&'src_data [u8]>,
+    ) -> Result<
+        VerificationSendable<'src_data, TcStateAccepted, VerifSuccess>,
+        VerificationErrorWithToken<TcStateAccepted>,
+    > {
+        self.sendable_success_no_step(
+            src_data_buf,
+            Subservice::TmStartSuccess.into(),
+            token,
+            seq_count,
+            msg_count,
+            time_stamp,
+        )
+    }
+
+    pub fn send_start_success(
+        &self,
+        mut sendable: VerificationSendable<'_, TcStateAccepted, VerifSuccess>,
+        sender: &mut (impl EcssTmSenderCore + ?Sized),
+    ) -> Result<VerificationToken<TcStateStarted>, VerificationOrSendErrorWithToken<TcStateAccepted>>
+    {
+        sender
+            .send_tm(sendable.pus_tm.take().unwrap().into())
+            .map_err(|e| VerificationOrSendErrorWithToken(e, sendable.token.unwrap()))?;
+        Ok(sendable.send_success_start_success())
+    }
+
+    /// Package and send a PUS TM\[1, 4\] packet, see 8.1.2.4 of the PUS standard.
+    ///
+    /// Requires a token previously acquired by calling [Self::acceptance_success]. It consumes
+    /// the token because verification handling is done.
+    pub fn start_failure<'src_data>(
+        &self,
+        src_data_buf: &'src_data mut [u8],
+        token: VerificationToken<TcStateAccepted>,
+        seq_count: u16,
+        msg_count: u16,
+        params: FailParams<'src_data, '_>,
+    ) -> Result<
+        VerificationSendable<'src_data, TcStateAccepted, VerifFailure>,
+        VerificationErrorWithToken<TcStateAccepted>,
+    > {
+        self.sendable_failure_no_step(
+            src_data_buf,
+            Subservice::TmStartFailure.into(),
+            token,
+            seq_count,
+            msg_count,
+            None::<&dyn EcssEnumeration>,
+            &params,
+        )
+    }
+
+    pub fn send_start_failure(
+        &self,
+        mut sendable: VerificationSendable<'_, TcStateAccepted, VerifFailure>,
+        sender: &mut (impl EcssTmSenderCore + ?Sized),
+    ) -> Result<(), VerificationOrSendErrorWithToken<TcStateAccepted>> {
+        sender
+            .send_tm(sendable.pus_tm.take().unwrap().into())
+            .map_err(|e| VerificationOrSendErrorWithToken(e, sendable.token.unwrap()))?;
+        sendable.send_success_verif_failure();
+        Ok(())
+    }
+
+    /// Package and send a PUS TM\[1, 5\] packet, see 8.1.2.5 of the PUS standard.
+    ///
+    /// Requires a token previously acquired by calling [Self::start_success].
+    pub fn step_success<'src_data>(
+        &mut self,
+        src_data_buf: &'src_data mut [u8],
+        token: &VerificationToken<TcStateStarted>,
+        seq_count: u16,
+        msg_count: u16,
+        time_stamp: Option<&'src_data [u8]>,
+        step: impl EcssEnumeration,
+    ) -> Result<VerificationSendable<'src_data, TcStateStarted, VerifSuccess>, EcssTmtcError> {
+        Ok(VerificationSendable::new_no_token(
+            self.create_pus_verif_success_tm(
+                src_data_buf,
+                Subservice::TmStepSuccess.into(),
+                seq_count,
+                msg_count,
+                &token.req_id,
+                time_stamp,
+                Some(&step),
+            )?,
+        ))
+    }
+
+    /// Package and send a PUS TM\[1, 6\] packet, see 8.1.2.6 of the PUS standard.
+    ///
+    /// Requires a token previously acquired by calling [Self::start_success]. It consumes the
+    /// token because verification handling is done.
+    pub fn step_failure<'src_data>(
+        &mut self,
+        src_data_buf: &'src_data mut [u8],
+        token: VerificationToken<TcStateStarted>,
+        seq_count: u16,
+        msg_count: u16,
+        params: FailParamsWithStep<'src_data, '_>,
+    ) -> Result<
+        VerificationSendable<'src_data, TcStateStarted, VerifFailure>,
+        VerificationErrorWithToken<TcStateStarted>,
+    > {
+        Ok(VerificationSendable::new(
+            self.create_pus_verif_fail_tm(
+                src_data_buf,
+                Subservice::TmStepFailure.into(),
+                seq_count,
+                msg_count,
+                &token.req_id,
+                Some(params.step),
+                &params.bp,
+            )
+            .map_err(|e| VerificationErrorWithToken(e, token))?,
+            token,
+        ))
+    }
+
+    /// Package and send a PUS TM\[1, 7\] packet, see 8.1.2.7 of the PUS standard.
+    ///
+    /// Requires a token previously acquired by calling [Self::start_success]. It consumes the
+    /// token because verification handling is done.
+    pub fn completion_success<'src_data, TcState: WasAtLeastAccepted + Copy>(
+        &mut self,
+        src_data_buf: &'src_data mut [u8],
+        token: VerificationToken<TcState>,
+        seq_counter: u16,
+        msg_counter: u16,
+        time_stamp: Option<&'src_data [u8]>,
+    ) -> Result<
+        VerificationSendable<'src_data, TcState, VerifSuccess>,
+        VerificationErrorWithToken<TcState>,
+    > {
+        self.sendable_success_no_step(
+            src_data_buf,
+            Subservice::TmCompletionSuccess.into(),
+            token,
+            seq_counter,
+            msg_counter,
+            time_stamp,
+        )
+    }
+
+    /// Package and send a PUS TM\[1, 8\] packet, see 8.1.2.8 of the PUS standard.
+    ///
+    /// Requires a token previously acquired by calling [Self::start_success]. It consumes the
+    /// token because verification handling is done.
+    pub fn completion_failure<'src_data, TcState: WasAtLeastAccepted + Copy>(
+        &mut self,
+        src_data_buf: &'src_data mut [u8],
+        token: VerificationToken<TcState>,
+        seq_count: u16,
+        msg_count: u16,
+        params: FailParams<'src_data, '_>,
+    ) -> Result<
+        VerificationSendable<'src_data, TcState, VerifFailure>,
+        VerificationErrorWithToken<TcState>,
+    > {
+        self.sendable_failure_no_step(
+            src_data_buf,
+            Subservice::TmCompletionFailure.into(),
+            token,
+            seq_count,
+            msg_count,
+            None::<&dyn EcssEnumeration>,
+            &params,
+        )
+    }
+
+    pub fn send_step_or_completion_success<TcState: WasAtLeastAccepted + Copy>(
+        &self,
+        mut sendable: VerificationSendable<'_, TcState, VerifSuccess>,
+        sender: &mut (impl EcssTmSenderCore + ?Sized),
+    ) -> Result<(), VerificationOrSendErrorWithToken<TcState>> {
+        sender
+            .send_tm(sendable.pus_tm.take().unwrap().into())
+            .map_err(|e| VerificationOrSendErrorWithToken(e, sendable.token.unwrap()))?;
+        sendable.send_success_step_or_completion_success();
+        Ok(())
+    }
+
+    pub fn send_step_or_completion_failure<TcState: WasAtLeastAccepted + Copy>(
+        &self,
+        mut sendable: VerificationSendable<'_, TcState, VerifFailure>,
+        sender: &mut (impl EcssTmSenderCore + ?Sized),
+    ) -> Result<(), VerificationOrSendErrorWithToken<TcState>> {
+        sender
+            .send_tm(sendable.pus_tm.take().unwrap().into())
+            .map_err(|e| VerificationOrSendErrorWithToken(e, sendable.token.unwrap()))?;
+        sendable.send_success_verif_failure();
+        Ok(())
+    }
+
+    // Internal helper function, too many arguments is acceptable for this case.
+    #[allow(clippy::too_many_arguments)]
+    fn create_pus_verif_success_tm<'src_data>(
+        &mut self,
+        src_data_buf: &'src_data mut [u8],
+        subservice: u8,
+        seq_count: u16,
+        msg_counter: u16,
+        req_id: &RequestId,
+        time_stamp: Option<&'src_data [u8]>,
+        step: Option<&(impl EcssEnumeration + ?Sized)>,
+    ) -> Result<PusTm<'src_data>, EcssTmtcError> {
+        let mut source_data_len = size_of::<u32>();
+        if let Some(step) = step {
+            source_data_len += step.size();
+        }
+        source_buffer_large_enough(src_data_buf.len(), source_data_len)?;
+        let mut idx = 0;
+        req_id.to_bytes(&mut src_data_buf[0..RequestId::SIZE_AS_BYTES]);
+        idx += RequestId::SIZE_AS_BYTES;
+        if let Some(step) = step {
+            // Size check was done beforehand
+            step.write_to_be_bytes(&mut src_data_buf[idx..idx + step.size()])
+                .unwrap();
+        }
+        let mut sp_header = SpHeader::tm_unseg(self.apid(), seq_count, 0).unwrap();
+        Ok(self.create_pus_verif_tm_base(
+            src_data_buf,
+            subservice,
+            msg_counter,
+            &mut sp_header,
+            time_stamp,
+            source_data_len,
+        ))
+    }
+
+    // Internal helper function, too many arguments is acceptable for this case.
+    #[allow(clippy::too_many_arguments)]
+    fn create_pus_verif_fail_tm<'src_data>(
+        &self,
+        src_data_buf: &'src_data mut [u8],
+        subservice: u8,
+        seq_count: u16,
+        msg_counter: u16,
+        req_id: &RequestId,
+        step: Option<&(impl EcssEnumeration + ?Sized)>,
+        params: &FailParams<'src_data, '_>,
+    ) -> Result<PusTm<'src_data>, EcssTmtcError> {
+        let mut idx = 0;
+        let mut source_data_len = RequestId::SIZE_AS_BYTES + params.failure_code.size();
+        if let Some(step) = step {
+            source_data_len += step.size();
+        }
+        if let Some(failure_data) = params.failure_data {
+            source_data_len += failure_data.len();
+        }
+        source_buffer_large_enough(src_data_buf.len(), source_data_len)?;
+        req_id.to_bytes(&mut src_data_buf[0..RequestId::SIZE_AS_BYTES]);
+        idx += RequestId::SIZE_AS_BYTES;
+        if let Some(step) = step {
+            // Size check done beforehand
+            step.write_to_be_bytes(&mut src_data_buf[idx..idx + step.size()])
+                .unwrap();
+            idx += step.size();
+        }
+        params
+            .failure_code
+            .write_to_be_bytes(&mut src_data_buf[idx..idx + params.failure_code.size()])
+            .map_err(PusError::ByteConversion)?;
+        idx += params.failure_code.size();
+        if let Some(failure_data) = params.failure_data {
+            src_data_buf[idx..idx + failure_data.len()].copy_from_slice(failure_data);
+        }
+        let mut sp_header = SpHeader::tm_unseg(self.apid(), seq_count, 0).unwrap();
+        Ok(self.create_pus_verif_tm_base(
+            src_data_buf,
+            subservice,
+            msg_counter,
+            &mut sp_header,
+            params.time_stamp,
+            source_data_len,
+        ))
+    }
+
+    fn create_pus_verif_tm_base<'src_data>(
+        &self,
+        src_data_buf: &'src_data mut [u8],
+        subservice: u8,
+        msg_counter: u16,
+        sp_header: &mut SpHeader,
+        time_stamp: Option<&'src_data [u8]>,
+        source_data_len: usize,
+    ) -> PusTm<'src_data> {
+        let tm_sec_header =
+            PusTmSecondaryHeader::new(1, subservice, msg_counter, self.dest_id, time_stamp);
+        PusTm::new(
+            sp_header,
+            tm_sec_header,
+            Some(&src_data_buf[0..source_data_len]),
+            true,
+        )
+    }
+}
+
+#[cfg(feature = "alloc")]
+mod alloc_mod {
+    use super::*;
+    use crate::pus::alloc_mod::EcssTmSender;
+    use crate::seq_count::SequenceCountProvider;
+    use alloc::boxed::Box;
+    use alloc::vec;
+    use alloc::vec::Vec;
+
+    #[derive(Clone)]
+    pub struct VerificationReporterCfg {
+        apid: u16,
+        pub step_field_width: usize,
+        pub fail_code_field_width: usize,
+        pub max_fail_data_len: usize,
+    }
+
+    impl VerificationReporterCfg {
+        pub fn new(
+            apid: u16,
+            step_field_width: usize,
+            fail_code_field_width: usize,
+            max_fail_data_len: usize,
+        ) -> Option<Self> {
+            if apid > MAX_APID {
+                return None;
+            }
+            Some(Self {
+                apid,
+                step_field_width,
+                fail_code_field_width,
+                max_fail_data_len,
+            })
+        }
+    }
+
+    /// Primary verification handler. It provides an API to send PUS 1 verification telemetry packets
+    /// and verify the various steps of telecommand handling as specified in the PUS standard.
+    /// It is assumed that the sequence counter and message counters are updated in a central
+    /// TM funnel. This helper will always set those fields to 0.
+    #[derive(Clone)]
+    pub struct VerificationReporter {
+        source_data_buf: Vec<u8>,
+        pub seq_count_provider: Option<Box<dyn SequenceCountProvider<u16> + Send>>,
+        pub msg_count_provider: Option<Box<dyn SequenceCountProvider<u16> + Send>>,
+        pub reporter: VerificationReporterCore,
+    }
+
+    impl VerificationReporter {
+        pub fn new(cfg: &VerificationReporterCfg) -> Self {
+            let reporter = VerificationReporterCore::new(cfg.apid).unwrap();
+            Self {
+                source_data_buf: vec![
+                    0;
+                    RequestId::SIZE_AS_BYTES
+                        + cfg.step_field_width
+                        + cfg.fail_code_field_width
+                        + cfg.max_fail_data_len
+                ],
+                seq_count_provider: None,
+                msg_count_provider: None,
+                reporter,
+            }
+        }
+
+        delegate!(
+            to self.reporter {
+                pub fn set_apid(&mut self, apid: u16) -> bool;
+                pub fn apid(&self) -> u16;
+                pub fn add_tc(&mut self, pus_tc: &PusTc) -> VerificationToken<TcStateNone>;
+                pub fn add_tc_with_req_id(&mut self, req_id: RequestId) -> VerificationToken<TcStateNone>;
+                pub fn dest_id(&self) -> u16;
+                pub fn set_dest_id(&mut self, dest_id: u16);
+            }
+        );
+
+        pub fn allowed_source_data_len(&self) -> usize {
+            self.source_data_buf.capacity()
+        }
+
+        /// Package and send a PUS TM\[1, 1\] packet, see 8.1.2.1 of the PUS standard
+        pub fn acceptance_success(
+            &mut self,
+            token: VerificationToken<TcStateNone>,
+            sender: &mut (impl EcssTmSenderCore + ?Sized),
+            time_stamp: Option<&[u8]>,
+        ) -> Result<VerificationToken<TcStateAccepted>, VerificationOrSendErrorWithToken<TcStateNone>>
+        {
+            let seq_count = self
+                .seq_count_provider
+                .as_ref()
+                .map_or(0, |v| v.get_and_increment());
+            let msg_count = self
+                .seq_count_provider
+                .as_ref()
+                .map_or(0, |v| v.get_and_increment());
+            let sendable = self.reporter.acceptance_success(
+                self.source_data_buf.as_mut_slice(),
+                token,
+                seq_count,
+                msg_count,
+                time_stamp,
+            )?;
+            self.reporter.send_acceptance_success(sendable, sender)
+        }
+
+        /// Package and send a PUS TM\[1, 2\] packet, see 8.1.2.2 of the PUS standard
+        pub fn acceptance_failure(
+            &mut self,
+            token: VerificationToken<TcStateNone>,
+            sender: &mut (impl EcssTmSenderCore + ?Sized),
+            params: FailParams,
+        ) -> Result<(), VerificationOrSendErrorWithToken<TcStateNone>> {
+            let seq_count = self
+                .seq_count_provider
+                .as_ref()
+                .map_or(0, |v| v.get_and_increment());
+            let msg_count = self
+                .seq_count_provider
+                .as_ref()
+                .map_or(0, |v| v.get_and_increment());
+            let sendable = self.reporter.acceptance_failure(
+                self.source_data_buf.as_mut_slice(),
+                token,
+                seq_count,
+                msg_count,
+                params,
+            )?;
+            self.reporter.send_acceptance_failure(sendable, sender)
+        }
+
+        /// Package and send a PUS TM\[1, 3\] packet, see 8.1.2.3 of the PUS standard.
+        ///
+        /// Requires a token previously acquired by calling [Self::acceptance_success].
+        pub fn start_success(
+            &mut self,
+            token: VerificationToken<TcStateAccepted>,
+            sender: &mut (impl EcssTmSenderCore + ?Sized),
+            time_stamp: Option<&[u8]>,
+        ) -> Result<
+            VerificationToken<TcStateStarted>,
+            VerificationOrSendErrorWithToken<TcStateAccepted>,
+        > {
+            let seq_count = self
+                .seq_count_provider
+                .as_ref()
+                .map_or(0, |v| v.get_and_increment());
+            let msg_count = self
+                .seq_count_provider
+                .as_ref()
+                .map_or(0, |v| v.get_and_increment());
+            let sendable = self.reporter.start_success(
+                self.source_data_buf.as_mut_slice(),
+                token,
+                seq_count,
+                msg_count,
+                time_stamp,
+            )?;
+            self.reporter.send_start_success(sendable, sender)
+        }
+
+        /// Package and send a PUS TM\[1, 4\] packet, see 8.1.2.4 of the PUS standard.
+        ///
+        /// Requires a token previously acquired by calling [Self::acceptance_success]. It consumes
+        /// the token because verification handling is done.
+        pub fn start_failure(
+            &mut self,
+            token: VerificationToken<TcStateAccepted>,
+            sender: &mut (impl EcssTmSenderCore + ?Sized),
+            params: FailParams,
+        ) -> Result<(), VerificationOrSendErrorWithToken<TcStateAccepted>> {
+            let seq_count = self
+                .seq_count_provider
+                .as_ref()
+                .map_or(0, |v| v.get_and_increment());
+            let msg_count = self
+                .seq_count_provider
+                .as_ref()
+                .map_or(0, |v| v.get_and_increment());
+            let sendable = self.reporter.start_failure(
+                self.source_data_buf.as_mut_slice(),
+                token,
+                seq_count,
+                msg_count,
+                params,
+            )?;
+            self.reporter.send_start_failure(sendable, sender)
+        }
+
+        /// Package and send a PUS TM\[1, 5\] packet, see 8.1.2.5 of the PUS standard.
+        ///
+        /// Requires a token previously acquired by calling [Self::start_success].
+        pub fn step_success(
+            &mut self,
+            token: &VerificationToken<TcStateStarted>,
+            sender: &mut (impl EcssTmSenderCore + ?Sized),
+            time_stamp: Option<&[u8]>,
+            step: impl EcssEnumeration,
+        ) -> Result<(), EcssTmtcError> {
+            let seq_count = self
+                .seq_count_provider
+                .as_ref()
+                .map_or(0, |v| v.get_and_increment());
+            let msg_count = self
+                .seq_count_provider
+                .as_ref()
+                .map_or(0, |v| v.get_and_increment());
+            let sendable = self.reporter.step_success(
+                self.source_data_buf.as_mut_slice(),
+                token,
+                seq_count,
+                msg_count,
+                time_stamp,
+                step,
+            )?;
+            self.reporter
+                .send_step_or_completion_success(sendable, sender)
+                .map_err(|e| e.0)
+        }
+
+        /// Package and send a PUS TM\[1, 6\] packet, see 8.1.2.6 of the PUS standard.
+        ///
+        /// Requires a token previously acquired by calling [Self::start_success]. It consumes the
+        /// token because verification handling is done.
+        pub fn step_failure(
+            &mut self,
+            token: VerificationToken<TcStateStarted>,
+            sender: &mut (impl EcssTmSenderCore + ?Sized),
+            params: FailParamsWithStep,
+        ) -> Result<(), VerificationOrSendErrorWithToken<TcStateStarted>> {
+            let seq_count = self
+                .seq_count_provider
+                .as_ref()
+                .map_or(0, |v| v.get_and_increment());
+            let msg_count = self
+                .seq_count_provider
+                .as_ref()
+                .map_or(0, |v| v.get_and_increment());
+            let sendable = self.reporter.step_failure(
+                self.source_data_buf.as_mut_slice(),
+                token,
+                seq_count,
+                msg_count,
+                params,
+            )?;
+            self.reporter
+                .send_step_or_completion_failure(sendable, sender)
+        }
+
+        /// Package and send a PUS TM\[1, 7\] packet, see 8.1.2.7 of the PUS standard.
+        ///
+        /// Requires a token previously acquired by calling [Self::start_success]. It consumes the
+        /// token because verification handling is done.
+        pub fn completion_success<TcState: WasAtLeastAccepted + Copy>(
+            &mut self,
+            token: VerificationToken<TcState>,
+            sender: &mut (impl EcssTmSenderCore + ?Sized),
+            time_stamp: Option<&[u8]>,
+        ) -> Result<(), VerificationOrSendErrorWithToken<TcState>> {
+            let seq_count = self
+                .seq_count_provider
+                .as_ref()
+                .map_or(0, |v| v.get_and_increment());
+            let msg_count = self
+                .seq_count_provider
+                .as_ref()
+                .map_or(0, |v| v.get_and_increment());
+            let sendable = self.reporter.completion_success(
+                self.source_data_buf.as_mut_slice(),
+                token,
+                seq_count,
+                msg_count,
+                time_stamp,
+            )?;
+            self.reporter
+                .send_step_or_completion_success(sendable, sender)
+        }
+
+        /// Package and send a PUS TM\[1, 8\] packet, see 8.1.2.8 of the PUS standard.
+        ///
+        /// Requires a token previously acquired by calling [Self::start_success]. It consumes the
+        /// token because verification handling is done.
+        pub fn completion_failure<TcState: WasAtLeastAccepted + Copy>(
+            &mut self,
+            token: VerificationToken<TcState>,
+            sender: &mut (impl EcssTmSenderCore + ?Sized),
+            params: FailParams,
+        ) -> Result<(), VerificationOrSendErrorWithToken<TcState>> {
+            let seq_count = self
+                .seq_count_provider
+                .as_ref()
+                .map_or(0, |v| v.get_and_increment());
+            let msg_count = self
+                .seq_count_provider
+                .as_ref()
+                .map_or(0, |v| v.get_and_increment());
+            let sendable = self.reporter.completion_failure(
+                self.source_data_buf.as_mut_slice(),
+                token,
+                seq_count,
+                msg_count,
+                params,
+            )?;
+            self.reporter
+                .send_step_or_completion_failure(sendable, sender)
+        }
+    }
+
+    /// Helper object which caches the sender passed as a trait object. Provides the same
+    /// API as [VerificationReporter] but without the explicit sender arguments.
+    #[derive(Clone)]
+    pub struct VerificationReporterWithSender {
+        pub reporter: VerificationReporter,
+        pub sender: Box<dyn EcssTmSender>,
+    }
+
+    impl VerificationReporterWithSender {
+        pub fn new(cfg: &VerificationReporterCfg, sender: Box<dyn EcssTmSender>) -> Self {
+            let reporter = VerificationReporter::new(cfg);
+            Self::new_from_reporter(reporter, sender)
+        }
+
+        pub fn new_from_reporter(
+            reporter: VerificationReporter,
+            sender: Box<dyn EcssTmSender>,
+        ) -> Self {
+            Self { reporter, sender }
+        }
+
+        delegate! {
+            to self.reporter {
+                pub fn set_apid(&mut self, apid: u16) -> bool;
+                pub fn apid(&self) -> u16;
+                pub fn add_tc(&mut self, pus_tc: &PusTc) -> VerificationToken<TcStateNone>;
+                pub fn add_tc_with_req_id(&mut self, req_id: RequestId) -> VerificationToken<TcStateNone>;
+                pub fn dest_id(&self) -> u16;
+                pub fn set_dest_id(&mut self, dest_id: u16);
+            }
+        }
+
+        pub fn acceptance_success(
+            &mut self,
+            token: VerificationToken<TcStateNone>,
+            time_stamp: Option<&[u8]>,
+        ) -> Result<VerificationToken<TcStateAccepted>, VerificationOrSendErrorWithToken<TcStateNone>>
+        {
+            self.reporter
+                .acceptance_success(token, self.sender.as_mut(), time_stamp)
+        }
+
+        pub fn acceptance_failure(
+            &mut self,
+            token: VerificationToken<TcStateNone>,
+            params: FailParams,
+        ) -> Result<(), VerificationOrSendErrorWithToken<TcStateNone>> {
+            self.reporter
+                .acceptance_failure(token, self.sender.as_mut(), params)
+        }
+
+        pub fn start_success(
+            &mut self,
+            token: VerificationToken<TcStateAccepted>,
+            time_stamp: Option<&[u8]>,
+        ) -> Result<
+            VerificationToken<TcStateStarted>,
+            VerificationOrSendErrorWithToken<TcStateAccepted>,
+        > {
+            self.reporter
+                .start_success(token, self.sender.as_mut(), time_stamp)
+        }
+
+        pub fn start_failure(
+            &mut self,
+            token: VerificationToken<TcStateAccepted>,
+            params: FailParams,
+        ) -> Result<(), VerificationOrSendErrorWithToken<TcStateAccepted>> {
+            self.reporter
+                .start_failure(token, self.sender.as_mut(), params)
+        }
+
+        pub fn step_success(
+            &mut self,
+            token: &VerificationToken<TcStateStarted>,
+            time_stamp: Option<&[u8]>,
+            step: impl EcssEnumeration,
+        ) -> Result<(), EcssTmtcError> {
+            self.reporter
+                .step_success(token, self.sender.as_mut(), time_stamp, step)
+        }
+
+        pub fn step_failure(
+            &mut self,
+            token: VerificationToken<TcStateStarted>,
+            params: FailParamsWithStep,
+        ) -> Result<(), VerificationOrSendErrorWithToken<TcStateStarted>> {
+            self.reporter
+                .step_failure(token, self.sender.as_mut(), params)
+        }
+
+        pub fn completion_success<TcState: WasAtLeastAccepted + Copy>(
+            &mut self,
+            token: VerificationToken<TcState>,
+            time_stamp: Option<&[u8]>,
+        ) -> Result<(), VerificationOrSendErrorWithToken<TcState>> {
+            self.reporter
+                .completion_success(token, self.sender.as_mut(), time_stamp)
+        }
+
+        pub fn completion_failure<TcState: WasAtLeastAccepted + Copy>(
+            &mut self,
+            token: VerificationToken<TcState>,
+            params: FailParams,
+        ) -> Result<(), VerificationOrSendErrorWithToken<TcState>> {
+            self.reporter
+                .completion_failure(token, self.sender.as_mut(), params)
+        }
+    }
+}
+
+#[cfg(feature = "std")]
+mod std_mod {
+    use crate::pus::verification::VerificationReporterWithSender;
+    use std::sync::{Arc, Mutex};
+
+    //     use super::alloc_mod::VerificationReporterWithSender;
+    //     use super::*;
+    //     use crate::pool::{ShareablePoolProvider, SharedPool, StoreAddr};
+    //     use crate::pus::{EcssSender, MpscPusInStoreSendError, PusTmWrapper};
+    //     use crate::SenderId;
+    //     use delegate::delegate;
+    //     use spacepackets::ecss::SerializablePusPacket;
+    //     use std::sync::{mpsc, Arc, Mutex, RwLockWriteGuard};
+    //
+    pub type StdVerifReporterWithSender = VerificationReporterWithSender;
+    pub type SharedStdVerifReporterWithSender = Arc<Mutex<StdVerifReporterWithSender>>;
+    //
+    //     trait SendBackend: Send {
+    //         type SendError: Debug;
+    //
+    //         fn send(&self, addr: StoreAddr) -> Result<(), Self::SendError>;
+    //     }
+    //
+    //     #[derive(Clone)]
+    //     struct StdSenderBase<S> {
+    //         id: SenderId,
+    //         name: &'static str,
+    //         tm_store: SharedPool,
+    //         tx: S,
+    //         pub ignore_poison_error: bool,
+    //     }
+    //
+    //     impl<S: SendBackend> StdSenderBase<S> {
+    //         pub fn new(id: SenderId, name: &'static str, tm_store: SharedPool, tx: S) -> Self {
+    //             Self {
+    //                 id,
+    //                 name,
+    //                 tm_store,
+    //                 tx,
+    //                 ignore_poison_error: false,
+    //             }
+    //         }
+    //     }
+    //
+    //     unsafe impl<S: Sync> Sync for StdSenderBase<S> {}
+    //     unsafe impl<S: Send> Send for StdSenderBase<S> {}
+    //
+    //     impl SendBackend for mpsc::Sender<StoreAddr> {
+    //         type SendError = mpsc::SendError<StoreAddr>;
+    //
+    //         fn send(&self, addr: StoreAddr) -> Result<(), Self::SendError> {
+    //             self.send(addr)
+    //         }
+    //     }
+    //
+    //     #[derive(Clone)]
+    //     pub struct MpscVerifSender {
+    //         base: StdSenderBase<mpsc::Sender<StoreAddr>>,
+    //     }
+    //
+    //     /// Verification sender with a [mpsc::Sender] backend.
+    //     /// It implements the [EcssTmSenderCore] trait to be used as PUS Verification TM sender.
+    //     impl MpscVerifSender {
+    //         pub fn new(
+    //             id: SenderId,
+    //             name: &'static str,
+    //             tm_store: SharedPool,
+    //             tx: mpsc::Sender<StoreAddr>,
+    //         ) -> Self {
+    //             Self {
+    //                 base: StdSenderBase::new(id, name, tm_store, tx),
+    //             }
+    //         }
+    //     }
+    //
+    //     //noinspection RsTraitImplementation
+    //     impl EcssSender for MpscVerifSender {
+    //         delegate!(
+    //             to self.base {
+    //                 fn id(&self) -> SenderId;
+    //                 fn name(&self) -> &'static str;
+    //             }
+    //         );
+    //     }
+    //
+    //     //noinspection RsTraitImplementation
+    //     impl EcssTmSenderCore for MpscVerifSender {
+    //         type Error = MpscPusInStoreSendError;
+    //
+    //         delegate!(
+    //             to self.base {
+    //                 fn send_tm(&self, tm: PusTmWrapper) -> Result<(), Self::Error>;
+    //             }
+    //         );
+    //     }
+    //
+    //     impl SendBackend for crossbeam_channel::Sender<StoreAddr> {
+    //         type SendError = crossbeam_channel::SendError<StoreAddr>;
+    //
+    //         fn send(&self, addr: StoreAddr) -> Result<(), Self::SendError> {
+    //             self.send(addr)
+    //         }
+    //     }
+    //
+    //     /// Verification sender with a [crossbeam_channel::Sender] backend.
+    //     /// It implements the [EcssTmSenderCore] trait to be used as PUS Verification TM sender
+    //     #[cfg(feature = "crossbeam")]
+    //     #[derive(Clone)]
+    //     pub struct CrossbeamVerifSender {
+    //         base: StdSenderBase<crossbeam_channel::Sender<StoreAddr>>,
+    //     }
+    //
+    //     #[cfg(feature = "crossbeam")]
+    //     impl CrossbeamVerifSender {
+    //         pub fn new(
+    //             id: SenderId,
+    //             name: &'static str,
+    //             tm_store: SharedPool,
+    //             tx: crossbeam_channel::Sender<StoreAddr>,
+    //         ) -> Self {
+    //             Self {
+    //                 base: StdSenderBase::new(id, name, tm_store, tx),
+    //             }
+    //         }
+    //     }
+    //
+    //     //noinspection RsTraitImplementation
+    //     #[cfg(feature = "crossbeam")]
+    //     impl EcssSender for CrossbeamVerifSender {
+    //         delegate!(
+    //             to self.base {
+    //                 fn id(&self) -> SenderId;
+    //                 fn name(&self) -> &'static str;
+    //             }
+    //         );
+    //     }
+    //
+    //     //noinspection RsTraitImplementation
+    //     #[cfg(feature = "crossbeam")]
+    //     impl EcssTmSenderCore for CrossbeamVerifSender {
+    //         type Error = MpscPusInStoreSendError;
+    //
+    //         delegate!(
+    //             to self.base {
+    //                 fn send_tm(&mut self, tm: PusTm) -> Result<(), Self::Error>;
+    //             }
+    //         );
+    //     }
+    //
+    //     impl<S: SendBackend + Clone + 'static> EcssSender for StdSenderBase<S> {
+    //         fn id(&self) -> SenderId {
+    //             self.id
+    //         }
+    //         fn name(&self) -> &'static str {
+    //             self.name
+    //         }
+    //     }
+    //     impl<S: SendBackend + Clone + 'static> EcssTmSenderCore for StdSenderBase<S> {
+    //         type Error = MpscPusInStoreSendError;
+    //
+    //         fn send_tm(&self, tm: PusTmWrapper) -> Result<(), Self::Error> {
+    //             match tm {
+    //                 PusTmWrapper::InStore(addr) => {
+    //                     self.tx.send(addr).unwrap();
+    //                     Ok(())
+    //                 }
+    //                 PusTmWrapper::Direct(tm) => {
+    //                     let operation = |mut mg: RwLockWriteGuard<ShareablePoolProvider>| {
+    //                         let (addr, buf) = mg.free_element(tm.len_packed())?;
+    //                         tm.write_to_bytes(buf)
+    //                             .map_err(MpscPusInStoreSendError::Pus)?;
+    //                         drop(mg);
+    //                         self.tx
+    //                             .send(addr)
+    //                             .map_err(|_| MpscPusInStoreSendError::RxDisconnected(addr))?;
+    //                         Ok(())
+    //                     };
+    //                     match self.tm_store.write() {
+    //                         Ok(lock) => operation(lock),
+    //                         Err(poison_error) => {
+    //                             if self.ignore_poison_error {
+    //                                 operation(poison_error.into_inner())
+    //                             } else {
+    //                                 Err(MpscPusInStoreSendError::StoreLock)
+    //                             }
+    //                         }
+    //                     }
+    //                 }
+    //             }
+    //         }
+    //     }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::pool::{LocalPool, PoolCfg};
+    use crate::pus::tests::CommonTmInfo;
+    use crate::pus::verification::{
+        EcssTmSenderCore, EcssTmtcError, FailParams, FailParamsWithStep, RequestId, TcStateNone,
+        VerificationReporter, VerificationReporterCfg, VerificationReporterWithSender,
+        VerificationToken,
+    };
+    use crate::pus::{EcssChannel, MpscTmInStoreSender, PusTmWrapper};
+    use crate::tmtc::tm_helper::SharedTmStore;
+    use crate::ChannelId;
+    use alloc::boxed::Box;
+    use alloc::format;
+    use spacepackets::ecss::{EcssEnumU16, EcssEnumU32, EcssEnumU8, PusError, PusPacket};
+    use spacepackets::tc::{PusTc, PusTcSecondaryHeader};
+    use spacepackets::tm::PusTm;
+    use spacepackets::util::UnsignedEnum;
+    use spacepackets::{ByteConversionError, CcsdsPacket, SpHeader};
+    use std::cell::RefCell;
+    use std::collections::VecDeque;
+    use std::sync::mpsc;
+    use std::time::Duration;
+    use std::vec;
+    use std::vec::Vec;
+
+    fn is_send<T: Send>(_: &T) {}
+    #[allow(dead_code)]
+    fn is_sync<T: Sync>(_: &T) {}
+
+    const TEST_APID: u16 = 0x02;
+    const EMPTY_STAMP: [u8; 7] = [0; 7];
+
+    #[derive(Debug, Eq, PartialEq, Clone)]
+    struct TmInfo {
+        pub common: CommonTmInfo,
+        pub req_id: RequestId,
+        pub additional_data: Option<Vec<u8>>,
+    }
+
+    #[derive(Default, Clone)]
+    struct TestSender {
+        pub service_queue: RefCell<VecDeque<TmInfo>>,
+    }
+
+    impl EcssChannel for TestSender {
+        fn id(&self) -> ChannelId {
+            0
+        }
+        fn name(&self) -> &'static str {
+            "test_sender"
+        }
+    }
+
+    impl EcssTmSenderCore for TestSender {
+        fn send_tm(&self, tm: PusTmWrapper) -> Result<(), EcssTmtcError> {
+            match tm {
+                PusTmWrapper::InStore(_) => {
+                    panic!("TestSender: Can not deal with addresses");
+                }
+                PusTmWrapper::Direct(tm) => {
+                    assert_eq!(PusPacket::service(&tm), 1);
+                    assert!(tm.source_data().is_some());
+                    let mut time_stamp = [0; 7];
+                    time_stamp.clone_from_slice(&tm.timestamp().unwrap()[0..7]);
+                    let src_data = tm.source_data().unwrap();
+                    assert!(src_data.len() >= 4);
+                    let req_id =
+                        RequestId::from_bytes(&src_data[0..RequestId::SIZE_AS_BYTES]).unwrap();
+                    let mut vec = None;
+                    if src_data.len() > 4 {
+                        let mut new_vec = Vec::new();
+                        new_vec.extend_from_slice(&src_data[RequestId::SIZE_AS_BYTES..]);
+                        vec = Some(new_vec);
+                    }
+                    self.service_queue.borrow_mut().push_back(TmInfo {
+                        common: CommonTmInfo::new_from_tm(&tm),
+                        req_id,
+                        additional_data: vec,
+                    });
+                    Ok(())
+                }
+            }
+        }
+    }
+
+    struct TestBase<'a> {
+        vr: VerificationReporter,
+        #[allow(dead_code)]
+        tc: PusTc<'a>,
+    }
+
+    impl<'a> TestBase<'a> {
+        fn rep(&mut self) -> &mut VerificationReporter {
+            &mut self.vr
+        }
+    }
+    struct TestBaseWithHelper<'a> {
+        helper: VerificationReporterWithSender,
+        #[allow(dead_code)]
+        tc: PusTc<'a>,
+    }
+
+    impl<'a> TestBaseWithHelper<'a> {
+        fn rep(&mut self) -> &mut VerificationReporter {
+            &mut self.helper.reporter
+        }
+    }
+
+    fn base_reporter() -> VerificationReporter {
+        let cfg = VerificationReporterCfg::new(TEST_APID, 1, 2, 8).unwrap();
+        VerificationReporter::new(&cfg)
+    }
+
+    fn base_tc_init(app_data: Option<&[u8]>) -> (PusTc, RequestId) {
+        let mut sph = SpHeader::tc_unseg(TEST_APID, 0x34, 0).unwrap();
+        let tc_header = PusTcSecondaryHeader::new_simple(17, 1);
+        let pus_tc = PusTc::new(&mut sph, tc_header, app_data, true);
+        let req_id = RequestId::new(&pus_tc);
+        (pus_tc, req_id)
+    }
+
+    fn base_init(api_sel: bool) -> (TestBase<'static>, VerificationToken<TcStateNone>) {
+        let mut reporter = base_reporter();
+        let (tc, req_id) = base_tc_init(None);
+        let init_tok;
+        if api_sel {
+            init_tok = reporter.add_tc_with_req_id(req_id);
+        } else {
+            init_tok = reporter.add_tc(&tc);
+        }
+        (TestBase { vr: reporter, tc }, init_tok)
+    }
+
+    fn base_with_helper_init() -> (TestBaseWithHelper<'static>, VerificationToken<TcStateNone>) {
+        let mut reporter = base_reporter();
+        let (tc, _) = base_tc_init(None);
+        let init_tok = reporter.add_tc(&tc);
+        let sender = TestSender::default();
+        let helper = VerificationReporterWithSender::new_from_reporter(reporter, Box::new(sender));
+        (TestBaseWithHelper { helper, tc }, init_tok)
+    }
+
+    fn acceptance_check(sender: &mut TestSender, req_id: &RequestId) {
+        let cmp_info = TmInfo {
+            common: CommonTmInfo {
+                subservice: 1,
+                apid: TEST_APID,
+                msg_counter: 0,
+                dest_id: 0,
+                time_stamp: EMPTY_STAMP,
+            },
+            additional_data: None,
+            req_id: req_id.clone(),
+        };
+        let mut service_queue = sender.service_queue.borrow_mut();
+        assert_eq!(service_queue.len(), 1);
+        let info = service_queue.pop_front().unwrap();
+        assert_eq!(info, cmp_info);
+    }
+
+    #[test]
+    fn test_mpsc_verif_send_sync() {
+        let pool = LocalPool::new(PoolCfg::new(vec![(8, 8)]));
+        let tm_store = Box::new(pool);
+        let shared_tm_store = SharedTmStore::new(tm_store);
+        let (tx, _) = mpsc::channel();
+        let mpsc_verif_sender = MpscTmInStoreSender::new(0, "verif_sender", shared_tm_store, tx);
+        is_send(&mpsc_verif_sender);
+    }
+
+    #[test]
+    fn test_state() {
+        let (mut b, _) = base_init(false);
+        assert_eq!(b.vr.apid(), TEST_APID);
+        b.vr.set_apid(TEST_APID + 1);
+        assert_eq!(b.vr.apid(), TEST_APID + 1);
+    }
+
+    #[test]
+    fn test_basic_acceptance_success() {
+        let (mut b, tok) = base_init(false);
+        let mut sender = TestSender::default();
+        b.vr.acceptance_success(tok, &mut sender, Some(&EMPTY_STAMP))
+            .expect("Sending acceptance success failed");
+        acceptance_check(&mut sender, &tok.req_id);
+    }
+
+    #[test]
+    fn test_basic_acceptance_success_with_helper() {
+        let (mut b, tok) = base_with_helper_init();
+        b.helper
+            .acceptance_success(tok, Some(&EMPTY_STAMP))
+            .expect("Sending acceptance success failed");
+        let sender: &mut TestSender = b.helper.sender.downcast_mut().unwrap();
+        acceptance_check(sender, &tok.req_id);
+    }
+
+    fn acceptance_fail_check(sender: &mut TestSender, req_id: RequestId, stamp_buf: [u8; 7]) {
+        let cmp_info = TmInfo {
+            common: CommonTmInfo {
+                subservice: 2,
+                apid: TEST_APID,
+                msg_counter: 0,
+                dest_id: 5,
+                time_stamp: stamp_buf,
+            },
+            additional_data: Some([0, 2].to_vec()),
+            req_id,
+        };
+        let mut service_queue = sender.service_queue.borrow_mut();
+        assert_eq!(service_queue.len(), 1);
+        let info = service_queue.pop_front().unwrap();
+        assert_eq!(info, cmp_info);
+    }
+
+    #[test]
+    fn test_basic_acceptance_failure() {
+        let (mut b, tok) = base_init(true);
+        b.rep().reporter.dest_id = 5;
+        let stamp_buf = [1, 2, 3, 4, 5, 6, 7];
+        let mut sender = TestSender::default();
+        let fail_code = EcssEnumU16::new(2);
+        let fail_params = FailParams::new(Some(stamp_buf.as_slice()), &fail_code, None);
+        b.vr.acceptance_failure(tok, &mut sender, fail_params)
+            .expect("Sending acceptance success failed");
+        acceptance_fail_check(&mut sender, tok.req_id, stamp_buf);
+    }
+
+    #[test]
+    fn test_basic_acceptance_failure_with_helper() {
+        let (mut b, tok) = base_with_helper_init();
+        b.rep().reporter.dest_id = 5;
+        let stamp_buf = [1, 2, 3, 4, 5, 6, 7];
+        let fail_code = EcssEnumU16::new(2);
+        let fail_params = FailParams::new(Some(stamp_buf.as_slice()), &fail_code, None);
+        b.helper
+            .acceptance_failure(tok, fail_params)
+            .expect("Sending acceptance success failed");
+        let sender: &mut TestSender = b.helper.sender.downcast_mut().unwrap();
+        acceptance_fail_check(sender, tok.req_id, stamp_buf);
+    }
+
+    #[test]
+    fn test_acceptance_fail_data_too_large() {
+        let (mut b, tok) = base_with_helper_init();
+        b.rep().reporter.dest_id = 5;
+        let stamp_buf = [1, 2, 3, 4, 5, 6, 7];
+        let fail_code = EcssEnumU16::new(2);
+        let fail_data: [u8; 16] = [0; 16];
+        // 4 req ID + 1 byte step + 2 byte error code + 8 byte fail data
+        assert_eq!(b.rep().allowed_source_data_len(), 15);
+        let fail_params = FailParams::new(
+            Some(stamp_buf.as_slice()),
+            &fail_code,
+            Some(fail_data.as_slice()),
+        );
+        let res = b.helper.acceptance_failure(tok, fail_params);
+        assert!(res.is_err());
+        let err_with_token = res.unwrap_err();
+        assert_eq!(err_with_token.1, tok);
+        match err_with_token.0 {
+            EcssTmtcError::Pus(PusError::ByteConversion(e)) => match e {
+                ByteConversionError::ToSliceTooSmall(missmatch) => {
+                    assert_eq!(
+                        missmatch.expected,
+                        fail_data.len() + RequestId::SIZE_AS_BYTES + fail_code.size()
+                    );
+                    assert_eq!(missmatch.found, b.rep().allowed_source_data_len());
+                }
+                _ => {
+                    panic!("{}", format!("Unexpected error {:?}", e))
+                }
+            },
+            _ => {
+                panic!("{}", format!("Unexpected error {:?}", err_with_token.0))
+            }
+        }
+    }
+
+    #[test]
+    fn test_basic_acceptance_failure_with_fail_data() {
+        let (mut b, tok) = base_init(false);
+        let mut sender = TestSender::default();
+        let fail_code = EcssEnumU8::new(10);
+        let fail_data = EcssEnumU32::new(12);
+        let mut fail_data_raw = [0; 4];
+        fail_data.write_to_be_bytes(&mut fail_data_raw).unwrap();
+        let fail_params = FailParams::new(
+            Some(&EMPTY_STAMP),
+            &fail_code,
+            Some(fail_data_raw.as_slice()),
+        );
+        b.vr.acceptance_failure(tok, &mut sender, fail_params)
+            .expect("Sending acceptance success failed");
+        let cmp_info = TmInfo {
+            common: CommonTmInfo {
+                subservice: 2,
+                apid: TEST_APID,
+                msg_counter: 0,
+                dest_id: 0,
+                time_stamp: EMPTY_STAMP,
+            },
+            additional_data: Some([10, 0, 0, 0, 12].to_vec()),
+            req_id: tok.req_id,
+        };
+        let mut service_queue = sender.service_queue.borrow_mut();
+        assert_eq!(service_queue.len(), 1);
+        let info = service_queue.pop_front().unwrap();
+        assert_eq!(info, cmp_info);
+    }
+
+    fn start_fail_check(sender: &mut TestSender, req_id: RequestId, fail_data_raw: [u8; 4]) {
+        let mut srv_queue = sender.service_queue.borrow_mut();
+        assert_eq!(srv_queue.len(), 2);
+        let mut cmp_info = TmInfo {
+            common: CommonTmInfo {
+                subservice: 1,
+                apid: TEST_APID,
+                msg_counter: 0,
+                dest_id: 0,
+                time_stamp: EMPTY_STAMP,
+            },
+            additional_data: None,
+            req_id,
+        };
+        let mut info = srv_queue.pop_front().unwrap();
+        assert_eq!(info, cmp_info);
+
+        cmp_info = TmInfo {
+            common: CommonTmInfo {
+                subservice: 4,
+                apid: TEST_APID,
+                msg_counter: 0,
+                dest_id: 0,
+                time_stamp: EMPTY_STAMP,
+            },
+            additional_data: Some([&[22], fail_data_raw.as_slice()].concat().to_vec()),
+            req_id,
+        };
+        info = srv_queue.pop_front().unwrap();
+        assert_eq!(info, cmp_info);
+    }
+
+    #[test]
+    fn test_start_failure() {
+        let (mut b, tok) = base_init(false);
+        let mut sender = TestSender::default();
+        let fail_code = EcssEnumU8::new(22);
+        let fail_data: i32 = -12;
+        let mut fail_data_raw = [0; 4];
+        fail_data_raw.copy_from_slice(fail_data.to_be_bytes().as_slice());
+        let fail_params = FailParams::new(
+            Some(&EMPTY_STAMP),
+            &fail_code,
+            Some(fail_data_raw.as_slice()),
+        );
+
+        let accepted_token =
+            b.vr.acceptance_success(tok, &mut sender, Some(&EMPTY_STAMP))
+                .expect("Sending acceptance success failed");
+        let empty =
+            b.vr.start_failure(accepted_token, &mut sender, fail_params)
+                .expect("Start failure failure");
+        assert_eq!(empty, ());
+        start_fail_check(&mut sender, tok.req_id, fail_data_raw);
+    }
+
+    #[test]
+    fn test_start_failure_with_helper() {
+        let (mut b, tok) = base_with_helper_init();
+        let fail_code = EcssEnumU8::new(22);
+        let fail_data: i32 = -12;
+        let mut fail_data_raw = [0; 4];
+        fail_data_raw.copy_from_slice(fail_data.to_be_bytes().as_slice());
+        let fail_params = FailParams::new(
+            Some(&EMPTY_STAMP),
+            &fail_code,
+            Some(fail_data_raw.as_slice()),
+        );
+
+        let accepted_token = b
+            .helper
+            .acceptance_success(tok, Some(&EMPTY_STAMP))
+            .expect("Sending acceptance success failed");
+        let empty = b
+            .helper
+            .start_failure(accepted_token, fail_params)
+            .expect("Start failure failure");
+        assert_eq!(empty, ());
+        let sender: &mut TestSender = b.helper.sender.downcast_mut().unwrap();
+        start_fail_check(sender, tok.req_id, fail_data_raw);
+    }
+
+    fn step_success_check(sender: &mut TestSender, req_id: RequestId) {
+        let mut cmp_info = TmInfo {
+            common: CommonTmInfo {
+                subservice: 1,
+                apid: TEST_APID,
+                msg_counter: 0,
+                dest_id: 0,
+                time_stamp: EMPTY_STAMP,
+            },
+            additional_data: None,
+            req_id,
+        };
+        let mut srv_queue = sender.service_queue.borrow_mut();
+        let mut info = srv_queue.pop_front().unwrap();
+        assert_eq!(info, cmp_info);
+        cmp_info = TmInfo {
+            common: CommonTmInfo {
+                subservice: 3,
+                apid: TEST_APID,
+                msg_counter: 0,
+                dest_id: 0,
+                time_stamp: [0, 1, 0, 1, 0, 1, 0],
+            },
+            additional_data: None,
+            req_id,
+        };
+        info = srv_queue.pop_front().unwrap();
+        assert_eq!(info, cmp_info);
+        cmp_info = TmInfo {
+            common: CommonTmInfo {
+                subservice: 5,
+                apid: TEST_APID,
+                msg_counter: 0,
+                dest_id: 0,
+                time_stamp: EMPTY_STAMP,
+            },
+            additional_data: Some([0].to_vec()),
+            req_id,
+        };
+        info = srv_queue.pop_front().unwrap();
+        assert_eq!(info, cmp_info);
+        cmp_info = TmInfo {
+            common: CommonTmInfo {
+                subservice: 5,
+                apid: TEST_APID,
+                msg_counter: 0,
+                dest_id: 0,
+                time_stamp: EMPTY_STAMP,
+            },
+            additional_data: Some([1].to_vec()),
+            req_id,
+        };
+        info = srv_queue.pop_front().unwrap();
+        assert_eq!(info, cmp_info);
+    }
+
+    #[test]
+    fn test_steps_success() {
+        let (mut b, tok) = base_init(false);
+        let mut sender = TestSender::default();
+        let accepted_token = b
+            .rep()
+            .acceptance_success(tok, &mut sender, Some(&EMPTY_STAMP))
+            .expect("Sending acceptance success failed");
+        let started_token = b
+            .rep()
+            .start_success(accepted_token, &mut sender, Some(&[0, 1, 0, 1, 0, 1, 0]))
+            .expect("Sending start success failed");
+        let mut empty = b
+            .rep()
+            .step_success(
+                &started_token,
+                &mut sender,
+                Some(&EMPTY_STAMP),
+                EcssEnumU8::new(0),
+            )
+            .expect("Sending step 0 success failed");
+        assert_eq!(empty, ());
+        empty =
+            b.vr.step_success(
+                &started_token,
+                &mut sender,
+                Some(&EMPTY_STAMP),
+                EcssEnumU8::new(1),
+            )
+            .expect("Sending step 1 success failed");
+        assert_eq!(empty, ());
+        assert_eq!(sender.service_queue.borrow().len(), 4);
+        step_success_check(&mut sender, tok.req_id);
+    }
+
+    #[test]
+    fn test_steps_success_with_helper() {
+        let (mut b, tok) = base_with_helper_init();
+        let accepted_token = b
+            .helper
+            .acceptance_success(tok, Some(&EMPTY_STAMP))
+            .expect("Sending acceptance success failed");
+        let started_token = b
+            .helper
+            .start_success(accepted_token, Some(&[0, 1, 0, 1, 0, 1, 0]))
+            .expect("Sending start success failed");
+        let mut empty = b
+            .helper
+            .step_success(&started_token, Some(&EMPTY_STAMP), EcssEnumU8::new(0))
+            .expect("Sending step 0 success failed");
+        assert_eq!(empty, ());
+        empty = b
+            .helper
+            .step_success(&started_token, Some(&EMPTY_STAMP), EcssEnumU8::new(1))
+            .expect("Sending step 1 success failed");
+        assert_eq!(empty, ());
+        let sender: &mut TestSender = b.helper.sender.downcast_mut().unwrap();
+        assert_eq!(sender.service_queue.borrow().len(), 4);
+        step_success_check(sender, tok.req_id);
+    }
+
+    fn check_step_failure(sender: &mut TestSender, req_id: RequestId, fail_data_raw: [u8; 4]) {
+        assert_eq!(sender.service_queue.borrow().len(), 4);
+        let mut cmp_info = TmInfo {
+            common: CommonTmInfo {
+                subservice: 1,
+                apid: TEST_APID,
+                msg_counter: 0,
+                dest_id: 0,
+                time_stamp: EMPTY_STAMP,
+            },
+            additional_data: None,
+            req_id,
+        };
+        let mut info = sender.service_queue.borrow_mut().pop_front().unwrap();
+        assert_eq!(info, cmp_info);
+
+        cmp_info = TmInfo {
+            common: CommonTmInfo {
+                subservice: 3,
+                apid: TEST_APID,
+                msg_counter: 0,
+                dest_id: 0,
+                time_stamp: [0, 1, 0, 1, 0, 1, 0],
+            },
+            additional_data: None,
+            req_id,
+        };
+        info = sender.service_queue.borrow_mut().pop_front().unwrap();
+        assert_eq!(info, cmp_info);
+
+        cmp_info = TmInfo {
+            common: CommonTmInfo {
+                subservice: 5,
+                apid: TEST_APID,
+                msg_counter: 0,
+                dest_id: 0,
+                time_stamp: EMPTY_STAMP,
+            },
+            additional_data: Some([0].to_vec()),
+            req_id,
+        };
+        info = sender.service_queue.get_mut().pop_front().unwrap();
+        assert_eq!(info, cmp_info);
+
+        cmp_info = TmInfo {
+            common: CommonTmInfo {
+                subservice: 6,
+                apid: TEST_APID,
+                msg_counter: 0,
+                dest_id: 0,
+                time_stamp: EMPTY_STAMP,
+            },
+            additional_data: Some(
+                [
+                    [1].as_slice(),
+                    &[0, 0, 0x10, 0x20],
+                    fail_data_raw.as_slice(),
+                ]
+                .concat()
+                .to_vec(),
+            ),
+            req_id,
+        };
+        info = sender.service_queue.get_mut().pop_front().unwrap();
+        assert_eq!(info, cmp_info);
+    }
+
+    #[test]
+    fn test_step_failure() {
+        let (mut b, tok) = base_init(false);
+        let mut sender = TestSender::default();
+        let req_id = tok.req_id;
+        let fail_code = EcssEnumU32::new(0x1020);
+        let fail_data: f32 = -22.3232;
+        let mut fail_data_raw = [0; 4];
+        fail_data_raw.copy_from_slice(fail_data.to_be_bytes().as_slice());
+        let fail_step = EcssEnumU8::new(1);
+        let fail_params = FailParamsWithStep::new(
+            Some(&EMPTY_STAMP),
+            &fail_step,
+            &fail_code,
+            Some(fail_data_raw.as_slice()),
+        );
+
+        let accepted_token =
+            b.vr.acceptance_success(tok, &mut sender, Some(&EMPTY_STAMP))
+                .expect("Sending acceptance success failed");
+        let started_token =
+            b.vr.start_success(accepted_token, &mut sender, Some(&[0, 1, 0, 1, 0, 1, 0]))
+                .expect("Sending start success failed");
+        let mut empty =
+            b.vr.step_success(
+                &started_token,
+                &mut sender,
+                Some(&EMPTY_STAMP),
+                EcssEnumU8::new(0),
+            )
+            .expect("Sending completion success failed");
+        assert_eq!(empty, ());
+        empty =
+            b.vr.step_failure(started_token, &mut sender, fail_params)
+                .expect("Step failure failed");
+        assert_eq!(empty, ());
+        check_step_failure(&mut sender, req_id, fail_data_raw);
+    }
+
+    #[test]
+    fn test_steps_failure_with_helper() {
+        let (mut b, tok) = base_with_helper_init();
+        let req_id = tok.req_id;
+        let fail_code = EcssEnumU32::new(0x1020);
+        let fail_data: f32 = -22.3232;
+        let mut fail_data_raw = [0; 4];
+        fail_data_raw.copy_from_slice(fail_data.to_be_bytes().as_slice());
+        let fail_step = EcssEnumU8::new(1);
+        let fail_params = FailParamsWithStep::new(
+            Some(&EMPTY_STAMP),
+            &fail_step,
+            &fail_code,
+            Some(fail_data_raw.as_slice()),
+        );
+
+        let accepted_token = b
+            .helper
+            .acceptance_success(tok, Some(&EMPTY_STAMP))
+            .expect("Sending acceptance success failed");
+        let started_token = b
+            .helper
+            .start_success(accepted_token, Some(&[0, 1, 0, 1, 0, 1, 0]))
+            .expect("Sending start success failed");
+        let mut empty = b
+            .helper
+            .step_success(&started_token, Some(&EMPTY_STAMP), EcssEnumU8::new(0))
+            .expect("Sending completion success failed");
+        assert_eq!(empty, ());
+        empty = b
+            .helper
+            .step_failure(started_token, fail_params)
+            .expect("Step failure failed");
+        assert_eq!(empty, ());
+        let sender: &mut TestSender = b.helper.sender.downcast_mut().unwrap();
+        check_step_failure(sender, req_id, fail_data_raw);
+    }
+
+    fn completion_fail_check(sender: &mut TestSender, req_id: RequestId) {
+        assert_eq!(sender.service_queue.borrow().len(), 3);
+
+        let mut cmp_info = TmInfo {
+            common: CommonTmInfo {
+                subservice: 1,
+                apid: TEST_APID,
+                msg_counter: 0,
+                dest_id: 0,
+                time_stamp: EMPTY_STAMP,
+            },
+            additional_data: None,
+            req_id,
+        };
+        let mut info = sender.service_queue.get_mut().pop_front().unwrap();
+        assert_eq!(info, cmp_info);
+
+        cmp_info = TmInfo {
+            common: CommonTmInfo {
+                subservice: 3,
+                apid: TEST_APID,
+                msg_counter: 0,
+                dest_id: 0,
+                time_stamp: [0, 1, 0, 1, 0, 1, 0],
+            },
+            additional_data: None,
+            req_id,
+        };
+        info = sender.service_queue.get_mut().pop_front().unwrap();
+        assert_eq!(info, cmp_info);
+
+        cmp_info = TmInfo {
+            common: CommonTmInfo {
+                subservice: 8,
+                apid: TEST_APID,
+                msg_counter: 0,
+                dest_id: 0,
+                time_stamp: EMPTY_STAMP,
+            },
+            additional_data: Some([0, 0, 0x10, 0x20].to_vec()),
+            req_id,
+        };
+        info = sender.service_queue.get_mut().pop_front().unwrap();
+        assert_eq!(info, cmp_info);
+    }
+
+    #[test]
+    fn test_completion_failure() {
+        let (mut b, tok) = base_init(false);
+        let mut sender = TestSender::default();
+        let req_id = tok.req_id;
+        let fail_code = EcssEnumU32::new(0x1020);
+        let fail_params = FailParams::new(Some(&EMPTY_STAMP), &fail_code, None);
+
+        let accepted_token =
+            b.vr.acceptance_success(tok, &mut sender, Some(&EMPTY_STAMP))
+                .expect("Sending acceptance success failed");
+        let started_token =
+            b.vr.start_success(accepted_token, &mut sender, Some(&[0, 1, 0, 1, 0, 1, 0]))
+                .expect("Sending start success failed");
+        let empty =
+            b.vr.completion_failure(started_token, &mut sender, fail_params)
+                .expect("Completion failure");
+        assert_eq!(empty, ());
+        completion_fail_check(&mut sender, req_id);
+    }
+
+    #[test]
+    fn test_completion_failure_with_helper() {
+        let (mut b, tok) = base_with_helper_init();
+        let req_id = tok.req_id;
+        let fail_code = EcssEnumU32::new(0x1020);
+        let fail_params = FailParams::new(Some(&EMPTY_STAMP), &fail_code, None);
+
+        let accepted_token = b
+            .helper
+            .acceptance_success(tok, Some(&EMPTY_STAMP))
+            .expect("Sending acceptance success failed");
+        let started_token = b
+            .helper
+            .start_success(accepted_token, Some(&[0, 1, 0, 1, 0, 1, 0]))
+            .expect("Sending start success failed");
+        let empty = b
+            .helper
+            .completion_failure(started_token, fail_params)
+            .expect("Completion failure");
+        assert_eq!(empty, ());
+        let sender: &mut TestSender = b.helper.sender.downcast_mut().unwrap();
+        completion_fail_check(sender, req_id);
+    }
+
+    fn completion_success_check(sender: &mut TestSender, req_id: RequestId) {
+        assert_eq!(sender.service_queue.borrow().len(), 3);
+        let cmp_info = TmInfo {
+            common: CommonTmInfo {
+                subservice: 1,
+                apid: TEST_APID,
+                msg_counter: 0,
+                dest_id: 0,
+                time_stamp: EMPTY_STAMP,
+            },
+            additional_data: None,
+            req_id,
+        };
+        let mut info = sender.service_queue.borrow_mut().pop_front().unwrap();
+        assert_eq!(info, cmp_info);
+
+        let cmp_info = TmInfo {
+            common: CommonTmInfo {
+                subservice: 3,
+                apid: TEST_APID,
+                msg_counter: 0,
+                dest_id: 0,
+                time_stamp: [0, 1, 0, 1, 0, 1, 0],
+            },
+            additional_data: None,
+            req_id,
+        };
+        info = sender.service_queue.borrow_mut().pop_front().unwrap();
+        assert_eq!(info, cmp_info);
+        let cmp_info = TmInfo {
+            common: CommonTmInfo {
+                subservice: 7,
+                apid: TEST_APID,
+                msg_counter: 0,
+                dest_id: 0,
+                time_stamp: EMPTY_STAMP,
+            },
+            additional_data: None,
+            req_id,
+        };
+        info = sender.service_queue.borrow_mut().pop_front().unwrap();
+        assert_eq!(info, cmp_info);
+    }
+
+    #[test]
+    fn test_complete_success_sequence() {
+        let (mut b, tok) = base_init(false);
+        let mut sender = TestSender::default();
+        let accepted_token =
+            b.vr.acceptance_success(tok, &mut sender, Some(&EMPTY_STAMP))
+                .expect("Sending acceptance success failed");
+        let started_token =
+            b.vr.start_success(accepted_token, &mut sender, Some(&[0, 1, 0, 1, 0, 1, 0]))
+                .expect("Sending start success failed");
+        let empty =
+            b.vr.completion_success(started_token, &mut sender, Some(&EMPTY_STAMP))
+                .expect("Sending completion success failed");
+        assert_eq!(empty, ());
+        completion_success_check(&mut sender, tok.req_id);
+    }
+
+    #[test]
+    fn test_complete_success_sequence_with_helper() {
+        let (mut b, tok) = base_with_helper_init();
+        let accepted_token = b
+            .helper
+            .acceptance_success(tok, Some(&EMPTY_STAMP))
+            .expect("Sending acceptance success failed");
+        let started_token = b
+            .helper
+            .start_success(accepted_token, Some(&[0, 1, 0, 1, 0, 1, 0]))
+            .expect("Sending start success failed");
+        let empty = b
+            .helper
+            .completion_success(started_token, Some(&EMPTY_STAMP))
+            .expect("Sending completion success failed");
+        assert_eq!(empty, ());
+        let sender: &mut TestSender = b.helper.sender.downcast_mut().unwrap();
+        completion_success_check(sender, tok.req_id);
+    }
+
+    #[test]
+    // TODO: maybe a bit more extensive testing, all I have time for right now
+    fn test_seq_count_increment() {
+        let pool_cfg = PoolCfg::new(vec![(10, 32), (10, 64), (10, 128), (10, 1024)]);
+        let tm_pool = Box::new(LocalPool::new(pool_cfg.clone()));
+        let shared_tm_store = SharedTmStore::new(tm_pool);
+        let shared_tm_pool = shared_tm_store.clone_backing_pool();
+        let (verif_tx, verif_rx) = mpsc::channel();
+        let sender = MpscTmInStoreSender::new(0, "Verification Sender", shared_tm_store, verif_tx);
+        let cfg = VerificationReporterCfg::new(TEST_APID, 1, 2, 8).unwrap();
+        let mut reporter = VerificationReporterWithSender::new(&cfg, Box::new(sender));
+
+        let mut sph = SpHeader::tc_unseg(TEST_APID, 0, 0).unwrap();
+        let tc_header = PusTcSecondaryHeader::new_simple(17, 1);
+        let pus_tc_0 = PusTc::new(&mut sph, tc_header, None, true);
+        let init_token = reporter.add_tc(&pus_tc_0);
+
+        // Complete success sequence for a telecommand
+        let accepted_token = reporter
+            .acceptance_success(init_token, Some(&EMPTY_STAMP))
+            .unwrap();
+        let started_token = reporter
+            .start_success(accepted_token, Some(&EMPTY_STAMP))
+            .unwrap();
+        reporter
+            .completion_success(started_token, Some(&EMPTY_STAMP))
+            .unwrap();
+
+        // Verify it arrives correctly on receiver end
+        let mut tm_buf: [u8; 1024] = [0; 1024];
+        let mut packet_idx = 0;
+        while packet_idx < 3 {
+            let addr = verif_rx.recv_timeout(Duration::from_millis(10)).unwrap();
+            let tm_len;
+            {
+                let mut rg = shared_tm_pool.write().expect("Error locking shared pool");
+                let store_guard = rg.read_with_guard(addr);
+                let slice = store_guard.read().expect("Error reading TM slice");
+                tm_len = slice.len();
+                tm_buf[0..tm_len].copy_from_slice(slice);
+            }
+            let (pus_tm, _) =
+                PusTm::from_bytes(&tm_buf[0..tm_len], 7).expect("Error reading verification TM");
+            if packet_idx == 0 {
+                assert_eq!(pus_tm.subservice(), 1);
+                assert_eq!(pus_tm.sp_header.seq_count(), 0);
+            } else if packet_idx == 1 {
+                assert_eq!(pus_tm.subservice(), 3);
+                assert_eq!(pus_tm.sp_header.seq_count(), 0);
+            } else if packet_idx == 2 {
+                assert_eq!(pus_tm.subservice(), 7);
+                assert_eq!(pus_tm.sp_header.seq_count(), 0);
+            }
+            packet_idx += 1;
+        }
+    }
+}
diff --git a/satrs-core/src/request.rs b/satrs-core/src/request.rs
new file mode 100644
index 0000000..8b13789
--- /dev/null
+++ b/satrs-core/src/request.rs
@@ -0,0 +1 @@
+
diff --git a/satrs-core/src/res_code.rs b/satrs-core/src/res_code.rs
new file mode 100644
index 0000000..5b0c64e
--- /dev/null
+++ b/satrs-core/src/res_code.rs
@@ -0,0 +1,60 @@
+#[cfg(feature = "serde")]
+use serde::{Deserialize, Serialize};
+use spacepackets::ecss::{EcssEnumU16, EcssEnumeration};
+use spacepackets::util::UnsignedEnum;
+use spacepackets::{ByteConversionError, SizeMissmatch};
+
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+pub struct ResultU16 {
+    group_id: u8,
+    unique_id: u8,
+}
+
+impl ResultU16 {
+    pub const fn const_new(group_id: u8, unique_id: u8) -> Self {
+        Self {
+            group_id,
+            unique_id,
+        }
+    }
+    pub fn raw(&self) -> u16 {
+        ((self.group_id as u16) << 8) | self.unique_id as u16
+    }
+    pub fn group_id(&self) -> u8 {
+        self.group_id
+    }
+    pub fn unique_id(&self) -> u8 {
+        self.unique_id
+    }
+}
+
+impl From<ResultU16> for EcssEnumU16 {
+    fn from(v: ResultU16) -> Self {
+        EcssEnumU16::new(v.raw())
+    }
+}
+
+impl UnsignedEnum for ResultU16 {
+    fn size(&self) -> usize {
+        core::mem::size_of::<u16>()
+    }
+
+    fn write_to_be_bytes(&self, buf: &mut [u8]) -> Result<usize, ByteConversionError> {
+        if buf.len() < 2 {
+            return Err(ByteConversionError::ToSliceTooSmall(SizeMissmatch {
+                found: buf.len(),
+                expected: 2,
+            }));
+        }
+        buf[0] = self.group_id;
+        buf[1] = self.unique_id;
+        Ok(self.size())
+    }
+}
+
+impl EcssEnumeration for ResultU16 {
+    fn pfc(&self) -> u8 {
+        16
+    }
+}
diff --git a/satrs-core/src/seq_count.rs b/satrs-core/src/seq_count.rs
new file mode 100644
index 0000000..c60c8f7
--- /dev/null
+++ b/satrs-core/src/seq_count.rs
@@ -0,0 +1,250 @@
+use core::cell::Cell;
+#[cfg(feature = "alloc")]
+use dyn_clone::DynClone;
+use paste::paste;
+use spacepackets::MAX_SEQ_COUNT;
+#[cfg(feature = "std")]
+pub use stdmod::*;
+
+/// Core trait for objects which can provide a sequence count.
+///
+/// The core functions are not mutable on purpose to allow easier usage with
+/// static structs when using the interior mutability pattern. This can be achieved by using
+/// [Cell], [core::cell::RefCell] or atomic types.
+pub trait SequenceCountProviderCore<Raw> {
+    fn get(&self) -> Raw;
+
+    fn increment(&self);
+
+    fn get_and_increment(&self) -> Raw {
+        let val = self.get();
+        self.increment();
+        val
+    }
+}
+
+/// Extension trait which allows cloning a sequence count provider after it was turned into
+/// a trait object.
+#[cfg(feature = "alloc")]
+pub trait SequenceCountProvider<Raw>: SequenceCountProviderCore<Raw> + DynClone {}
+#[cfg(feature = "alloc")]
+dyn_clone::clone_trait_object!(SequenceCountProvider<u16>);
+#[cfg(feature = "alloc")]
+impl<T, Raw> SequenceCountProvider<Raw> for T where T: SequenceCountProviderCore<Raw> + Clone {}
+
+#[derive(Default, Clone)]
+pub struct SeqCountProviderSimple<T: Copy> {
+    seq_count: Cell<T>,
+    max_val: T,
+}
+
+macro_rules! impl_for_primitives {
+    ($($ty: ident,)+) => {
+        $(
+            paste! {
+                impl SeqCountProviderSimple<$ty> {
+                    pub fn [<new_ $ty _max_val>](max_val: $ty) -> Self {
+                        Self {
+                            seq_count: Cell::new(0),
+                            max_val,
+                        }
+                    }
+
+                    pub fn [<new_ $ty>]() -> Self {
+                        Self {
+                            seq_count: Cell::new(0),
+                            max_val: $ty::MAX
+                        }
+                    }
+                }
+
+                impl SequenceCountProviderCore<$ty> for SeqCountProviderSimple<$ty> {
+                    fn get(&self) -> $ty {
+                        self.seq_count.get()
+                    }
+
+                    fn increment(&self) {
+                        self.get_and_increment();
+                    }
+
+                    fn get_and_increment(&self) -> $ty {
+                        let curr_count = self.seq_count.get();
+
+                        if curr_count == self.max_val {
+                            self.seq_count.set(0);
+                        } else {
+                            self.seq_count.set(curr_count + 1);
+                        }
+                        curr_count
+                    }
+                }
+            }
+        )+
+    }
+}
+
+impl_for_primitives!(u8, u16, u32, u64,);
+
+/// This is a sequence count provider which wraps around at [MAX_SEQ_COUNT].
+pub struct CcsdsSimpleSeqCountProvider {
+    provider: SeqCountProviderSimple<u16>,
+}
+
+impl CcsdsSimpleSeqCountProvider {
+    pub fn new() -> Self {
+        Self {
+            provider: SeqCountProviderSimple::new_u16_max_val(MAX_SEQ_COUNT),
+        }
+    }
+}
+
+impl Default for CcsdsSimpleSeqCountProvider {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl SequenceCountProviderCore<u16> for CcsdsSimpleSeqCountProvider {
+    delegate::delegate! {
+        to self.provider {
+            fn get(&self) -> u16;
+            fn increment(&self);
+            fn get_and_increment(&self) -> u16;
+        }
+    }
+}
+
+#[cfg(feature = "std")]
+pub mod stdmod {
+    use super::*;
+    use std::sync::{Arc, Mutex};
+
+    macro_rules! sync_clonable_seq_counter_impl {
+         ($($ty: ident,)+) => {
+             $(paste! {
+                 /// These sequence counters can be shared between threads and can also be
+                 /// configured to wrap around at specified maximum values. Please note that
+                 /// that the API provided by this class will not panic und [Mutex] lock errors,
+                 /// but it will yield 0 for the getter functions.
+                 #[derive(Clone, Default)]
+                 pub struct [<SeqCountProviderSync $ty:upper>] {
+                     seq_count: Arc<Mutex<$ty>>,
+                     max_val: $ty
+                 }
+
+                 impl [<SeqCountProviderSync $ty:upper>] {
+                     pub fn new() -> Self {
+                        Self::new_with_max_val($ty::MAX)
+                     }
+
+                     pub fn new_with_max_val(max_val: $ty) -> Self {
+                         Self {
+                             seq_count: Arc::default(),
+                             max_val
+                         }
+                     }
+                 }
+                 impl SequenceCountProviderCore<$ty> for [<SeqCountProviderSync $ty:upper>] {
+                    fn get(&self) -> $ty {
+                        match self.seq_count.lock() {
+                            Ok(counter) => *counter,
+                            Err(_) => 0
+                        }
+                    }
+
+                    fn increment(&self) {
+                        self.get_and_increment();
+                    }
+
+                    fn get_and_increment(&self) -> $ty {
+                        match self.seq_count.lock() {
+                            Ok(mut counter) => {
+                                let val = *counter;
+                                if val == self.max_val {
+                                    *counter = 0;
+                                } else {
+                                    *counter += 1;
+                                }
+                                val
+                            }
+                            Err(_) => 0,
+                        }
+                    }
+                 }
+             })+
+         }
+    }
+    sync_clonable_seq_counter_impl!(u8, u16, u32, u64,);
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::seq_count::{
+        CcsdsSimpleSeqCountProvider, SeqCountProviderSimple, SeqCountProviderSyncU8,
+        SequenceCountProviderCore,
+    };
+    use spacepackets::MAX_SEQ_COUNT;
+
+    #[test]
+    fn test_u8_counter() {
+        let u8_counter = SeqCountProviderSimple::new_u8();
+        assert_eq!(u8_counter.get(), 0);
+        assert_eq!(u8_counter.get_and_increment(), 0);
+        assert_eq!(u8_counter.get_and_increment(), 1);
+        assert_eq!(u8_counter.get(), 2);
+    }
+
+    #[test]
+    fn test_u8_counter_overflow() {
+        let u8_counter = SeqCountProviderSimple::new_u8();
+        for _ in 0..256 {
+            u8_counter.increment();
+        }
+        assert_eq!(u8_counter.get(), 0);
+    }
+
+    #[test]
+    fn test_ccsds_counter() {
+        let ccsds_counter = CcsdsSimpleSeqCountProvider::default();
+        assert_eq!(ccsds_counter.get(), 0);
+        assert_eq!(ccsds_counter.get_and_increment(), 0);
+        assert_eq!(ccsds_counter.get_and_increment(), 1);
+        assert_eq!(ccsds_counter.get(), 2);
+    }
+
+    #[test]
+    fn test_ccsds_counter_overflow() {
+        let ccsds_counter = CcsdsSimpleSeqCountProvider::default();
+        for _ in 0..MAX_SEQ_COUNT + 1 {
+            ccsds_counter.increment();
+        }
+        assert_eq!(ccsds_counter.get(), 0);
+    }
+
+    #[test]
+    fn test_atomic_ref_counters() {
+        let sync_u8_counter = SeqCountProviderSyncU8::new();
+        assert_eq!(sync_u8_counter.get(), 0);
+        assert_eq!(sync_u8_counter.get_and_increment(), 0);
+        assert_eq!(sync_u8_counter.get_and_increment(), 1);
+        assert_eq!(sync_u8_counter.get(), 2);
+    }
+
+    #[test]
+    fn test_atomic_ref_counters_overflow() {
+        let sync_u8_counter = SeqCountProviderSyncU8::new();
+        for _ in 0..u8::MAX as u16 + 1 {
+            sync_u8_counter.increment();
+        }
+        assert_eq!(sync_u8_counter.get(), 0);
+    }
+
+    #[test]
+    fn test_atomic_ref_counters_overflow_custom_max_val() {
+        let sync_u8_counter = SeqCountProviderSyncU8::new_with_max_val(128);
+        for _ in 0..129 {
+            sync_u8_counter.increment();
+        }
+        assert_eq!(sync_u8_counter.get(), 0);
+    }
+}
diff --git a/fsrc-core/src/tmtc/ccsds_distrib.rs b/satrs-core/src/tmtc/ccsds_distrib.rs
similarity index 82%
rename from fsrc-core/src/tmtc/ccsds_distrib.rs
rename to satrs-core/src/tmtc/ccsds_distrib.rs
index 92d6c39..eefed54 100644
--- a/fsrc-core/src/tmtc/ccsds_distrib.rs
+++ b/satrs-core/src/tmtc/ccsds_distrib.rs
@@ -4,7 +4,7 @@
 //!  1. [CcsdsDistributor] component which dispatches received packets to a user-provided handler
 //!  2. [CcsdsPacketHandler] trait which should be implemented by the user-provided packet handler.
 //!
-//! The [CcsdsDistributor] implements the [ReceivesCcsdsTc] and [ReceivesTc] trait which allows to
+//! The [CcsdsDistributor] implements the [ReceivesCcsdsTc] and [ReceivesTcCore] trait which allows to
 //! pass raw or CCSDS packets to it. Upon receiving a packet, it performs the following steps:
 //!
 //! 1. It tries to identify the target Application Process Identifier (APID) based on the
@@ -18,9 +18,10 @@
 //! # Example
 //!
 //! ```rust
-//! use fsrc_core::tmtc::ccsds_distrib::{CcsdsPacketHandler, CcsdsDistributor};
-//! use fsrc_core::tmtc::ReceivesTc;
+//! use satrs_core::tmtc::ccsds_distrib::{CcsdsPacketHandler, CcsdsDistributor};
+//! use satrs_core::tmtc::{ReceivesTc, ReceivesTcCore};
 //! use spacepackets::{CcsdsPacket, SpHeader};
+//! use spacepackets::ecss::SerializablePusPacket;
 //! use spacepackets::tc::PusTc;
 //!
 //! #[derive (Default)]
@@ -54,11 +55,11 @@
 //! let mut ccsds_distributor = CcsdsDistributor::new(Box::new(apid_handler));
 //!
 //! // Create and pass PUS telecommand with a valid APID
-//! let mut space_packet_header = SpHeader::tc(0x002, 0x34, 0).unwrap();
+//! let mut space_packet_header = SpHeader::tc_unseg(0x002, 0x34, 0).unwrap();
 //! let mut pus_tc = PusTc::new_simple(&mut space_packet_header, 17, 1, None, true);
 //! let mut test_buf: [u8; 32] = [0; 32];
 //! let mut size = pus_tc
-//!     .write_to(test_buf.as_mut_slice())
+//!     .write_to_bytes(test_buf.as_mut_slice())
 //!     .expect("Error writing TC to buffer");
 //! let tc_slice = &test_buf[0..size];
 //! ccsds_distributor.pass_tc(&tc_slice).expect("Passing TC slice failed");
@@ -66,7 +67,7 @@
 //! // Now pass a packet with an unknown APID to the distributor
 //! pus_tc.set_apid(0x003);
 //! size = pus_tc
-//!     .write_to(test_buf.as_mut_slice())
+//!     .write_to_bytes(test_buf.as_mut_slice())
 //!     .expect("Error writing TC to buffer");
 //! let tc_slice = &test_buf[0..size];
 //! ccsds_distributor.pass_tc(&tc_slice).expect("Passing TC slice failed");
@@ -84,10 +85,13 @@
 //!     .expect("Casting back to concrete type failed");
 //! mutable_ref.mutable_foo();
 //! ```
-use crate::tmtc::{ReceivesCcsdsTc, ReceivesTc};
+use crate::tmtc::{ReceivesCcsdsTc, ReceivesTcCore};
 use alloc::boxed::Box;
+use core::fmt::{Display, Formatter};
 use downcast_rs::Downcast;
 use spacepackets::{ByteConversionError, CcsdsPacket, SizeMissmatch, SpHeader};
+#[cfg(feature = "std")]
+use std::error::Error;
 
 /// Generic trait for a handler or dispatcher object handling CCSDS packets.
 ///
@@ -114,18 +118,46 @@ pub trait CcsdsPacketHandler: Downcast {
 
 downcast_rs::impl_downcast!(CcsdsPacketHandler assoc Error);
 
+pub trait SendableCcsdsPacketHandler: CcsdsPacketHandler + Send {}
+
+impl<T: CcsdsPacketHandler + Send> SendableCcsdsPacketHandler for T {}
+
+downcast_rs::impl_downcast!(SendableCcsdsPacketHandler assoc Error);
+
 /// The CCSDS distributor dispatches received CCSDS packets to a user provided packet handler.
+///
+/// The passed APID handler is required to be [Send]able to allow more ergonomic usage with
+/// threads.
 pub struct CcsdsDistributor<E> {
     /// User provided APID handler stored as a generic trait object.
     /// It can be cast back to the original concrete type using the [Self::apid_handler_ref] or
     /// the [Self::apid_handler_mut] method.
-    pub apid_handler: Box<dyn CcsdsPacketHandler<Error = E>>,
+    pub apid_handler: Box<dyn SendableCcsdsPacketHandler<Error = E>>,
 }
 
 #[derive(Debug, Copy, Clone, PartialEq, Eq)]
 pub enum CcsdsError<E> {
     CustomError(E),
-    PacketError(ByteConversionError),
+    ByteConversionError(ByteConversionError),
+}
+
+impl<E: Display> Display for CcsdsError<E> {
+    fn fmt(&self, f: &mut Formatter<'_>) -> core::fmt::Result {
+        match self {
+            Self::CustomError(e) => write!(f, "{e}"),
+            Self::ByteConversionError(e) => write!(f, "{e}"),
+        }
+    }
+}
+
+#[cfg(feature = "std")]
+impl<E: Error> Error for CcsdsError<E> {
+    fn source(&self) -> Option<&(dyn Error + 'static)> {
+        match self {
+            Self::CustomError(e) => e.source(),
+            Self::ByteConversionError(e) => e.source(),
+        }
+    }
 }
 
 impl<E: 'static> ReceivesCcsdsTc for CcsdsDistributor<E> {
@@ -136,38 +168,39 @@ impl<E: 'static> ReceivesCcsdsTc for CcsdsDistributor<E> {
     }
 }
 
-impl<E: 'static> ReceivesTc for CcsdsDistributor<E> {
+impl<E: 'static> ReceivesTcCore for CcsdsDistributor<E> {
     type Error = CcsdsError<E>;
 
     fn pass_tc(&mut self, tc_raw: &[u8]) -> Result<(), Self::Error> {
         if tc_raw.len() < 7 {
-            return Err(CcsdsError::PacketError(
+            return Err(CcsdsError::ByteConversionError(
                 ByteConversionError::FromSliceTooSmall(SizeMissmatch {
                     found: tc_raw.len(),
                     expected: 7,
                 }),
             ));
         }
-        let sp_header = SpHeader::from_raw_slice(tc_raw).map_err(|e| CcsdsError::PacketError(e))?;
+        let (sp_header, _) =
+            SpHeader::from_be_bytes(tc_raw).map_err(|e| CcsdsError::ByteConversionError(e))?;
         self.dispatch_ccsds(&sp_header, tc_raw)
     }
 }
 
 impl<E: 'static> CcsdsDistributor<E> {
-    pub fn new(apid_handler: Box<dyn CcsdsPacketHandler<Error = E>>) -> Self {
+    pub fn new(apid_handler: Box<dyn SendableCcsdsPacketHandler<Error = E>>) -> Self {
         CcsdsDistributor { apid_handler }
     }
 
     /// This function can be used to retrieve a reference to the concrete instance of the APID
     /// handler after it was passed to the distributor. See the
     /// [module documentation][crate::tmtc::ccsds_distrib] for an fsrc-example.
-    pub fn apid_handler_ref<T: CcsdsPacketHandler<Error = E>>(&self) -> Option<&T> {
+    pub fn apid_handler_ref<T: SendableCcsdsPacketHandler<Error = E>>(&self) -> Option<&T> {
         self.apid_handler.downcast_ref::<T>()
     }
 
     /// This function can be used to retrieve a mutable reference to the concrete instance of the
     /// APID handler after it was passed to the distributor.
-    pub fn apid_handler_mut<T: CcsdsPacketHandler<Error = E>>(&mut self) -> Option<&mut T> {
+    pub fn apid_handler_mut<T: SendableCcsdsPacketHandler<Error = E>>(&mut self) -> Option<&mut T> {
         self.apid_handler.downcast_mut::<T>()
     }
 
@@ -192,16 +225,21 @@ impl<E: 'static> CcsdsDistributor<E> {
 pub(crate) mod tests {
     use super::*;
     use crate::tmtc::ccsds_distrib::{CcsdsDistributor, CcsdsPacketHandler};
+    use spacepackets::ecss::SerializablePusPacket;
     use spacepackets::tc::PusTc;
     use spacepackets::CcsdsPacket;
     use std::collections::VecDeque;
     use std::sync::{Arc, Mutex};
     use std::vec::Vec;
 
+    fn is_send<T: Send>(_: &T) {}
+
     pub fn generate_ping_tc(buf: &mut [u8]) -> &[u8] {
-        let mut sph = SpHeader::tc(0x002, 0x34, 0).unwrap();
+        let mut sph = SpHeader::tc_unseg(0x002, 0x34, 0).unwrap();
         let pus_tc = PusTc::new_simple(&mut sph, 17, 1, None, true);
-        let size = pus_tc.write_to(buf).expect("Error writing TC to buffer");
+        let size = pus_tc
+            .write_to_bytes(buf)
+            .expect("Error writing TC to buffer");
         assert_eq!(size, 13);
         &buf[0..size]
     }
@@ -289,6 +327,7 @@ pub(crate) mod tests {
             unknown_packet_queue: unknown_packet_queue.clone(),
         };
         let mut ccsds_distrib = CcsdsDistributor::new(Box::new(apid_handler));
+        is_send(&ccsds_distrib);
         let mut test_buf: [u8; 32] = [0; 32];
         let tc_slice = generate_ping_tc(test_buf.as_mut_slice());
 
@@ -310,11 +349,11 @@ pub(crate) mod tests {
             unknown_packet_queue: unknown_packet_queue.clone(),
         };
         let mut ccsds_distrib = CcsdsDistributor::new(Box::new(apid_handler));
-        let mut sph = SpHeader::tc(0x004, 0x34, 0).unwrap();
+        let mut sph = SpHeader::tc_unseg(0x004, 0x34, 0).unwrap();
         let pus_tc = PusTc::new_simple(&mut sph, 17, 1, None, true);
         let mut test_buf: [u8; 32] = [0; 32];
         pus_tc
-            .write_to(test_buf.as_mut_slice())
+            .write_to_bytes(test_buf.as_mut_slice())
             .expect("Error writing TC to buffer");
         ccsds_distrib.pass_tc(&test_buf).expect("Passing TC failed");
         let recvd = unknown_packet_queue.lock().unwrap().pop_front();
diff --git a/satrs-core/src/tmtc/mod.rs b/satrs-core/src/tmtc/mod.rs
new file mode 100644
index 0000000..5d5f306
--- /dev/null
+++ b/satrs-core/src/tmtc/mod.rs
@@ -0,0 +1,94 @@
+//! Telemetry and Telecommanding (TMTC) module. Contains packet routing components with special
+//! support for CCSDS and ECSS packets.
+//!
+//! The distributor modules provided by this module use trait objects provided by the user to
+//! directly dispatch received packets to packet listeners based on packet fields like the CCSDS
+//! Application Process ID (APID) or the ECSS PUS service type. This allows for fast packet
+//! routing without the overhead and complication of using message queues. However, it also requires
+#[cfg(feature = "alloc")]
+use downcast_rs::{impl_downcast, Downcast};
+#[cfg(feature = "serde")]
+use serde::{Deserialize, Serialize};
+use spacepackets::{ByteConversionError, SizeMissmatch, SpHeader};
+
+#[cfg(feature = "alloc")]
+pub mod ccsds_distrib;
+#[cfg(feature = "alloc")]
+pub mod pus_distrib;
+pub mod tm_helper;
+
+#[cfg(feature = "alloc")]
+pub use ccsds_distrib::{CcsdsDistributor, CcsdsError, CcsdsPacketHandler};
+#[cfg(feature = "alloc")]
+pub use pus_distrib::{PusDistributor, PusServiceProvider};
+
+pub type TargetId = u32;
+
+#[derive(Copy, Clone, PartialEq, Eq, Debug, Hash)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+pub struct AddressableId {
+    pub target_id: TargetId,
+    pub unique_id: u32,
+}
+
+impl AddressableId {
+    pub fn from_raw_be(buf: &[u8]) -> Result<Self, ByteConversionError> {
+        if buf.len() < 8 {
+            return Err(ByteConversionError::FromSliceTooSmall(SizeMissmatch {
+                found: buf.len(),
+                expected: 8,
+            }));
+        }
+        Ok(Self {
+            target_id: u32::from_be_bytes(buf[0..4].try_into().unwrap()),
+            unique_id: u32::from_be_bytes(buf[4..8].try_into().unwrap()),
+        })
+    }
+
+    pub fn write_to_be_bytes(&self, buf: &mut [u8]) -> Result<usize, ByteConversionError> {
+        if buf.len() < 8 {
+            return Err(ByteConversionError::ToSliceTooSmall(SizeMissmatch {
+                found: buf.len(),
+                expected: 8,
+            }));
+        }
+        buf[0..4].copy_from_slice(&self.target_id.to_be_bytes());
+        buf[4..8].copy_from_slice(&self.unique_id.to_be_bytes());
+        Ok(8)
+    }
+}
+
+/// Generic trait for object which can receive any telecommands in form of a raw bytestream, with
+/// no assumptions about the received protocol.
+///
+/// This trait is implemented by both the [crate::tmtc::pus_distrib::PusDistributor] and the
+/// [crate::tmtc::ccsds_distrib::CcsdsDistributor]  which allows to pass the respective packets in
+/// raw byte format into them.
+pub trait ReceivesTcCore {
+    type Error;
+    fn pass_tc(&mut self, tc_raw: &[u8]) -> Result<(), Self::Error>;
+}
+
+/// Extension trait of [ReceivesTcCore] which allows downcasting by implementing [Downcast] and
+/// is also sendable.
+#[cfg(feature = "alloc")]
+pub trait ReceivesTc: ReceivesTcCore + Downcast + Send {}
+
+/// Blanket implementation to automatically implement [ReceivesTc] when the [alloc] feature
+/// is enabled.
+#[cfg(feature = "alloc")]
+impl<T> ReceivesTc for T where T: ReceivesTcCore + Send + 'static {}
+
+#[cfg(feature = "alloc")]
+impl_downcast!(ReceivesTc assoc Error);
+
+/// Generic trait for object which can receive CCSDS space packets, for example ECSS PUS packets
+/// for CCSDS File Delivery Protocol (CFDP) packets.
+///
+/// This trait is implemented by both the [crate::tmtc::pus_distrib::PusDistributor] and the
+/// [crate::tmtc::ccsds_distrib::CcsdsDistributor] which allows
+/// to pass the respective packets in raw byte format or in CCSDS format into them.
+pub trait ReceivesCcsdsTc {
+    type Error;
+    fn pass_ccsds(&mut self, header: &SpHeader, tc_raw: &[u8]) -> Result<(), Self::Error>;
+}
diff --git a/fsrc-core/src/tmtc/pus_distrib.rs b/satrs-core/src/tmtc/pus_distrib.rs
similarity index 81%
rename from fsrc-core/src/tmtc/pus_distrib.rs
rename to satrs-core/src/tmtc/pus_distrib.rs
index 9ee8bc6..b6a5eab 100644
--- a/fsrc-core/src/tmtc/pus_distrib.rs
+++ b/satrs-core/src/tmtc/pus_distrib.rs
@@ -5,9 +5,9 @@
 //!  2. [PusServiceProvider] trait which should be implemented by the user-provided PUS packet
 //!     handler.
 //!
-//! The [PusDistributor] implements the [ReceivesEcssPusTc], [ReceivesCcsdsTc] and the [ReceivesTc]
-//! trait which allows to pass raw packets, CCSDS packets and PUS TC packets into it.
-//! Upon receiving a packet, it performs the following steps:
+//! The [PusDistributor] implements the [ReceivesEcssPusTc], [ReceivesCcsdsTc] and the
+//! [ReceivesTcCore] trait which allows to pass raw packets, CCSDS packets and PUS TC packets into
+//! it. Upon receiving a packet, it performs the following steps:
 //!
 //! 1. It tries to extract the [SpHeader] and [PusTc] objects from the raw bytestream. If this
 //!    process fails, a [PusDistribError::PusError] is returned to the user.
@@ -17,8 +17,9 @@
 //! # Example
 //!
 //! ```rust
-//! use fsrc_core::tmtc::pus_distrib::{PusDistributor, PusServiceProvider};
-//! use fsrc_core::tmtc::ReceivesTc;
+//! use spacepackets::ecss::SerializablePusPacket;
+//! use satrs_core::tmtc::pus_distrib::{PusDistributor, PusServiceProvider};
+//! use satrs_core::tmtc::{ReceivesTc, ReceivesTcCore};
 //! use spacepackets::SpHeader;
 //! use spacepackets::tc::PusTc;
 //! struct ConcretePusHandler {
@@ -43,11 +44,11 @@
 //! let mut pus_distributor = PusDistributor::new(Box::new(service_handler));
 //!
 //! // Create and pass PUS ping telecommand with a valid APID
-//! let mut space_packet_header = SpHeader::tc(0x002, 0x34, 0).unwrap();
+//! let mut space_packet_header = SpHeader::tc_unseg(0x002, 0x34, 0).unwrap();
 //! let mut pus_tc = PusTc::new_simple(&mut space_packet_header, 17, 1, None, true);
 //! let mut test_buf: [u8; 32] = [0; 32];
 //! let mut size = pus_tc
-//!     .write_to(test_buf.as_mut_slice())
+//!     .write_to_bytes(test_buf.as_mut_slice())
 //!     .expect("Error writing TC to buffer");
 //! let tc_slice = &test_buf[0..size];
 //!
@@ -60,12 +61,16 @@
 //!     .expect("Casting back to concrete type failed");
 //! assert_eq!(concrete_handler_ref.handler_call_count, 1);
 //! ```
-use crate::tmtc::{ReceivesCcsdsTc, ReceivesEcssPusTc, ReceivesTc};
+use crate::pus::ReceivesEcssPusTc;
+use crate::tmtc::{ReceivesCcsdsTc, ReceivesTcCore};
 use alloc::boxed::Box;
+use core::fmt::{Display, Formatter};
 use downcast_rs::Downcast;
 use spacepackets::ecss::{PusError, PusPacket};
 use spacepackets::tc::PusTc;
 use spacepackets::SpHeader;
+#[cfg(feature = "std")]
+use std::error::Error;
 
 pub trait PusServiceProvider: Downcast {
     type Error;
@@ -78,12 +83,22 @@ pub trait PusServiceProvider: Downcast {
 }
 downcast_rs::impl_downcast!(PusServiceProvider assoc Error);
 
+pub trait SendablePusServiceProvider: PusServiceProvider + Send {}
+
+impl<T: Send + PusServiceProvider> SendablePusServiceProvider for T {}
+
+downcast_rs::impl_downcast!(SendablePusServiceProvider assoc Error);
+
+/// Generic distributor object which dispatches received packets to a user provided handler.
+///
+/// This distributor expects the passed trait object to be [Send]able to allow more ergonomic
+/// usage with threads.
 pub struct PusDistributor<E> {
-    pub service_provider: Box<dyn PusServiceProvider<Error = E>>,
+    pub service_provider: Box<dyn SendablePusServiceProvider<Error = E>>,
 }
 
 impl<E> PusDistributor<E> {
-    pub fn new(service_provider: Box<dyn PusServiceProvider<Error = E>>) -> Self {
+    pub fn new(service_provider: Box<dyn SendablePusServiceProvider<Error = E>>) -> Self {
         PusDistributor { service_provider }
     }
 }
@@ -94,12 +109,31 @@ pub enum PusDistribError<E> {
     PusError(PusError),
 }
 
-impl<E: 'static> ReceivesTc for PusDistributor<E> {
+impl<E: Display> Display for PusDistribError<E> {
+    fn fmt(&self, f: &mut Formatter<'_>) -> core::fmt::Result {
+        match self {
+            PusDistribError::CustomError(e) => write!(f, "{e}"),
+            PusDistribError::PusError(e) => write!(f, "{e}"),
+        }
+    }
+}
+
+#[cfg(feature = "std")]
+impl<E: Error> Error for PusDistribError<E> {
+    fn source(&self) -> Option<&(dyn Error + 'static)> {
+        match self {
+            Self::CustomError(e) => e.source(),
+            Self::PusError(e) => e.source(),
+        }
+    }
+}
+
+impl<E: 'static> ReceivesTcCore for PusDistributor<E> {
     type Error = PusDistribError<E>;
     fn pass_tc(&mut self, tm_raw: &[u8]) -> Result<(), Self::Error> {
         // Convert to ccsds and call pass_ccsds
-        let sp_header = SpHeader::from_raw_slice(tm_raw)
-            .map_err(|e| PusDistribError::PusError(PusError::PacketError(e)))?;
+        let (sp_header, _) = SpHeader::from_be_bytes(tm_raw)
+            .map_err(|e| PusDistribError::PusError(PusError::ByteConversion(e)))?;
         self.pass_ccsds(&sp_header, tm_raw)
     }
 }
@@ -107,8 +141,7 @@ impl<E: 'static> ReceivesTc for PusDistributor<E> {
 impl<E: 'static> ReceivesCcsdsTc for PusDistributor<E> {
     type Error = PusDistribError<E>;
     fn pass_ccsds(&mut self, header: &SpHeader, tm_raw: &[u8]) -> Result<(), Self::Error> {
-        let (tc, _) =
-            PusTc::new_from_raw_slice(tm_raw).map_err(|e| PusDistribError::PusError(e))?;
+        let (tc, _) = PusTc::from_bytes(tm_raw).map_err(|e| PusDistribError::PusError(e))?;
         self.pass_pus_tc(header, &tc)
     }
 }
@@ -123,11 +156,13 @@ impl<E: 'static> ReceivesEcssPusTc for PusDistributor<E> {
 }
 
 impl<E: 'static> PusDistributor<E> {
-    pub fn service_provider_ref<T: PusServiceProvider<Error = E>>(&self) -> Option<&T> {
+    pub fn service_provider_ref<T: SendablePusServiceProvider<Error = E>>(&self) -> Option<&T> {
         self.service_provider.downcast_ref::<T>()
     }
 
-    pub fn service_provider_mut<T: PusServiceProvider<Error = E>>(&mut self) -> Option<&mut T> {
+    pub fn service_provider_mut<T: SendablePusServiceProvider<Error = E>>(
+        &mut self,
+    ) -> Option<&mut T> {
         self.service_provider.downcast_mut::<T>()
     }
 }
@@ -148,6 +183,8 @@ mod tests {
     #[cfg(feature = "std")]
     use std::sync::{Arc, Mutex};
 
+    fn is_send<T: Send>(_: &T) {}
+
     struct PusHandlerSharedQueue {
         pub pus_queue: Arc<Mutex<VecDeque<(u8, u16, Vec<u8>)>>>,
     }
@@ -264,7 +301,7 @@ mod tests {
         let pus_distrib = PusDistributor {
             service_provider: Box::new(pus_handler),
         };
-
+        is_send(&pus_distrib);
         let apid_handler = ApidHandlerShared {
             pus_distrib,
             handler_base,
diff --git a/satrs-core/src/tmtc/tm_helper.rs b/satrs-core/src/tmtc/tm_helper.rs
new file mode 100644
index 0000000..da2bc1e
--- /dev/null
+++ b/satrs-core/src/tmtc/tm_helper.rs
@@ -0,0 +1,93 @@
+use spacepackets::time::cds::TimeProvider;
+use spacepackets::time::TimeWriter;
+use spacepackets::tm::{PusTm, PusTmSecondaryHeader};
+use spacepackets::SpHeader;
+
+#[cfg(feature = "std")]
+pub use std_mod::*;
+
+#[cfg(feature = "std")]
+pub mod std_mod {
+    use crate::pool::{ShareablePoolProvider, SharedPool, StoreAddr};
+    use crate::pus::EcssTmtcError;
+    use spacepackets::ecss::SerializablePusPacket;
+    use spacepackets::tm::PusTm;
+    use std::sync::{Arc, RwLock};
+
+    #[derive(Clone)]
+    pub struct SharedTmStore {
+        pool: SharedPool,
+    }
+
+    impl SharedTmStore {
+        pub fn new(backing_pool: ShareablePoolProvider) -> Self {
+            Self {
+                pool: Arc::new(RwLock::new(backing_pool)),
+            }
+        }
+
+        pub fn clone_backing_pool(&self) -> SharedPool {
+            self.pool.clone()
+        }
+
+        pub fn add_pus_tm(&self, pus_tm: &PusTm) -> Result<StoreAddr, EcssTmtcError> {
+            let mut pg = self.pool.write().map_err(|_| EcssTmtcError::StoreLock)?;
+            let (addr, buf) = pg.free_element(pus_tm.len_packed())?;
+            pus_tm
+                .write_to_bytes(buf)
+                .expect("writing PUS TM to store failed");
+            Ok(addr)
+        }
+    }
+}
+
+pub struct PusTmWithCdsShortHelper {
+    apid: u16,
+    cds_short_buf: [u8; 7],
+}
+
+impl PusTmWithCdsShortHelper {
+    pub fn new(apid: u16) -> Self {
+        Self {
+            apid,
+            cds_short_buf: [0; 7],
+        }
+    }
+
+    #[cfg(feature = "std")]
+    pub fn create_pus_tm_timestamp_now<'a>(
+        &'a mut self,
+        service: u8,
+        subservice: u8,
+        source_data: Option<&'a [u8]>,
+        seq_count: u16,
+    ) -> PusTm {
+        let time_stamp = TimeProvider::from_now_with_u16_days().unwrap();
+        time_stamp.write_to_bytes(&mut self.cds_short_buf).unwrap();
+        self.create_pus_tm_common(service, subservice, source_data, seq_count)
+    }
+
+    pub fn create_pus_tm_with_stamper<'a>(
+        &'a mut self,
+        service: u8,
+        subservice: u8,
+        source_data: Option<&'a [u8]>,
+        stamper: &TimeProvider,
+        seq_count: u16,
+    ) -> PusTm {
+        stamper.write_to_bytes(&mut self.cds_short_buf).unwrap();
+        self.create_pus_tm_common(service, subservice, source_data, seq_count)
+    }
+
+    fn create_pus_tm_common<'a>(
+        &'a self,
+        service: u8,
+        subservice: u8,
+        source_data: Option<&'a [u8]>,
+        seq_count: u16,
+    ) -> PusTm {
+        let mut reply_header = SpHeader::tm_unseg(self.apid, seq_count, 0).unwrap();
+        let tc_header = PusTmSecondaryHeader::new_simple(service, subservice, &self.cds_short_buf);
+        PusTm::new(&mut reply_header, tc_header, source_data, true)
+    }
+}
diff --git a/satrs-core/tests/hk_helpers.rs b/satrs-core/tests/hk_helpers.rs
new file mode 100644
index 0000000..07264ef
--- /dev/null
+++ b/satrs-core/tests/hk_helpers.rs
@@ -0,0 +1,164 @@
+#![allow(dead_code)]
+use core::mem::size_of;
+use serde::{Deserialize, Serialize};
+use spacepackets::ecss::{Ptc, RealPfc, UnsignedPfc};
+use spacepackets::time::cds::TimeProvider;
+use spacepackets::time::{CcsdsTimeProvider, TimeWriter};
+
+enum NumOfParamsInfo {
+    /// The parameter entry is a scalar field
+    Scalar = 0b00,
+    /// The parameter entry is a vector, and its length field is one byte wide (max. 255 entries)
+    VecLenFieldOneByte = 0b01,
+    /// The parameter entry is a vecotr, and its length field is two bytes wide (max. 65565 entries)
+    VecLenFieldTwoBytes = 0b10,
+    /// The parameter entry is a matrix, and its length field contains a one byte row number
+    /// and a one byte column number.
+    MatrixRowsAndColumns = 0b11,
+}
+
+const HAS_VALIDITY_MASK: u8 = 1 << 7;
+
+struct ParamWithValidity<T> {
+    valid: bool,
+    val: T,
+}
+
+struct TestMgmHk {
+    temp: f32,
+    mgm_vals: [u16; 3],
+}
+
+struct TestMgmHkWithIndividualValidity {
+    temp: ParamWithValidity<f32>,
+    mgm_vals: ParamWithValidity<[u16; 3]>,
+}
+
+#[derive(Serialize, Deserialize)]
+struct TestMgmHkWithGroupValidity {
+    last_valid_stamp: TimeProvider,
+    valid: bool,
+    temp: f32,
+    mgm_vals: [u16; 3],
+}
+
+impl TestMgmHk {
+    pub fn write_to_be_bytes(&self, buf: &mut [u8]) -> Result<usize, ()> {
+        let mut curr_idx = 0;
+        buf[curr_idx..curr_idx + size_of::<f32>()].copy_from_slice(&self.temp.to_be_bytes());
+        curr_idx += size_of::<f32>();
+        for val in self.mgm_vals {
+            buf[curr_idx..curr_idx + size_of::<u16>()].copy_from_slice(&val.to_be_bytes());
+            curr_idx += size_of::<u16>();
+        }
+        Ok(curr_idx)
+    }
+}
+
+/// This could in principle be auto-generated.
+impl TestMgmHkWithIndividualValidity {
+    pub fn write_to_be_bytes_self_describing(&self, buf: &mut [u8]) -> Result<usize, ()> {
+        let mut curr_idx = 0;
+        buf[curr_idx] = 0;
+        buf[curr_idx] |= HAS_VALIDITY_MASK | (self.temp.valid as u8) << 6;
+        curr_idx += 1;
+        buf[curr_idx] = Ptc::Real as u8;
+        curr_idx += 1;
+        buf[curr_idx] = RealPfc::Float as u8;
+        curr_idx += 1;
+        buf[curr_idx..curr_idx + size_of::<f32>()].copy_from_slice(&self.temp.val.to_be_bytes());
+        curr_idx += size_of::<f32>();
+        buf[curr_idx] = 0;
+        buf[curr_idx] |= HAS_VALIDITY_MASK
+            | (self.mgm_vals.valid as u8) << 6
+            | (NumOfParamsInfo::VecLenFieldOneByte as u8) << 4;
+        curr_idx += 1;
+        buf[curr_idx] = Ptc::UnsignedInt as u8;
+        curr_idx += 1;
+        buf[curr_idx] = UnsignedPfc::TwoBytes as u8;
+        curr_idx += 1;
+        buf[curr_idx] = 3;
+        curr_idx += 1;
+        for val in self.mgm_vals.val {
+            buf[curr_idx..curr_idx + size_of::<u16>()].copy_from_slice(&val.to_be_bytes());
+            curr_idx += size_of::<u16>();
+        }
+        Ok(curr_idx)
+    }
+}
+
+impl TestMgmHkWithGroupValidity {
+    pub fn write_to_be_bytes_self_describing(&self, buf: &mut [u8]) -> Result<usize, ()> {
+        let mut curr_idx = 0;
+        buf[curr_idx] = self.valid as u8;
+        curr_idx += 1;
+        self.last_valid_stamp
+            .write_to_bytes(&mut buf[curr_idx..curr_idx + self.last_valid_stamp.len_as_bytes()])
+            .unwrap();
+        curr_idx += self.last_valid_stamp.len_as_bytes();
+        buf[curr_idx] = 0;
+        curr_idx += 1;
+        buf[curr_idx] = Ptc::Real as u8;
+        curr_idx += 1;
+        buf[curr_idx] = RealPfc::Float as u8;
+        curr_idx += 1;
+        buf[curr_idx..curr_idx + size_of::<f32>()].copy_from_slice(&self.temp.to_be_bytes());
+        curr_idx += size_of::<f32>();
+        buf[curr_idx] = 0;
+        buf[curr_idx] |= (NumOfParamsInfo::VecLenFieldOneByte as u8) << 4;
+        curr_idx += 1;
+        buf[curr_idx] = Ptc::UnsignedInt as u8;
+        curr_idx += 1;
+        buf[curr_idx] = UnsignedPfc::TwoBytes as u8;
+        curr_idx += 1;
+        buf[curr_idx] = 3;
+        for val in self.mgm_vals {
+            buf[curr_idx..curr_idx + size_of::<u16>()].copy_from_slice(&val.to_be_bytes());
+            curr_idx += size_of::<u16>();
+        }
+        Ok(curr_idx)
+    }
+}
+
+#[test]
+pub fn main() {
+    let mut raw_buf: [u8; 32] = [0; 32];
+    let mgm_hk = TestMgmHk {
+        temp: 20.0,
+        mgm_vals: [0x1f1f, 0x2f2f, 0x3f3f],
+    };
+    // 4 byte float + 3 * 2 bytes MGM values
+    let written = mgm_hk.write_to_be_bytes(&mut raw_buf).unwrap();
+    assert_eq!(written, 10);
+
+    let mgm_hk_individual_validity = TestMgmHkWithIndividualValidity {
+        temp: ParamWithValidity {
+            valid: true,
+            val: 20.0,
+        },
+        mgm_vals: ParamWithValidity {
+            valid: true,
+            val: [0x1f1f, 0x2f2f, 0x3f3f],
+        },
+    };
+    let written = mgm_hk_individual_validity
+        .write_to_be_bytes_self_describing(&mut raw_buf)
+        .unwrap();
+    // 3 byte float description, 4 byte float, 4 byte MGM val description, 3 * 2 bytes MGM values
+    assert_eq!(written, 17);
+
+    // The easiest and probably best approach, trading off big advantages for TM downlink capacity:
+    // Use a JSON format
+    let mgm_hk_group_validity = TestMgmHkWithGroupValidity {
+        last_valid_stamp: TimeProvider::from_now_with_u16_days().unwrap(),
+        valid: false,
+        temp: 20.0,
+        mgm_vals: [0x1f1f, 0x2f2f, 0x3f3f],
+    };
+    let mgm_as_json_str = serde_json::to_string(&mgm_hk_group_validity).unwrap();
+    println!(
+        "JSON string with length {}: {}",
+        mgm_as_json_str.len(),
+        mgm_as_json_str
+    );
+}
diff --git a/fsrc-core/tests/pool_test.rs b/satrs-core/tests/pools.rs
similarity index 85%
rename from fsrc-core/tests/pool_test.rs
rename to satrs-core/tests/pools.rs
index 3187fd9..375d624 100644
--- a/fsrc-core/tests/pool_test.rs
+++ b/satrs-core/tests/pools.rs
@@ -1,4 +1,4 @@
-use fsrc_core::pool::{LocalPool, PoolCfg, PoolGuard, PoolProvider, StoreAddr};
+use satrs_core::pool::{LocalPool, PoolCfg, PoolGuard, PoolProvider, StoreAddr};
 use std::ops::DerefMut;
 use std::sync::mpsc;
 use std::sync::mpsc::{Receiver, Sender};
@@ -20,14 +20,15 @@ fn threaded_usage() {
     });
 
     let jh1 = thread::spawn(move || {
-        let mut pool_access = shared_clone.write().unwrap();
         let addr;
         {
             addr = rx.recv().expect("Receiving store address failed");
+            let mut pool_access = shared_clone.write().unwrap();
             let pg = PoolGuard::new(pool_access.deref_mut(), addr);
             let read_res = pg.read().expect("Reading failed");
             assert_eq!(read_res, DUMMY_DATA);
         }
+        let pool_access = shared_clone.read().unwrap();
         assert!(!pool_access.has_element_at(&addr).expect("Invalid address"));
     });
     jh0.join().unwrap();
diff --git a/satrs-core/tests/pus_autogen_events.rs b/satrs-core/tests/pus_autogen_events.rs
new file mode 100644
index 0000000..eaec7e6
--- /dev/null
+++ b/satrs-core/tests/pus_autogen_events.rs
@@ -0,0 +1,94 @@
+#![allow(dead_code, unused_imports)]
+
+use satrs_core::events::{
+    EventU32, EventU32TypedSev, GenericEvent, HasSeverity, LargestEventRaw, LargestGroupIdRaw,
+    Severity, SeverityInfo, SeverityLow, SeverityMedium,
+};
+use std::convert::AsRef;
+
+#[derive(Debug)]
+struct GroupIdIntrospection {
+    name: &'static str,
+    id: LargestGroupIdRaw,
+}
+
+#[derive(Debug)]
+struct EventIntrospection {
+    name: &'static str,
+    group_id: GroupIdIntrospection,
+    event: &'static EventU32,
+    info: &'static str,
+}
+
+//#[event(descr="This is some info event")]
+const INFO_EVENT_0: EventU32TypedSev<SeverityInfo> = EventU32TypedSev::const_new(0, 0);
+const INFO_EVENT_0_ERASED: EventU32 = EventU32::const_from_info(INFO_EVENT_0);
+
+// This is ideally auto-generated
+const INFO_EVENT_0_INTROSPECTION: EventIntrospection = EventIntrospection {
+    name: "INFO_EVENT_0",
+    group_id: GroupIdIntrospection {
+        id: 0,
+        name: "Group ID 0 without name",
+    },
+    event: &INFO_EVENT_0_ERASED,
+    info: "This is some info event",
+};
+
+//#[event(descr="This is some low severity event")]
+const SOME_LOW_SEV_EVENT: EventU32TypedSev<SeverityLow> = EventU32TypedSev::const_new(0, 12);
+
+//const EVENT_LIST: [&'static Event; 2] = [&INFO_EVENT_0, &SOME_LOW_SEV_EVENT];
+
+//#[event_group]
+const TEST_GROUP_NAME: u16 = 1;
+// Auto-generated?
+const TEST_GROUP_NAME_NAME: &str = "TEST_GROUP_NAME";
+
+//#[event(desc="Some medium severity event")]
+const MEDIUM_SEV_EVENT_IN_OTHER_GROUP: EventU32TypedSev<SeverityMedium> =
+    EventU32TypedSev::const_new(TEST_GROUP_NAME, 0);
+const MEDIUM_SEV_EVENT_IN_OTHER_GROUP_REDUCED: EventU32 =
+    EventU32::const_from_medium(MEDIUM_SEV_EVENT_IN_OTHER_GROUP);
+
+// Also auto-generated
+const MEDIUM_SEV_EVENT_IN_OTHER_GROUP_INTROSPECTION: EventIntrospection = EventIntrospection {
+    name: "MEDIUM_SEV_EVENT_IN_OTHER_GROUP",
+    group_id: GroupIdIntrospection {
+        name: TEST_GROUP_NAME_NAME,
+        id: TEST_GROUP_NAME,
+    },
+    event: &MEDIUM_SEV_EVENT_IN_OTHER_GROUP_REDUCED,
+    info: "Some medium severity event",
+};
+
+const CONST_SLICE: &'static [u8] = &[0, 1, 2, 3];
+const INTROSPECTION_FOR_TEST_GROUP_0: [&EventIntrospection; 2] =
+    [&INFO_EVENT_0_INTROSPECTION, &INFO_EVENT_0_INTROSPECTION];
+
+//const INTROSPECTION_FOR_TABLE: &'static [&EventIntrospection] = &INTROSPECTION_FOR_TEST_GROUP_0;
+
+const INTROSPECTION_FOR_TEST_GROUP_NAME: [&EventIntrospection; 1] =
+    [&MEDIUM_SEV_EVENT_IN_OTHER_GROUP_INTROSPECTION];
+//const BLAH: &'static [&EventIntrospection] = &INTROSPECTION_FOR_TEST_GROUP_NAME;
+
+const ALL_EVENTS: [&[&EventIntrospection]; 2] = [
+    &INTROSPECTION_FOR_TEST_GROUP_0,
+    &INTROSPECTION_FOR_TEST_GROUP_NAME,
+];
+
+#[test]
+fn main() {
+    //let test = stringify!(INFO_EVENT);
+    //println!("{:?}", test);
+    //for event in EVENT_LIST {
+    //    println!("{:?}", event);
+    //}
+    //for events in ALL_EVENTS.into_iter().flatten() {
+    //    dbg!("{:?}", events);
+    //}
+    //for introspection_info in INTROSPECTION_FOR_TEST_GROUP {
+    //    dbg!("{:?}", introspection_info);
+    //}
+    //let test_struct =
+}
diff --git a/satrs-core/tests/pus_events.rs b/satrs-core/tests/pus_events.rs
new file mode 100644
index 0000000..8030bb9
--- /dev/null
+++ b/satrs-core/tests/pus_events.rs
@@ -0,0 +1,162 @@
+use satrs_core::event_man::{
+    EventManagerWithMpscQueue, MpscEventU32Receiver, MpscEventU32SendProvider, SendEventProvider,
+};
+use satrs_core::events::{EventU32, EventU32TypedSev, Severity, SeverityInfo};
+use satrs_core::params::U32Pair;
+use satrs_core::params::{Params, ParamsHeapless, WritableToBeBytes};
+use satrs_core::pus::event_man::{
+    DefaultPusMgmtBackendProvider, EventReporter, PusEventDispatcher,
+};
+use satrs_core::pus::MpscTmAsVecSender;
+use spacepackets::ecss::{PusError, PusPacket};
+use spacepackets::tm::PusTm;
+use std::sync::mpsc::{channel, SendError, TryRecvError};
+use std::thread;
+
+const INFO_EVENT: EventU32TypedSev<SeverityInfo> =
+    EventU32TypedSev::<SeverityInfo>::const_new(1, 0);
+const LOW_SEV_EVENT: EventU32 = EventU32::const_new(Severity::LOW, 1, 5);
+const EMPTY_STAMP: [u8; 7] = [0; 7];
+
+#[derive(Debug, Clone)]
+pub enum CustomTmSenderError {
+    SendError(SendError<Vec<u8>>),
+    PusError(PusError),
+}
+
+#[test]
+fn test_threaded_usage() {
+    let (event_sender, event_man_receiver) = channel();
+    let event_receiver = MpscEventU32Receiver::new(event_man_receiver);
+    let mut event_man = EventManagerWithMpscQueue::new(Box::new(event_receiver));
+
+    let (pus_event_man_tx, pus_event_man_rx) = channel();
+    let pus_event_man_send_provider = MpscEventU32SendProvider::new(1, pus_event_man_tx);
+    event_man.subscribe_all(pus_event_man_send_provider.id());
+    event_man.add_sender(pus_event_man_send_provider);
+    let (event_tx, event_rx) = channel();
+    let reporter = EventReporter::new(0x02, 128).expect("Creating event reporter failed");
+    let backend = DefaultPusMgmtBackendProvider::<EventU32>::default();
+    let mut pus_event_man = PusEventDispatcher::new(reporter, Box::new(backend));
+    // PUS + Generic event manager thread
+    let jh0 = thread::spawn(move || {
+        let mut sender = MpscTmAsVecSender::new(0, "event_sender", event_tx);
+        let mut event_cnt = 0;
+        let mut params_array: [u8; 128] = [0; 128];
+        loop {
+            let res = event_man.try_event_handling();
+            assert!(res.is_ok());
+            match pus_event_man_rx.try_recv() {
+                Ok((event, aux_data)) => {
+                    let mut gen_event = |aux_data| {
+                        pus_event_man.generate_pus_event_tm_generic(
+                            &mut sender,
+                            &EMPTY_STAMP,
+                            event,
+                            aux_data,
+                        )
+                    };
+                    let res = if let Some(aux_data) = aux_data {
+                        match aux_data {
+                            Params::Heapless(heapless) => match heapless {
+                                ParamsHeapless::Raw(raw) => {
+                                    raw.write_to_be_bytes(&mut params_array)
+                                        .expect("Writing raw parameter failed");
+                                    gen_event(Some(&params_array[0..raw.raw_len()]))
+                                }
+                                ParamsHeapless::EcssEnum(e) => {
+                                    e.write_to_be_bytes(&mut params_array)
+                                        .expect("Writing ECSS enum failed");
+                                    gen_event(Some(&params_array[0..e.raw_len()]))
+                                }
+                            },
+                            Params::Vec(vec) => gen_event(Some(vec.as_slice())),
+                            Params::String(str) => gen_event(Some(str.as_bytes())),
+                            Params::Store(_) => gen_event(None),
+                        }
+                    } else {
+                        gen_event(None)
+                    };
+                    event_cnt += 1;
+                    assert!(res.is_ok());
+                    assert!(res.unwrap());
+                    if event_cnt == 2 {
+                        break;
+                    }
+                }
+                Err(e) => {
+                    if let TryRecvError::Disconnected = e {
+                        panic!("Event receiver disconnected!")
+                    }
+                }
+            }
+        }
+    });
+
+    // Event sender and TM checker thread
+    let jh1 = thread::spawn(move || {
+        event_sender
+            .send((INFO_EVENT.into(), None))
+            .expect("Sending info event failed");
+        loop {
+            match event_rx.try_recv() {
+                // Event TM received successfully
+                Ok(event_tm) => {
+                    let tm =
+                        PusTm::from_bytes(event_tm.as_slice(), 7).expect("Deserializing TM failed");
+                    assert_eq!(tm.0.service(), 5);
+                    assert_eq!(tm.0.subservice(), 1);
+                    let src_data = tm.0.source_data();
+                    assert!(src_data.is_some());
+                    let src_data = src_data.unwrap();
+                    assert_eq!(src_data.len(), 4);
+                    let event =
+                        EventU32::from(u32::from_be_bytes(src_data[0..4].try_into().unwrap()));
+                    assert_eq!(event, INFO_EVENT);
+                    break;
+                }
+                Err(e) => {
+                    if let TryRecvError::Disconnected = e {
+                        panic!("Event sender disconnected!")
+                    }
+                }
+            }
+        }
+        event_sender
+            .send((
+                LOW_SEV_EVENT.into(),
+                Some(Params::Heapless((2_u32, 3_u32).into())),
+            ))
+            .expect("Sending low severity event failed");
+        loop {
+            match event_rx.try_recv() {
+                // Event TM received successfully
+                Ok(event_tm) => {
+                    let tm =
+                        PusTm::from_bytes(event_tm.as_slice(), 7).expect("Deserializing TM failed");
+                    assert_eq!(tm.0.service(), 5);
+                    assert_eq!(tm.0.subservice(), 2);
+                    let src_data = tm.0.source_data();
+                    assert!(src_data.is_some());
+                    let src_data = src_data.unwrap();
+                    assert_eq!(src_data.len(), 12);
+                    let event =
+                        EventU32::from(u32::from_be_bytes(src_data[0..4].try_into().unwrap()));
+                    assert_eq!(event, LOW_SEV_EVENT);
+                    let u32_pair: U32Pair =
+                        src_data[4..].try_into().expect("Creating U32Pair failed");
+                    assert_eq!(u32_pair.0, 2);
+                    assert_eq!(u32_pair.1, 3);
+                    break;
+                }
+                Err(e) => {
+                    if let TryRecvError::Disconnected = e {
+                        panic!("Event sender disconnected!")
+                    }
+                }
+            }
+        }
+    });
+    jh0.join().expect("Joining manager thread failed");
+    jh1.join().expect("Joining creator thread failed");
+}
diff --git a/satrs-core/tests/pus_verification.rs b/satrs-core/tests/pus_verification.rs
new file mode 100644
index 0000000..a533dbc
--- /dev/null
+++ b/satrs-core/tests/pus_verification.rs
@@ -0,0 +1,194 @@
+// TODO: Refactor this to also test the STD impl using mpsc
+// TODO: Change back to cross-beam as soon as STD impl was added back for TM.
+#[cfg(feature = "crossbeam")]
+pub mod crossbeam_test {
+    use hashbrown::HashMap;
+    use satrs_core::pool::{LocalPool, PoolCfg, PoolProvider};
+    use satrs_core::pus::verification::{
+        FailParams, RequestId, VerificationReporterCfg, VerificationReporterWithSender,
+    };
+    use satrs_core::pus::MpscTmInStoreSender;
+    use satrs_core::tmtc::tm_helper::SharedTmStore;
+    use spacepackets::ecss::{EcssEnumU16, EcssEnumU8, PusPacket, SerializablePusPacket};
+    use spacepackets::tc::{PusTc, PusTcSecondaryHeader};
+    use spacepackets::tm::PusTm;
+    use spacepackets::SpHeader;
+    use std::sync::{mpsc, Arc, RwLock};
+    use std::thread;
+    use std::time::Duration;
+
+    const TEST_APID: u16 = 0x03;
+    const FIXED_STAMP: [u8; 7] = [0; 7];
+    const PACKETS_SENT: u8 = 8;
+
+    /// This test also shows how the verification report could be used in a multi-threaded context,
+    /// wrapping it into an [Arc] and [Mutex] and then passing it to two threads.
+    ///
+    ///  - The first thread generates a acceptance, a start, two steps and one completion report
+    ///  - The second generates an acceptance and start success report and a completion failure
+    ///  - The third thread is the verification receiver. In the test case, it verifies the other two
+    ///    threads have sent the correct expected verification reports
+    #[test]
+    fn test_shared_reporter() {
+        // We use a synced sequence count provider here because both verification reporters have the
+        // the same APID. If they had distinct APIDs, the more correct approach would be to have
+        // each reporter have an own sequence count provider.
+        let cfg = VerificationReporterCfg::new(TEST_APID, 1, 2, 8).unwrap();
+        // Shared pool object to store the verification PUS telemetry
+        let pool_cfg = PoolCfg::new(vec![(10, 32), (10, 64), (10, 128), (10, 1024)]);
+        let shared_tm_store = SharedTmStore::new(Box::new(LocalPool::new(pool_cfg.clone())));
+        let shared_tc_pool_0 = Arc::new(RwLock::new(LocalPool::new(pool_cfg)));
+        let shared_tc_pool_1 = shared_tc_pool_0.clone();
+        let (tx, rx) = mpsc::channel();
+        let sender =
+            MpscTmInStoreSender::new(0, "verif_sender", shared_tm_store.clone(), tx.clone());
+        let mut reporter_with_sender_0 =
+            VerificationReporterWithSender::new(&cfg, Box::new(sender));
+        let mut reporter_with_sender_1 = reporter_with_sender_0.clone();
+        // For test purposes, we retrieve the request ID from the TCs and pass them to the receiver
+        // tread.
+        let req_id_0;
+        let req_id_1;
+
+        let (tx_tc_0, rx_tc_0) = crossbeam_channel::bounded(3);
+        let (tx_tc_1, rx_tc_1) = crossbeam_channel::bounded(3);
+        {
+            let mut tc_guard = shared_tc_pool_0.write().unwrap();
+            let mut sph = SpHeader::tc_unseg(TEST_APID, 0, 0).unwrap();
+            let tc_header = PusTcSecondaryHeader::new_simple(17, 1);
+            let pus_tc_0 = PusTc::new(&mut sph, tc_header, None, true);
+            req_id_0 = RequestId::new(&pus_tc_0);
+            let (addr, mut buf) = tc_guard.free_element(pus_tc_0.len_packed()).unwrap();
+            pus_tc_0.write_to_bytes(&mut buf).unwrap();
+            tx_tc_0.send(addr).unwrap();
+            let mut sph = SpHeader::tc_unseg(TEST_APID, 1, 0).unwrap();
+            let tc_header = PusTcSecondaryHeader::new_simple(5, 1);
+            let pus_tc_1 = PusTc::new(&mut sph, tc_header, None, true);
+            req_id_1 = RequestId::new(&pus_tc_1);
+            let (addr, mut buf) = tc_guard.free_element(pus_tc_0.len_packed()).unwrap();
+            pus_tc_1.write_to_bytes(&mut buf).unwrap();
+            tx_tc_1.send(addr).unwrap();
+        }
+        let verif_sender_0 = thread::spawn(move || {
+            let mut tc_buf: [u8; 1024] = [0; 1024];
+            let tc_addr = rx_tc_0
+                .recv_timeout(Duration::from_millis(20))
+                .expect("Receive timeout");
+            let tc_len;
+            {
+                let mut tc_guard = shared_tc_pool_0.write().unwrap();
+                let pg = tc_guard.read_with_guard(tc_addr);
+                let buf = pg.read().unwrap();
+                tc_len = buf.len();
+                tc_buf[0..tc_len].copy_from_slice(buf);
+            }
+            let (_tc, _) = PusTc::from_bytes(&tc_buf[0..tc_len]).unwrap();
+            let accepted_token;
+
+            let token = reporter_with_sender_0.add_tc_with_req_id(req_id_0);
+            accepted_token = reporter_with_sender_0
+                .acceptance_success(token, Some(&FIXED_STAMP))
+                .expect("Acceptance success failed");
+
+            // Do some start handling here
+            let started_token;
+            started_token = reporter_with_sender_0
+                .start_success(accepted_token, Some(&FIXED_STAMP))
+                .expect("Start success failed");
+            // Do some step handling here
+            reporter_with_sender_0
+                .step_success(&started_token, Some(&FIXED_STAMP), EcssEnumU8::new(0))
+                .expect("Start success failed");
+
+            // Finish up
+            reporter_with_sender_0
+                .step_success(&started_token, Some(&FIXED_STAMP), EcssEnumU8::new(1))
+                .expect("Start success failed");
+            reporter_with_sender_0
+                .completion_success(started_token, Some(&FIXED_STAMP))
+                .expect("Completion success failed");
+        });
+
+        let verif_sender_1 = thread::spawn(move || {
+            let mut tc_buf: [u8; 1024] = [0; 1024];
+            let tc_addr = rx_tc_1
+                .recv_timeout(Duration::from_millis(20))
+                .expect("Receive timeout");
+            let tc_len;
+            {
+                let mut tc_guard = shared_tc_pool_1.write().unwrap();
+                let pg = tc_guard.read_with_guard(tc_addr);
+                let buf = pg.read().unwrap();
+                tc_len = buf.len();
+                tc_buf[0..tc_len].copy_from_slice(buf);
+            }
+            let (tc, _) = PusTc::from_bytes(&tc_buf[0..tc_len]).unwrap();
+            let token = reporter_with_sender_1.add_tc(&tc);
+            let accepted_token = reporter_with_sender_1
+                .acceptance_success(token, Some(&FIXED_STAMP))
+                .expect("Acceptance success failed");
+            let started_token = reporter_with_sender_1
+                .start_success(accepted_token, Some(&FIXED_STAMP))
+                .expect("Start success failed");
+            let fail_code = EcssEnumU16::new(2);
+            let params = FailParams::new(Some(&FIXED_STAMP), &fail_code, None);
+            reporter_with_sender_1
+                .completion_failure(started_token, params)
+                .expect("Completion success failed");
+        });
+
+        let verif_receiver = thread::spawn(move || {
+            let mut packet_counter = 0;
+            let mut tm_buf: [u8; 1024] = [0; 1024];
+            let mut verif_map = HashMap::new();
+            while packet_counter < PACKETS_SENT {
+                let verif_addr = rx
+                    .recv_timeout(Duration::from_millis(50))
+                    .expect("Packet reception timeout");
+                let tm_len;
+                let shared_tm_store = shared_tm_store.clone_backing_pool();
+                {
+                    let mut rg = shared_tm_store.write().expect("Error locking shared pool");
+                    let store_guard = rg.read_with_guard(verif_addr);
+                    let slice = store_guard.read().expect("Error reading TM slice");
+                    tm_len = slice.len();
+                    tm_buf[0..tm_len].copy_from_slice(slice);
+                }
+                let (pus_tm, _) = PusTm::from_bytes(&tm_buf[0..tm_len], 7)
+                    .expect("Error reading verification TM");
+                let req_id = RequestId::from_bytes(
+                    &pus_tm.source_data().expect("Invalid TM source data")
+                        [0..RequestId::SIZE_AS_BYTES],
+                )
+                .unwrap();
+                if !verif_map.contains_key(&req_id) {
+                    let mut content = Vec::new();
+                    content.push(pus_tm.subservice());
+                    verif_map.insert(req_id, content);
+                } else {
+                    let content = verif_map.get_mut(&req_id).unwrap();
+                    content.push(pus_tm.subservice())
+                }
+                packet_counter += 1;
+            }
+            for (req_id, content) in verif_map {
+                if req_id == req_id_1 {
+                    assert_eq!(content[0], 1);
+                    assert_eq!(content[1], 3);
+                    assert_eq!(content[2], 8);
+                } else if req_id == req_id_0 {
+                    assert_eq!(content[0], 1);
+                    assert_eq!(content[1], 3);
+                    assert_eq!(content[2], 5);
+                    assert_eq!(content[3], 5);
+                    assert_eq!(content[4], 7);
+                } else {
+                    panic!("Unexpected request ID {:?}", req_id);
+                }
+            }
+        });
+        verif_sender_0.join().expect("Joining thread 0 failed");
+        verif_sender_1.join().expect("Joining thread 1 failed");
+        verif_receiver.join().expect("Joining thread 2 failed");
+    }
+}
diff --git a/satrs-example-stm32f3-disco/.gitignore b/satrs-example-stm32f3-disco/.gitignore
new file mode 100644
index 0000000..767b60e
--- /dev/null
+++ b/satrs-example-stm32f3-disco/.gitignore
@@ -0,0 +1,3 @@
+/target
+/itm.txt
+/.cargo/config*
diff --git a/satrs-example-stm32f3-disco/.vscode/.gitignore b/satrs-example-stm32f3-disco/.vscode/.gitignore
new file mode 100644
index 0000000..3cdd741
--- /dev/null
+++ b/satrs-example-stm32f3-disco/.vscode/.gitignore
@@ -0,0 +1,2 @@
+/settings.json
+/.cortex-debug.*
diff --git a/satrs-example-stm32f3-disco/.vscode/extensions.json b/satrs-example-stm32f3-disco/.vscode/extensions.json
new file mode 100644
index 0000000..dd3369c
--- /dev/null
+++ b/satrs-example-stm32f3-disco/.vscode/extensions.json
@@ -0,0 +1,12 @@
+{
+	// See https://go.microsoft.com/fwlink/?LinkId=827846 to learn about workspace recommendations.
+	// Extension identifier format: ${publisher}.${name}. Example: vscode.csharp
+
+	// List of extensions which should be recommended for users of this workspace.
+	"recommendations": [
+		"rust-lang.rust",
+		"marus25.cortex-debug",
+	],
+	// List of extensions recommended by VS Code that should not be recommended for users of this workspace.
+	"unwantedRecommendations": []
+}
\ No newline at end of file
diff --git a/satrs-example-stm32f3-disco/.vscode/launch.json b/satrs-example-stm32f3-disco/.vscode/launch.json
new file mode 100644
index 0000000..f9e65f2
--- /dev/null
+++ b/satrs-example-stm32f3-disco/.vscode/launch.json
@@ -0,0 +1,66 @@
+{
+    /* 
+     * Requires the Rust Language Server (RLS) and Cortex-Debug extensions
+     * https://marketplace.visualstudio.com/items?itemName=rust-lang.rust
+     * https://marketplace.visualstudio.com/items?itemName=marus25.cortex-debug
+     */
+    "version": "0.2.0",
+    "configurations": [
+        {
+            /* Launches debug session for currently open example */
+            "type": "cortex-debug",
+            "request": "launch",
+            "name": "Debug",
+            "servertype": "openocd",
+            "cwd": "${workspaceRoot}",
+            "preLaunchTask": "cargo build",
+            "runToEntryPoint": "true",
+            "executable": "./target/thumbv7em-none-eabihf/debug/satrs-example-stm32f3-disco",
+            "preLaunchCommands": ["break rust_begin_unwind"],
+            "device": "STM32F303VCT6",
+            "configFiles": [
+                "${workspaceRoot}/.vscode/openocd-helpers.tcl",
+                "interface/stlink.cfg",
+                "target/stm32f3x.cfg"
+            ],
+            "svdFile": "${env:HOME}/.svd/STM32F303.svd",
+            "swoConfig": {
+                "enabled": true,
+                "cpuFrequency": 8000000,
+                "swoFrequency": 2000000,
+                "source": "probe",
+                "decoders": [
+                    { "type": "console", "label": "ITM", "port": 0 }
+                ]
+            }
+        },
+        {
+            /* Launches debug session for currently open example */
+            "type": "cortex-debug",
+            "request": "launch",
+            "name": "Release",
+            "servertype": "openocd",
+            "cwd": "${workspaceRoot}",
+            "preLaunchTask": "cargo build",
+            "runToEntryPoint": "true",
+            "executable": "./target/thumbv7em-none-eabihf/release/satrs-example-stm32f3-disco",
+            "preLaunchCommands": ["break rust_begin_unwind"],
+            "device": "STM32F303VCT6",
+            "configFiles": [
+                "${workspaceRoot}/.vscode/openocd-helpers.tcl",
+                "interface/stlink.cfg",
+                "target/stm32f3x.cfg"
+            ],
+            "svdFile": "${env:HOME}/.svd/STM32F303.svd",
+            "swoConfig": {
+                "enabled": true,
+                "cpuFrequency": 8000000,
+                "swoFrequency": 2000000,
+                "source": "probe",
+                "decoders": [
+                    { "type": "console", "label": "ITM", "port": 0 }
+                ]
+            }
+        }
+    ]
+}
\ No newline at end of file
diff --git a/satrs-example-stm32f3-disco/.vscode/openocd-helpers.tcl b/satrs-example-stm32f3-disco/.vscode/openocd-helpers.tcl
new file mode 100644
index 0000000..4da6f7e
--- /dev/null
+++ b/satrs-example-stm32f3-disco/.vscode/openocd-helpers.tcl
@@ -0,0 +1,17 @@
+#
+# Cortex-Debug extension calls this function during initialization. You can copy this
+# file, modify it and specifyy it as one of the config files supplied in launch.json
+# preferably at the beginning.
+#
+# Note that this file simply defines a function for use later when it is time to configure
+# for SWO.
+#
+set USE_SWO 0
+proc CDSWOConfigure { CDCPUFreqHz CDSWOFreqHz CDSWOOutput } {
+    # Alternative option: Pipe ITM output into itm.txt file
+    # tpiu config internal itm.txt uart off $CDCPUFreqHz
+
+    # Default option so SWO display of VS code works.
+    tpiu config internal $CDSWOOutput uart off $CDCPUFreqHz $CDSWOFreqHz
+    itm port 0 on
+}
diff --git a/satrs-example-stm32f3-disco/.vscode/settings_default.json b/satrs-example-stm32f3-disco/.vscode/settings_default.json
new file mode 100644
index 0000000..e78c4ec
--- /dev/null
+++ b/satrs-example-stm32f3-disco/.vscode/settings_default.json
@@ -0,0 +1,3 @@
+{
+    "cortex-debug.gdbPath.linux": "gdb-multiarch"
+}
diff --git a/satrs-example-stm32f3-disco/.vscode/tasks.json b/satrs-example-stm32f3-disco/.vscode/tasks.json
new file mode 100644
index 0000000..200a837
--- /dev/null
+++ b/satrs-example-stm32f3-disco/.vscode/tasks.json
@@ -0,0 +1,20 @@
+{
+    // See https://go.microsoft.com/fwlink/?LinkId=733558 
+    // for the documentation about the tasks.json format
+    "version": "2.0.0",
+    "tasks": [
+        {
+            "label": "cargo build",
+            "type": "shell",
+            "command": "~/.cargo/bin/cargo", // note: full path to the cargo
+            "args": [
+                "build"
+            ],
+            "group": {
+                "kind": "build",
+                "isDefault": true
+            }
+        },
+
+    ]
+}
\ No newline at end of file
diff --git a/Cargo.lock b/satrs-example-stm32f3-disco/Cargo.lock
similarity index 56%
rename from Cargo.lock
rename to satrs-example-stm32f3-disco/Cargo.lock
index 0e51f1f..e8d9f02 100644
--- a/Cargo.lock
+++ b/satrs-example-stm32f3-disco/Cargo.lock
@@ -3,39 +3,19 @@
 version = 3
 
 [[package]]
-name = "ahash"
-version = "0.7.6"
+name = "accelerometer"
+version = "0.12.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fcb51a0695d8f838b1ee009b3fbf66bda078cd64590202a864a8f3e8c4315c47"
+checksum = "1a4586d95cb0695e748760c9a751141eebb68265b1b20392a0f14db608679f7a"
 dependencies = [
- "getrandom",
- "once_cell",
- "version_check",
-]
-
-[[package]]
-name = "aho-corasick"
-version = "0.7.19"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b4f55bd91a0978cbfd91c457a164bab8b4001c833b7f323132c0a4e1922dd44e"
-dependencies = [
- "memchr",
-]
-
-[[package]]
-name = "android_system_properties"
-version = "0.1.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "819e7219dbd41043ac279b19830f2efc897156490d7fd6ea916720117ee66311"
-dependencies = [
- "libc",
+ "micromath",
 ]
 
 [[package]]
 name = "atomic-polyfill"
-version = "0.1.10"
+version = "0.1.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9c041a8d9751a520ee19656232a18971f18946a7900f1520ee4400002244dd89"
+checksum = "e3ff7eb3f316534d83a8a2c3d1674ace8a5a71198eba31e2e2b597833f699b28"
 dependencies = [
  "critical-section",
 ]
@@ -61,12 +41,6 @@ version = "1.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f8fe8f5a8a398345e52358e18ff07cc17a568fbca5c6f73873d3a62056309603"
 
-[[package]]
-name = "bit_field"
-version = "0.10.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dcb6dd1c2376d2e096796e234a70e17e94cc2d5d54ff8ce42b28cef1d0d359a4"
-
 [[package]]
 name = "bitfield"
 version = "0.13.2"
@@ -80,20 +54,14 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"
 
 [[package]]
-name = "bumpalo"
-version = "3.11.0"
+name = "bxcan"
+version = "0.6.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c1ad822118d20d2c234f427000d5acc36eabe1e29a348c89b63dd60b13f28e5d"
-
-[[package]]
-name = "bus"
-version = "2.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "80cb4625f5b60155ff1018c9d4ce2e38bf5ae3e5780dfab9fa68bb44a6b751e2"
+checksum = "4b13b4b2ea9ab2ba924063ebb86ad895cb79f4a79bf90f27949eb20c335b30f9"
 dependencies = [
- "crossbeam-channel",
- "num_cpus",
- "parking_lot_core",
+ "bitflags",
+ "nb 1.0.0",
+ "vcell",
 ]
 
 [[package]]
@@ -102,6 +70,15 @@ version = "1.4.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "14c189c53d098945499cdfa7ecc63567cf3886b3332b312a5b4585d8d3a6a610"
 
+[[package]]
+name = "cast"
+version = "0.2.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4c24dab4283a142afa2fdca129b80ad2c6284e073930f964c3a1293c225ee39a"
+dependencies = [
+ "rustc_version 0.4.0",
+]
+
 [[package]]
 name = "cfg-if"
 version = "1.0.0"
@@ -110,28 +87,14 @@ checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
 
 [[package]]
 name = "chrono"
-version = "0.4.22"
+version = "0.4.23"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bfd4d1b31faaa3a89d7934dbded3111da0d2ef28e3ebccdb4f0179f5929d1ef1"
+checksum = "16b0a3d9ed01224b22057780a37bb8c5dbfe1be8ba48678e7bf57ec4b385411f"
 dependencies = [
- "iana-time-zone",
  "num-integer",
  "num-traits",
- "winapi",
 ]
 
-[[package]]
-name = "cobs"
-version = "0.2.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "67ba02a97a2bd10f4b59b25c7973101c79642302776489e030cd13cdab09ed15"
-
-[[package]]
-name = "core-foundation-sys"
-version = "0.8.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5827cebf4670468b8772dd191856768aedcb1b0278a04f989f7766351917b9dc"
-
 [[package]]
 name = "cortex-m"
 version = "0.7.6"
@@ -145,79 +108,101 @@ dependencies = [
 ]
 
 [[package]]
-name = "crc"
-version = "3.0.0"
+name = "cortex-m-rt"
+version = "0.7.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "53757d12b596c16c78b83458d732a5d1a17ab3f53f2f7412f6fb57cc8a140ab3"
+checksum = "d6d3328b8b5534f0c90acd66b68950f2763b37e0173cac4d8b4937c4a80761f9"
 dependencies = [
- "crc-catalog",
+ "cortex-m-rt-macros",
 ]
 
 [[package]]
-name = "crc-catalog"
-version = "2.1.0"
+name = "cortex-m-rt-macros"
+version = "0.7.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2d0165d2900ae6778e36e80bbc4da3b5eefccee9ba939761f9c2882a5d9af3ff"
+checksum = "f0f6f3e36f203cfedbc78b357fb28730aa2c6dc1ab060ee5c2405e843988d3c7"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "cortex-m-rtic"
+version = "1.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c6b82f1c39acd6c3a35c2013b6110c20f5bc534522791fabadeed49ccada2dce"
+dependencies = [
+ "bare-metal 1.0.0",
+ "cortex-m",
+ "cortex-m-rtic-macros",
+ "heapless",
+ "rtic-core",
+ "rtic-monotonic",
+ "version_check",
+]
+
+[[package]]
+name = "cortex-m-rtic-macros"
+version = "1.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9e8e9645ef54bec1cf70ac33e9bf9566e6507ab5b41ae6baf3735662194e8607"
+dependencies = [
+ "proc-macro-error",
+ "proc-macro2",
+ "quote",
+ "rtic-syntax",
+ "syn",
+]
 
 [[package]]
 name = "critical-section"
-version = "0.2.7"
+version = "1.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "95da181745b56d4bd339530ec393508910c909c784e8962d15d722bacf0bcbcd"
+checksum = "6548a0ad5d2549e111e1f6a11a6c2e2d00ce6a3dafe22948d67c2b443f775e52"
+
+[[package]]
+name = "darling"
+version = "0.14.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b0dd3cd20dc6b5a876612a6e5accfe7f3dd883db6d07acfbf14c128f61550dfa"
 dependencies = [
- "bare-metal 1.0.0",
- "cfg-if",
- "cortex-m",
- "riscv",
+ "darling_core",
+ "darling_macro",
 ]
 
 [[package]]
-name = "crossbeam-channel"
-version = "0.5.6"
+name = "darling_core"
+version = "0.14.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c2dd04ddaf88237dc3b8d8f9a3c1004b506b54b3313403944054d23c0870c521"
-dependencies = [
- "cfg-if",
- "crossbeam-utils",
-]
-
-[[package]]
-name = "crossbeam-utils"
-version = "0.8.11"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "51887d4adc7b564537b15adcfb307936f8075dfcd5f00dde9a9f1d29383682bc"
-dependencies = [
- "cfg-if",
- "once_cell",
-]
-
-[[package]]
-name = "delegate"
-version = "0.7.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d70a2d4995466955a415223acf3c9c934b9ff2339631cdf4ffc893da4bacd717"
+checksum = "a784d2ccaf7c98501746bf0be29b2022ba41fd62a2e622af997a03e9f972859f"
 dependencies = [
+ "fnv",
+ "ident_case",
  "proc-macro2",
  "quote",
  "syn",
 ]
 
 [[package]]
-name = "delegate"
-version = "0.8.0"
+name = "darling_macro"
+version = "0.14.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "082a24a9967533dc5d743c602157637116fc1b52806d694a5a45e6f32567fcdd"
+checksum = "7618812407e9402654622dd402b0a89dff9ba93badd6540781526117b92aab7e"
 dependencies = [
- "proc-macro2",
+ "darling_core",
  "quote",
  "syn",
 ]
 
 [[package]]
-name = "downcast-rs"
-version = "1.2.0"
+name = "embedded-dma"
+version = "0.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9ea835d29036a4087793836fa931b08837ad5e957da9e23886b29586fb9b6650"
+checksum = "994f7e5b5cb23521c22304927195f236813053eb9c065dd2226a32ba64695446"
+dependencies = [
+ "stable_deref_trait",
+]
 
 [[package]]
 name = "embedded-hal"
@@ -230,41 +215,73 @@ dependencies = [
 ]
 
 [[package]]
-name = "fsrc-core"
-version = "0.1.0"
-dependencies = [
- "bus",
- "crossbeam-channel",
- "delegate 0.8.0",
- "downcast-rs",
- "hashbrown",
- "num-traits",
- "once_cell",
- "postcard",
- "serde",
- "spacepackets",
- "zerocopy",
-]
-
-[[package]]
-name = "fsrc-example"
-version = "0.1.0"
-dependencies = [
- "crossbeam-channel",
- "delegate 0.8.0",
- "fsrc-core",
- "spacepackets",
-]
-
-[[package]]
-name = "getrandom"
-version = "0.2.7"
+name = "embedded-time"
+version = "0.12.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4eb1a864a501629691edf6c15a593b7a51eebaa1e8468e9ddc623de7c9b58ec6"
+checksum = "d7a4b4d10ac48d08bfe3db7688c402baadb244721f30a77ce360bd24c3dffe58"
 dependencies = [
- "cfg-if",
- "libc",
- "wasi",
+ "num",
+]
+
+[[package]]
+name = "enumset"
+version = "1.0.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "19be8061a06ab6f3a6cf21106c873578bf01bd42ad15e0311a9c76161cb1c753"
+dependencies = [
+ "enumset_derive",
+]
+
+[[package]]
+name = "enumset_derive"
+version = "0.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "03e7b551eba279bf0fa88b83a46330168c1560a52a94f5126f892f0b364ab3e0"
+dependencies = [
+ "darling",
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "fnv"
+version = "1.0.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3f9eec918d3f24069decb9af1554cad7c880e2da24a9afd88aca000531ab82c1"
+
+[[package]]
+name = "fugit"
+version = "0.3.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7ab17bb279def6720d058cb6c052249938e7f99260ab534879281a95367a87e5"
+dependencies = [
+ "gcd",
+]
+
+[[package]]
+name = "gcd"
+version = "2.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a4b1b088ad0a967aa29540456b82fc8903f854775d33f71e9709c4efb3dfbfd2"
+
+[[package]]
+name = "generic-array"
+version = "0.11.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "667f6ea017b297ec65b8a108c6e9ad6879460721fb3b6b23abf690970147fc28"
+dependencies = [
+ "typenum",
+]
+
+[[package]]
+name = "generic-array"
+version = "0.14.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bff49e947297f3312447abdca79f45f4738097cc82b06e72054d2223f601f1b9"
+dependencies = [
+ "typenum",
+ "version_check",
 ]
 
 [[package]]
@@ -281,9 +298,6 @@ name = "hashbrown"
 version = "0.12.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8a9ee70c43aaf417c914396645a0fa852624801b24ebb7ae78fe8272889ac888"
-dependencies = [
- "ahash",
-]
 
 [[package]]
 name = "heapless"
@@ -294,60 +308,39 @@ dependencies = [
  "atomic-polyfill",
  "hash32",
  "rustc_version 0.4.0",
- "serde",
  "spin",
  "stable_deref_trait",
 ]
 
 [[package]]
-name = "hermit-abi"
-version = "0.1.19"
+name = "ident_case"
+version = "1.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "62b467343b94ba476dcb2500d242dadbb39557df889310ac77c5d99100aaac33"
+checksum = "b9e0384b61958566e926dc50660321d12159025e767c18e043daf26b70104c39"
+
+[[package]]
+name = "indexmap"
+version = "1.9.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1885e79c1fc4b10f0e172c475f458b7f7b93061064d98c3293e98c5ba0c8b399"
 dependencies = [
- "libc",
+ "autocfg",
+ "hashbrown",
 ]
 
 [[package]]
-name = "iana-time-zone"
-version = "0.1.47"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4c495f162af0bf17656d0014a0eded5f3cd2f365fdd204548c2869db89359dc7"
+name = "itm_logger"
+version = "0.1.3-pre.0"
 dependencies = [
- "android_system_properties",
- "core-foundation-sys",
- "js-sys",
- "once_cell",
- "wasm-bindgen",
- "winapi",
+ "cortex-m",
+ "log",
 ]
 
-[[package]]
-name = "js-sys"
-version = "0.3.59"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "258451ab10b34f8af53416d1fdab72c22e805f0c92a1136d59470ec0b11138b2"
-dependencies = [
- "wasm-bindgen",
-]
-
-[[package]]
-name = "lazy_static"
-version = "1.4.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646"
-
-[[package]]
-name = "libc"
-version = "0.2.132"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8371e4e5341c3a96db127eb2465ac681ced4c433e01dd0e938adbef26ba93ba5"
-
 [[package]]
 name = "lock_api"
-version = "0.4.8"
+version = "0.4.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9f80bf5aacaf25cbfc8210d1cfb718f2bf3b11c4c54e5afe36c236853a8ec390"
+checksum = "435011366fe56583b16cf956f9df0095b405b82d76425bc8981c0e22e60ec4df"
 dependencies = [
  "autocfg",
  "scopeguard",
@@ -363,10 +356,24 @@ dependencies = [
 ]
 
 [[package]]
-name = "memchr"
-version = "2.5.0"
+name = "lsm303dlhc"
+version = "0.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2dffe52ecf27772e601905b7522cb4ef790d2cc203488bbd0e2fe85fcb74566d"
+checksum = "9e5d1a5c290951321d1b0d4a40edd828537de9889134a0e67c5146542ae57706"
+dependencies = [
+ "cast",
+ "embedded-hal",
+ "generic-array 0.11.2",
+]
+
+[[package]]
+name = "micromath"
+version = "1.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bc4010833aea396656c2f91ee704d51a6f1329ec2ab56ffd00bfd56f7481ea94"
+dependencies = [
+ "generic-array 0.14.6",
+]
 
 [[package]]
 name = "nb"
@@ -383,6 +390,28 @@ version = "1.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "546c37ac5d9e56f55e73b677106873d9d9f5190605e41a856503623648488cae"
 
+[[package]]
+name = "num"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8b7a8e9be5e039e2ff869df49155f1c06bd01ade2117ec783e56ab0932b67a8f"
+dependencies = [
+ "num-complex",
+ "num-integer",
+ "num-iter",
+ "num-rational",
+ "num-traits",
+]
+
+[[package]]
+name = "num-complex"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "747d632c0c558b87dbabbe6a82f3b4ae03720d0646ac5b7b4dae89394be5f2c5"
+dependencies = [
+ "num-traits",
+]
+
 [[package]]
 name = "num-integer"
 version = "0.1.45"
@@ -393,6 +422,28 @@ dependencies = [
  "num-traits",
 ]
 
+[[package]]
+name = "num-iter"
+version = "0.1.43"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7d03e6c028c5dc5cac6e2dec0efda81fc887605bb3d884578bb6d6bf7514e252"
+dependencies = [
+ "autocfg",
+ "num-integer",
+ "num-traits",
+]
+
+[[package]]
+name = "num-rational"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "12ac428b1cb17fce6f731001d307d351ec70a6d202fc2e60f7d4c5e42d8f4f07"
+dependencies = [
+ "autocfg",
+ "num-integer",
+ "num-traits",
+]
+
 [[package]]
 name = "num-traits"
 version = "0.2.15"
@@ -403,108 +454,93 @@ dependencies = [
 ]
 
 [[package]]
-name = "num_cpus"
-version = "1.13.1"
+name = "panic-itm"
+version = "0.4.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "19e64526ebdee182341572e50e9ad03965aa510cd94427a4549448f285e957a1"
+checksum = "3d577d97d1b31268087b6dddf2470e6794ef5eee87d9dca7fcd0481695391a4c"
 dependencies = [
- "hermit-abi",
- "libc",
+ "cortex-m",
 ]
 
 [[package]]
-name = "once_cell"
-version = "1.14.0"
+name = "paste"
+version = "1.0.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2f7254b99e31cad77da24b08ebf628882739a608578bb1bcdfc1f9c21260d7c0"
+checksum = "d01a5bd0424d00070b0098dd17ebca6f961a959dead1dbcbbbc1d1cd8d3deeba"
 
 [[package]]
-name = "parking_lot_core"
-version = "0.9.3"
+name = "proc-macro-error"
+version = "1.0.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "09a279cbf25cb0757810394fbc1e359949b59e348145c643a939a525692e6929"
+checksum = "da25490ff9892aab3fcf7c36f08cfb902dd3e71ca0f9f9517bea02a73a5ce38c"
 dependencies = [
- "cfg-if",
- "libc",
- "redox_syscall",
- "smallvec",
- "windows-sys",
+ "proc-macro-error-attr",
+ "proc-macro2",
+ "quote",
+ "syn",
+ "version_check",
 ]
 
 [[package]]
-name = "postcard"
-version = "1.0.2"
+name = "proc-macro-error-attr"
+version = "1.0.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1c2b180dc0bade59f03fd005cb967d3f1e5f69b13922dad0cd6e047cb8af2363"
+checksum = "a1be40180e52ecc98ad80b184934baf3d0d29f979574e439af5a55274b35f869"
 dependencies = [
- "cobs",
- "heapless",
- "serde",
+ "proc-macro2",
+ "quote",
+ "version_check",
 ]
 
 [[package]]
 name = "proc-macro2"
-version = "1.0.43"
+version = "1.0.49"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0a2ca2c61bc9f3d74d2886294ab7b9853abd9c1ad903a3ac7815c58989bb7bab"
+checksum = "57a8eca9f9c4ffde41714334dee777596264c7825420f521abc92b5b5deb63a5"
 dependencies = [
  "unicode-ident",
 ]
 
 [[package]]
 name = "quote"
-version = "1.0.21"
+version = "1.0.23"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bbe448f377a7d6961e30f5955f9b8d106c3f5e449d493ee1b125c1d43c2b5179"
+checksum = "8856d8364d252a14d474036ea1358d63c9e6965c8e5c1885c18f73d70bff9c7b"
 dependencies = [
  "proc-macro2",
 ]
 
 [[package]]
-name = "redox_syscall"
-version = "0.2.16"
+name = "rtcc"
+version = "0.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fb5a58c1855b4b6819d59012155603f0b22ad30cad752600aadfcb695265519a"
+checksum = "3623619ce77c09a7d87cf7c61c5c887b9c7dee8805f66af6c4aa5824be4d9930"
 dependencies = [
- "bitflags",
+ "chrono",
 ]
 
 [[package]]
-name = "regex"
-version = "1.6.0"
+name = "rtic-core"
+version = "1.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4c4eb3267174b8c6c2f654116623910a0fef09c4753f8dd83db29c48a0df988b"
-dependencies = [
- "aho-corasick",
- "memchr",
- "regex-syntax",
-]
+checksum = "d9369355b04d06a3780ec0f51ea2d225624db777acbc60abd8ca4832da5c1a42"
 
 [[package]]
-name = "regex-syntax"
-version = "0.6.27"
+name = "rtic-monotonic"
+version = "1.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a3f87b73ce11b1619a3c6332f45341e0047173771e8b8b73f87bfeefb7b56244"
+checksum = "fb8b0b822d1a366470b9cea83a1d4e788392db763539dc4ba022bcc787fece82"
 
 [[package]]
-name = "riscv"
-version = "0.7.0"
+name = "rtic-syntax"
+version = "1.0.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6907ccdd7a31012b70faf2af85cd9e5ba97657cc3987c4f13f8e4d2c2a088aba"
+checksum = "3ad3ae243dd8d0a1b064615f664d4fa7e63929939074c564cbe5efdc4c503065"
 dependencies = [
- "bare-metal 1.0.0",
- "bit_field",
- "riscv-target",
-]
-
-[[package]]
-name = "riscv-target"
-version = "0.1.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "88aa938cda42a0cf62a20cfe8d139ff1af20c2e681212b5b34adb5a58333f222"
-dependencies = [
- "lazy_static",
- "regex",
+ "indexmap",
+ "proc-macro2",
+ "quote",
+ "syn",
 ]
 
 [[package]]
@@ -522,7 +558,24 @@ version = "0.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "bfa0f585226d2e68097d4f95d113b15b83a82e819ab25717ec0590d9584ef366"
 dependencies = [
- "semver 1.0.13",
+ "semver 1.0.16",
+]
+
+[[package]]
+name = "sat-rs-example-stm32f-disco"
+version = "0.1.0"
+dependencies = [
+ "cortex-m",
+ "cortex-m-rt",
+ "cortex-m-rtic",
+ "embedded-hal",
+ "enumset",
+ "heapless",
+ "itm_logger",
+ "panic-itm",
+ "stm32f3-discovery",
+ "stm32f3xx-hal",
+ "systick-monotonic",
 ]
 
 [[package]]
@@ -542,9 +595,9 @@ dependencies = [
 
 [[package]]
 name = "semver"
-version = "1.0.13"
+version = "1.0.16"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "93f6841e709003d68bb2deee8c343572bf446003ec20a583e76f7b15cebf3711"
+checksum = "58bc9567378fc7690d6b2addae4e60ac2eeea07becb2c64b9f218b53865cba2a"
 
 [[package]]
 name = "semver-parser"
@@ -553,43 +606,10 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "388a1df253eca08550bef6c72392cfe7c30914bf41df5269b68cbd6ff8f570a3"
 
 [[package]]
-name = "serde"
-version = "1.0.144"
+name = "slice-group-by"
+version = "0.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0f747710de3dcd43b88c9168773254e809d8ddbdf9653b84e2554ab219f17860"
-dependencies = [
- "serde_derive",
-]
-
-[[package]]
-name = "serde_derive"
-version = "1.0.144"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "94ed3a816fb1d101812f83e789f888322c34e291f894f19590dc310963e87a00"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn",
-]
-
-[[package]]
-name = "smallvec"
-version = "1.9.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2fd0db749597d91ff862fd1d55ea87f7855a744a8425a64695b6fca237d1dad1"
-
-[[package]]
-name = "spacepackets"
-version = "0.1.0"
-dependencies = [
- "chrono",
- "crc",
- "delegate 0.7.0",
- "num-traits",
- "postcard",
- "serde",
- "zerocopy",
-]
+checksum = "03b634d87b960ab1a38c4fe143b508576f075e7c978bfad18217645ebfdfa2ec"
 
 [[package]]
 name = "spin"
@@ -607,10 +627,78 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a8f112729512f8e442d81f95a8a7ddf2b7c6b8a1a6f509a95864142b30cab2d3"
 
 [[package]]
-name = "syn"
-version = "1.0.99"
+name = "stm32-usbd"
+version = "0.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "58dbef6ec655055e20b86b15a8cc6d439cca19b667537ac6a1369572d151ab13"
+checksum = "c6c94998f166d66b210a164648a0b7866428d8f1e0740bf8a4c5edd89d4750c1"
+dependencies = [
+ "cortex-m",
+ "usb-device",
+ "vcell",
+]
+
+[[package]]
+name = "stm32f3"
+version = "0.14.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "265cda62ac13307414de4aca58dbbbd8038ddba85cffbb335823aa216f2e3200"
+dependencies = [
+ "bare-metal 1.0.0",
+ "cortex-m",
+ "cortex-m-rt",
+ "vcell",
+]
+
+[[package]]
+name = "stm32f3-discovery"
+version = "0.8.0-pre.0"
+dependencies = [
+ "accelerometer",
+ "cortex-m",
+ "cortex-m-rt",
+ "lsm303dlhc",
+ "stm32f3xx-hal",
+ "switch-hal",
+]
+
+[[package]]
+name = "stm32f3xx-hal"
+version = "0.9.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4e422c5c044e8f3a068b1e14b83c071449e27c9d4bc0e24f972b552d79f2be03"
+dependencies = [
+ "bare-metal 1.0.0",
+ "bxcan",
+ "cfg-if",
+ "cortex-m",
+ "cortex-m-rt",
+ "embedded-dma",
+ "embedded-hal",
+ "embedded-time",
+ "enumset",
+ "nb 1.0.0",
+ "paste",
+ "rtcc",
+ "slice-group-by",
+ "stm32-usbd",
+ "stm32f3",
+ "void",
+]
+
+[[package]]
+name = "switch-hal"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "90a4adc8cbd1726249b161898e48e0f3f1ce74d34dc784cbbc98fba4ed283fbf"
+dependencies = [
+ "embedded-hal",
+]
+
+[[package]]
+name = "syn"
+version = "1.0.107"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1f4064b5b16e03ae50984a5a8ed5d4f8803e6bc1fd170a3cda91a1be4b18e3f5"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -618,28 +706,33 @@ dependencies = [
 ]
 
 [[package]]
-name = "synstructure"
-version = "0.12.6"
+name = "systick-monotonic"
+version = "1.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f36bdaa60a83aca3921b5259d5400cbf5e90fc51931376a9bd4a0eb79aa7210f"
+checksum = "67fb822d5c615a0ae3a4795ee5b1d06381c7faf488d861c0a4fa8e6a88d5ff84"
 dependencies = [
- "proc-macro2",
- "quote",
- "syn",
- "unicode-xid",
+ "cortex-m",
+ "fugit",
+ "rtic-monotonic",
 ]
 
 [[package]]
-name = "unicode-ident"
-version = "1.0.3"
+name = "typenum"
+version = "1.16.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c4f5b37a154999a8f3f98cc23a628d850e154479cd94decf3414696e12e31aaf"
+checksum = "497961ef93d974e23eb6f433eb5fe1b7930b659f06d12dec6fc44a8f554c0bba"
 
 [[package]]
-name = "unicode-xid"
-version = "0.2.3"
+name = "unicode-ident"
+version = "1.0.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "957e51f3646910546462e67d5f7599b9e4fb8acdd304b087a6494730f9eebf04"
+checksum = "84a22b9f218b40614adcb3f4ff08b703773ad44fa9423e4e0d346d5db86e4ebc"
+
+[[package]]
+name = "usb-device"
+version = "0.2.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1f6cc3adc849b5292b4075fc0d5fdcf2f24866e88e336dd27a8943090a520508"
 
 [[package]]
 name = "vcell"
@@ -667,149 +760,3 @@ checksum = "9ee8f19f9d74293faf70901bc20ad067dc1ad390d2cbf1e3f75f721ffee908b6"
 dependencies = [
  "vcell",
 ]
-
-[[package]]
-name = "wasi"
-version = "0.11.0+wasi-snapshot-preview1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9c8d87e72b64a3b4db28d11ce29237c246188f4f51057d65a7eab63b7987e423"
-
-[[package]]
-name = "wasm-bindgen"
-version = "0.2.82"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fc7652e3f6c4706c8d9cd54832c4a4ccb9b5336e2c3bd154d5cccfbf1c1f5f7d"
-dependencies = [
- "cfg-if",
- "wasm-bindgen-macro",
-]
-
-[[package]]
-name = "wasm-bindgen-backend"
-version = "0.2.82"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "662cd44805586bd52971b9586b1df85cdbbd9112e4ef4d8f41559c334dc6ac3f"
-dependencies = [
- "bumpalo",
- "log",
- "once_cell",
- "proc-macro2",
- "quote",
- "syn",
- "wasm-bindgen-shared",
-]
-
-[[package]]
-name = "wasm-bindgen-macro"
-version = "0.2.82"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b260f13d3012071dfb1512849c033b1925038373aea48ced3012c09df952c602"
-dependencies = [
- "quote",
- "wasm-bindgen-macro-support",
-]
-
-[[package]]
-name = "wasm-bindgen-macro-support"
-version = "0.2.82"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5be8e654bdd9b79216c2929ab90721aa82faf65c48cdf08bdc4e7f51357b80da"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn",
- "wasm-bindgen-backend",
- "wasm-bindgen-shared",
-]
-
-[[package]]
-name = "wasm-bindgen-shared"
-version = "0.2.82"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6598dd0bd3c7d51095ff6531a5b23e02acdc81804e30d8f07afb77b7215a140a"
-
-[[package]]
-name = "winapi"
-version = "0.3.9"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419"
-dependencies = [
- "winapi-i686-pc-windows-gnu",
- "winapi-x86_64-pc-windows-gnu",
-]
-
-[[package]]
-name = "winapi-i686-pc-windows-gnu"
-version = "0.4.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6"
-
-[[package]]
-name = "winapi-x86_64-pc-windows-gnu"
-version = "0.4.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
-
-[[package]]
-name = "windows-sys"
-version = "0.36.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ea04155a16a59f9eab786fe12a4a450e75cdb175f9e0d80da1e17db09f55b8d2"
-dependencies = [
- "windows_aarch64_msvc",
- "windows_i686_gnu",
- "windows_i686_msvc",
- "windows_x86_64_gnu",
- "windows_x86_64_msvc",
-]
-
-[[package]]
-name = "windows_aarch64_msvc"
-version = "0.36.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9bb8c3fd39ade2d67e9874ac4f3db21f0d710bee00fe7cab16949ec184eeaa47"
-
-[[package]]
-name = "windows_i686_gnu"
-version = "0.36.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "180e6ccf01daf4c426b846dfc66db1fc518f074baa793aa7d9b9aaeffad6a3b6"
-
-[[package]]
-name = "windows_i686_msvc"
-version = "0.36.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e2e7917148b2812d1eeafaeb22a97e4813dfa60a3f8f78ebe204bcc88f12f024"
-
-[[package]]
-name = "windows_x86_64_gnu"
-version = "0.36.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4dcd171b8776c41b97521e5da127a2d86ad280114807d0b2ab1e462bc764d9e1"
-
-[[package]]
-name = "windows_x86_64_msvc"
-version = "0.36.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c811ca4a8c853ef420abd8592ba53ddbbac90410fab6903b3e79972a631f7680"
-
-[[package]]
-name = "zerocopy"
-version = "0.6.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "332f188cc1bcf1fe1064b8c58d150f497e697f49774aa846f2dc949d9a25f236"
-dependencies = [
- "byteorder",
- "zerocopy-derive",
-]
-
-[[package]]
-name = "zerocopy-derive"
-version = "0.3.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a0fbc82b82efe24da867ee52e015e58178684bd9dd64c34e66bdf21da2582a9f"
-dependencies = [
- "proc-macro2",
- "syn",
- "synstructure",
-]
diff --git a/satrs-example-stm32f3-disco/Cargo.toml b/satrs-example-stm32f3-disco/Cargo.toml
new file mode 100644
index 0000000..dec4cab
--- /dev/null
+++ b/satrs-example-stm32f3-disco/Cargo.toml
@@ -0,0 +1,59 @@
+[package]
+name = "satrs-example-stm32f3-disco"
+version = "0.1.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+cortex-m = "0.7"
+cortex-m-rt = "0.7"
+embedded-hal = "0.2.6"
+cortex-m-rtic = "1.0"
+enumset = "1.0"
+heapless = "0.7"
+systick-monotonic = "1.0"
+
+[dependencies.cobs]
+git = "https://github.com/robamu/cobs.rs.git"
+branch = "all_features"
+default-features = false
+
+[dependencies.panic-itm]
+version = "0.4"
+
+[dependencies.itm_logger]
+git = "https://github.com/robamu/itm_logger.rs.git"
+branch = "all_features"
+version = "0.1.3-alpha.0"
+
+[dependencies.stm32f3xx-hal]
+git = "https://github.com/robamu/stm32f3xx-hal"
+version = "0.10.0-alpha.0"
+features = ["stm32f303xc", "rt", "enumset"]
+branch = "all_features"
+# Can be used in workspace to develop and update HAL
+# path = "../stm32f3xx-hal"
+
+[dependencies.stm32f3-discovery]
+git = "https://github.com/robamu/stm32f3-discovery"
+version = "0.8.0-alpha.0"
+branch = "all_features"
+# Can be used in workspace to develop and update BSP
+# path = "../stm32f3-discovery"
+
+[dependencies.satrs-core]
+git = "https://egit.irs.uni-stuttgart.de/rust/satrs-core.git"
+version = "0.1.0-alpha.0"
+default-features = false
+
+# this lets you use `cargo fix`!
+# [[bin]]
+# name = "stm32f3-blinky"
+# test = false
+# bench = false
+
+[profile.release]
+codegen-units = 1 # better optimizations
+debug = true # symbols are nice and they don't increase the size on Flash
+lto = true # better optimizations
diff --git a/satrs-example-stm32f3-disco/LICENSE-APACHE b/satrs-example-stm32f3-disco/LICENSE-APACHE
new file mode 100644
index 0000000..16fe87b
--- /dev/null
+++ b/satrs-example-stm32f3-disco/LICENSE-APACHE
@@ -0,0 +1,201 @@
+                              Apache License
+                        Version 2.0, January 2004
+                     http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+   "License" shall mean the terms and conditions for use, reproduction,
+   and distribution as defined by Sections 1 through 9 of this document.
+
+   "Licensor" shall mean the copyright owner or entity authorized by
+   the copyright owner that is granting the License.
+
+   "Legal Entity" shall mean the union of the acting entity and all
+   other entities that control, are controlled by, or are under common
+   control with that entity. For the purposes of this definition,
+   "control" means (i) the power, direct or indirect, to cause the
+   direction or management of such entity, whether by contract or
+   otherwise, or (ii) ownership of fifty percent (50%) or more of the
+   outstanding shares, or (iii) beneficial ownership of such entity.
+
+   "You" (or "Your") shall mean an individual or Legal Entity
+   exercising permissions granted by this License.
+
+   "Source" form shall mean the preferred form for making modifications,
+   including but not limited to software source code, documentation
+   source, and configuration files.
+
+   "Object" form shall mean any form resulting from mechanical
+   transformation or translation of a Source form, including but
+   not limited to compiled object code, generated documentation,
+   and conversions to other media types.
+
+   "Work" shall mean the work of authorship, whether in Source or
+   Object form, made available under the License, as indicated by a
+   copyright notice that is included in or attached to the work
+   (an example is provided in the Appendix below).
+
+   "Derivative Works" shall mean any work, whether in Source or Object
+   form, that is based on (or derived from) the Work and for which the
+   editorial revisions, annotations, elaborations, or other modifications
+   represent, as a whole, an original work of authorship. For the purposes
+   of this License, Derivative Works shall not include works that remain
+   separable from, or merely link (or bind by name) to the interfaces of,
+   the Work and Derivative Works thereof.
+
+   "Contribution" shall mean any work of authorship, including
+   the original version of the Work and any modifications or additions
+   to that Work or Derivative Works thereof, that is intentionally
+   submitted to Licensor for inclusion in the Work by the copyright owner
+   or by an individual or Legal Entity authorized to submit on behalf of
+   the copyright owner. For the purposes of this definition, "submitted"
+   means any form of electronic, verbal, or written communication sent
+   to the Licensor or its representatives, including but not limited to
+   communication on electronic mailing lists, source code control systems,
+   and issue tracking systems that are managed by, or on behalf of, the
+   Licensor for the purpose of discussing and improving the Work, but
+   excluding communication that is conspicuously marked or otherwise
+   designated in writing by the copyright owner as "Not a Contribution."
+
+   "Contributor" shall mean Licensor and any individual or Legal Entity
+   on behalf of whom a Contribution has been received by Licensor and
+   subsequently incorporated within the Work.
+
+2. Grant of Copyright License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   copyright license to reproduce, prepare Derivative Works of,
+   publicly display, publicly perform, sublicense, and distribute the
+   Work and such Derivative Works in Source or Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   (except as stated in this section) patent license to make, have made,
+   use, offer to sell, sell, import, and otherwise transfer the Work,
+   where such license applies only to those patent claims licensable
+   by such Contributor that are necessarily infringed by their
+   Contribution(s) alone or by combination of their Contribution(s)
+   with the Work to which such Contribution(s) was submitted. If You
+   institute patent litigation against any entity (including a
+   cross-claim or counterclaim in a lawsuit) alleging that the Work
+   or a Contribution incorporated within the Work constitutes direct
+   or contributory patent infringement, then any patent licenses
+   granted to You under this License for that Work shall terminate
+   as of the date such litigation is filed.
+
+4. Redistribution. You may reproduce and distribute copies of the
+   Work or Derivative Works thereof in any medium, with or without
+   modifications, and in Source or Object form, provided that You
+   meet the following conditions:
+
+   (a) You must give any other recipients of the Work or
+       Derivative Works a copy of this License; and
+
+   (b) You must cause any modified files to carry prominent notices
+       stating that You changed the files; and
+
+   (c) You must retain, in the Source form of any Derivative Works
+       that You distribute, all copyright, patent, trademark, and
+       attribution notices from the Source form of the Work,
+       excluding those notices that do not pertain to any part of
+       the Derivative Works; and
+
+   (d) If the Work includes a "NOTICE" text file as part of its
+       distribution, then any Derivative Works that You distribute must
+       include a readable copy of the attribution notices contained
+       within such NOTICE file, excluding those notices that do not
+       pertain to any part of the Derivative Works, in at least one
+       of the following places: within a NOTICE text file distributed
+       as part of the Derivative Works; within the Source form or
+       documentation, if provided along with the Derivative Works; or,
+       within a display generated by the Derivative Works, if and
+       wherever such third-party notices normally appear. The contents
+       of the NOTICE file are for informational purposes only and
+       do not modify the License. You may add Your own attribution
+       notices within Derivative Works that You distribute, alongside
+       or as an addendum to the NOTICE text from the Work, provided
+       that such additional attribution notices cannot be construed
+       as modifying the License.
+
+   You may add Your own copyright statement to Your modifications and
+   may provide additional or different license terms and conditions
+   for use, reproduction, or distribution of Your modifications, or
+   for any such Derivative Works as a whole, provided Your use,
+   reproduction, and distribution of the Work otherwise complies with
+   the conditions stated in this License.
+
+5. Submission of Contributions. Unless You explicitly state otherwise,
+   any Contribution intentionally submitted for inclusion in the Work
+   by You to the Licensor shall be under the terms and conditions of
+   this License, without any additional terms or conditions.
+   Notwithstanding the above, nothing herein shall supersede or modify
+   the terms of any separate license agreement you may have executed
+   with Licensor regarding such Contributions.
+
+6. Trademarks. This License does not grant permission to use the trade
+   names, trademarks, service marks, or product names of the Licensor,
+   except as required for reasonable and customary use in describing the
+   origin of the Work and reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty. Unless required by applicable law or
+   agreed to in writing, Licensor provides the Work (and each
+   Contributor provides its Contributions) on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+   implied, including, without limitation, any warranties or conditions
+   of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+   PARTICULAR PURPOSE. You are solely responsible for determining the
+   appropriateness of using or redistributing the Work and assume any
+   risks associated with Your exercise of permissions under this License.
+
+8. Limitation of Liability. In no event and under no legal theory,
+   whether in tort (including negligence), contract, or otherwise,
+   unless required by applicable law (such as deliberate and grossly
+   negligent acts) or agreed to in writing, shall any Contributor be
+   liable to You for damages, including any direct, indirect, special,
+   incidental, or consequential damages of any character arising as a
+   result of this License or out of the use or inability to use the
+   Work (including but not limited to damages for loss of goodwill,
+   work stoppage, computer failure or malfunction, or any and all
+   other commercial damages or losses), even if such Contributor
+   has been advised of the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability. While redistributing
+   the Work or Derivative Works thereof, You may choose to offer,
+   and charge a fee for, acceptance of support, warranty, indemnity,
+   or other liability obligations and/or rights consistent with this
+   License. However, in accepting such obligations, You may act only
+   on Your own behalf and on Your sole responsibility, not on behalf
+   of any other Contributor, and only if You agree to indemnify,
+   defend, and hold each Contributor harmless for any liability
+   incurred by, or claims asserted against, such Contributor by reason
+   of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
+
+APPENDIX: How to apply the Apache License to your work.
+
+   To apply the Apache License to your work, attach the following
+   boilerplate notice, with the fields enclosed by brackets "[]"
+   replaced with your own identifying information. (Don't include
+   the brackets!)  The text should be enclosed in the appropriate
+   comment syntax for the file format. We also recommend that a
+   file or class name and description of purpose be included on the
+   same "printed page" as the copyright notice for easier
+   identification within third-party archives.
+
+Copyright [yyyy] [name of copyright owner]
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+	http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
diff --git a/satrs-example-stm32f3-disco/NOTICE b/satrs-example-stm32f3-disco/NOTICE
new file mode 100644
index 0000000..717a583
--- /dev/null
+++ b/satrs-example-stm32f3-disco/NOTICE
@@ -0,0 +1 @@
+This software contains code developed at the University of Stuttgart's Institute of Space Systems.
diff --git a/satrs-example-stm32f3-disco/README.md b/satrs-example-stm32f3-disco/README.md
new file mode 100644
index 0000000..9e98f05
--- /dev/null
+++ b/satrs-example-stm32f3-disco/README.md
@@ -0,0 +1,75 @@
+sat-rs example for the STM32F3-Discovery board
+=======
+
+This example application shows how the [sat-rs framework](https://egit.irs.uni-stuttgart.de/rust/satrs-launchpad)
+can be used on an embedded target. It also shows how a relatively simple OBSW could be built when no
+standard runtime is available. It uses [RTIC](https://rtic.rs/1/book/en/) as the concurrency
+framework.
+
+The STM32F3-Discovery device was picked because it is a cheap Cortex-M4 based device which is also
+used by the [Rust Embedded Book](https://docs.rust-embedded.org/book/intro/hardware.html) and the
+[Rust Discovery](https://docs.rust-embedded.org/discovery/f3discovery/) book as an introduction
+to embedded Rust.
+
+## Preparing Rust and the repository
+
+Building an application requires the `thumbv7em-none-eabihf` cross-compiler toolchain.
+If you have not installed it yet, you can do so with
+
+```sh
+rustup target add thumbv7em-none-eabihf
+```
+
+A default `.cargo` config file is provided for this project, but needs to be copied to have
+the correct name. This is so that the config file can be updated or edited for custom needs
+without being tracked by git.
+
+```sh
+cp def_config.toml config.toml
+```
+
+The configuration file will also set the target so it does not always have to be specified with
+the `--target` argument.
+
+## Building
+
+After that, assuming that you have a `.cargo/config.toml` setting the correct build target,
+you can simply build the application with
+
+```sh
+cargo build
+```
+
+## Flashing and Debugging from the command line
+
+TODO
+
+## Debugging with VS Code
+
+The STM32F3-Discovery comes with an on-board ST-Link so all that is required to flash and debug
+the board is a Mini-USB cable. The code in this repository was debugged using `openocd`
+and the VS Code [`Cortex-Debug` plugin](https://marketplace.visualstudio.com/items?itemName=marus25.cortex-debug).
+
+Some sample configuration files for VS Code were provided as well. You can simply use `Run` and `Debug`
+to automatically rebuild and flash your application.
+
+The `tasks.json` and `launch.json` files are generic and you can use them immediately by opening
+the folder in VS code or adding it to a workspace.
+
+If you would like to use a custom GDB application, you can specify the gdb binary in the following
+configuration variables in your `settings.json`:
+
+- `"cortex-debug.gdbPath"`
+- `"cortex-debug.gdbPath.linux"`
+- `"cortex-debug.gdbPath.windows"`
+- `"cortex-debug.gdbPath.osx"`
+
+## Commanding with Python
+
+When the SW is running on the Discovery board, you can command the MCU via a serial interface,
+using COBS encoded CCSDS packets.
+ 
+TODO:
+  - How and where to connect serial interface on the MCU
+  - How to set up Python venv (or at least strongly recommend it) and install deps
+  - How to copy `def_tmtc_conf.json` to `tmtc_conf.json` and adapt it for custom serial port
diff --git a/satrs-example-stm32f3-disco/build.rs b/satrs-example-stm32f3-disco/build.rs
new file mode 100644
index 0000000..98f603e
--- /dev/null
+++ b/satrs-example-stm32f3-disco/build.rs
@@ -0,0 +1,18 @@
+use std::env;
+use std::fs::File;
+use std::io::Write;
+use std::path::PathBuf;
+
+fn main() {
+    // Put the linker script somewhere the linker can find it
+    let out = &PathBuf::from(env::var_os("OUT_DIR").unwrap());
+    File::create(out.join("memory.x"))
+        .unwrap()
+        .write_all(include_bytes!("memory.x"))
+        .unwrap();
+    println!("cargo:rustc-link-search={}", out.display());
+
+    // Only re-run the build script when memory.x is changed,
+    // instead of when any part of the source code changes.
+    println!("cargo:rerun-if-changed=memory.x");
+}
diff --git a/satrs-example-stm32f3-disco/jlink.gdb b/satrs-example-stm32f3-disco/jlink.gdb
new file mode 100644
index 0000000..8eeed7c
--- /dev/null
+++ b/satrs-example-stm32f3-disco/jlink.gdb
@@ -0,0 +1,10 @@
+target extended-remote localhost:2331
+
+monitor reset
+
+# *try* to stop at the user entry point (it might be gone due to inlining)
+break main
+
+load
+
+continue
diff --git a/satrs-example-stm32f3-disco/memory.x b/satrs-example-stm32f3-disco/memory.x
new file mode 100644
index 0000000..a3a5787
--- /dev/null
+++ b/satrs-example-stm32f3-disco/memory.x
@@ -0,0 +1,33 @@
+/* Linker script for the STM32F303VCT6 */
+MEMORY
+{
+  /* NOTE 1 K = 1 KiBi = 1024 bytes */
+  FLASH : ORIGIN = 0x08000000, LENGTH = 256K
+  RAM : ORIGIN = 0x20000000, LENGTH = 40K
+}
+
+/* This is where the call stack will be allocated. */
+/* The stack is of the full descending type. */
+/* You may want to use this variable to locate the call stack and static
+   variables in different memory regions. Below is shown the default value */
+/* _stack_start = ORIGIN(RAM) + LENGTH(RAM); */
+
+/* You can use this symbol to customize the location of the .text section */
+/* If omitted the .text section will be placed right after the .vector_table
+   section */
+/* This is required only on microcontrollers that store some configuration right
+   after the vector table */
+/* _stext = ORIGIN(FLASH) + 0x400; */
+
+/* Example of putting non-initialized variables into custom RAM locations. */
+/* This assumes you have defined a region RAM2 above, and in the Rust
+   sources added the attribute `#[link_section = ".ram2bss"]` to the data
+   you want to place there. */
+/* Note that the section will not be zero-initialized by the runtime! */
+/* SECTIONS {
+     .ram2bss (NOLOAD) : ALIGN(4) {
+       *(.ram2bss);
+       . = ALIGN(4);
+     } > RAM2
+   } INSERT AFTER .bss;
+*/
diff --git a/satrs-example-stm32f3-disco/openocd.cfg b/satrs-example-stm32f3-disco/openocd.cfg
new file mode 100644
index 0000000..466c033
--- /dev/null
+++ b/satrs-example-stm32f3-disco/openocd.cfg
@@ -0,0 +1,12 @@
+# Sample OpenOCD configuration for the STM32F3DISCOVERY development board
+
+# Depending on the hardware revision you got you'll have to pick ONE of these
+# interfaces. At any time only one interface should be commented out.
+
+# Revision C (newer revision)
+source [find interface/stlink.cfg]
+
+# Revision A and B (older revisions)
+# source [find interface/stlink-v2.cfg]
+
+source [find target/stm32f3x.cfg]
diff --git a/satrs-example-stm32f3-disco/openocd.gdb b/satrs-example-stm32f3-disco/openocd.gdb
new file mode 100644
index 0000000..0ba0c09
--- /dev/null
+++ b/satrs-example-stm32f3-disco/openocd.gdb
@@ -0,0 +1,40 @@
+target extended-remote :3333
+
+# print demangled symbols
+set print asm-demangle on
+
+# set backtrace limit to not have infinite backtrace loops
+set backtrace limit 32
+
+# detect unhandled exceptions, hard faults and panics
+break DefaultHandler
+break HardFault
+break rust_begin_unwind
+# # run the next few lines so the panic message is printed immediately
+# # the number needs to be adjusted for your panic handler
+# commands $bpnum
+# next 4
+# end
+
+# *try* to stop at the user entry point (it might be gone due to inlining)
+break main
+
+# monitor arm semihosting enable
+
+# # send captured ITM to the file itm.fifo
+# # (the microcontroller SWO pin must be connected to the programmer SWO pin)
+# # 8000000 must match the core clock frequency
+monitor tpiu config internal itm.txt uart off 8000000
+
+# # OR: make the microcontroller SWO pin output compatible with UART (8N1)
+# # 8000000 must match the core clock frequency
+# # 2000000 is the frequency of the SWO pin
+# monitor tpiu config external uart off 8000000 2000000
+
+# # enable ITM port 0
+monitor itm port 0 on
+
+load
+
+# start the process but immediately halt the processor
+stepi
diff --git a/satrs-example-stm32f3-disco/pyclient/.gitignore b/satrs-example-stm32f3-disco/pyclient/.gitignore
new file mode 100644
index 0000000..a0c9366
--- /dev/null
+++ b/satrs-example-stm32f3-disco/pyclient/.gitignore
@@ -0,0 +1,7 @@
+/venv
+/log
+/.idea/*
+!/.idea/runConfigurations
+
+/seqcnt.txt
+/tmtc_conf.json
diff --git a/satrs-example-stm32f3-disco/pyclient/def_tmtc_conf.json b/satrs-example-stm32f3-disco/pyclient/def_tmtc_conf.json
new file mode 100644
index 0000000..5665681
--- /dev/null
+++ b/satrs-example-stm32f3-disco/pyclient/def_tmtc_conf.json
@@ -0,0 +1,4 @@
+{
+    "com_if": "serial_cobs",
+    "serial_baudrate": 115200
+}
\ No newline at end of file
diff --git a/satrs-example-stm32f3-disco/pyclient/main.py b/satrs-example-stm32f3-disco/pyclient/main.py
new file mode 100644
index 0000000..a5fa9cd
--- /dev/null
+++ b/satrs-example-stm32f3-disco/pyclient/main.py
@@ -0,0 +1,307 @@
+#!/usr/bin/env python3
+"""Example client for the sat-rs example application"""
+import enum
+import struct
+import sys
+import time
+from typing import Optional, cast
+
+import tmtccmd
+from spacepackets.ecss import PusTelemetry, PusTelecommand, PusVerificator
+from spacepackets.ecss.pus_17_test import Service17Tm
+from spacepackets.ecss.pus_1_verification import UnpackParams, Service1Tm
+
+from tmtccmd import CcsdsTmtcBackend, TcHandlerBase, ProcedureParamsWrapper
+from tmtccmd.core.base import BackendRequest
+from tmtccmd.pus import VerificationWrapper
+from tmtccmd.tm import CcsdsTmHandler, SpecificApidHandlerBase
+from tmtccmd.com_if import ComInterface
+from tmtccmd.config import (
+    default_json_path,
+    SetupParams,
+    TmTcCfgHookBase,
+    TmtcDefinitionWrapper,
+    CoreServiceList,
+    OpCodeEntry,
+    params_to_procedure_conversion,
+)
+from tmtccmd.config.com_if import SerialCfgWrapper
+from tmtccmd.config import PreArgsParsingWrapper, SetupWrapper
+from tmtccmd.logging import get_console_logger
+from tmtccmd.logging.pus import (
+    RegularTmtcLogWrapper,
+    RawTmtcTimedLogWrapper,
+    TimedLogWhen,
+)
+from tmtccmd.tc import (
+    TcQueueEntryType,
+    ProcedureWrapper,
+    TcProcedureType,
+    FeedWrapper,
+    SendCbParams,
+    DefaultPusQueueHelper,
+)
+from tmtccmd.tm.pus_5_event import Service5Tm
+from tmtccmd.util import FileSeqCountProvider, PusFileSeqCountProvider
+from tmtccmd.util.obj_id import ObjectIdDictT
+
+from tmtccmd.util.tmtc_printer import FsfwTmTcPrinter
+
+LOGGER = get_console_logger()
+
+EXAMPLE_PUS_APID = 0x02
+
+
+class SatRsConfigHook(TmTcCfgHookBase):
+    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]:
+        from tmtccmd.config.com_if import (
+            create_com_interface_default,
+            create_com_interface_cfg_default,
+        )
+
+        cfg = create_com_interface_cfg_default(
+            com_if_key=com_if_key,
+            json_cfg_path=self.cfg_path,
+            space_packet_ids=None,
+        )
+        if cfg is None:
+            raise ValueError(
+                f"No valid configuration could be retrieved for the COM IF with key {com_if_key}"
+            )
+        if cfg.com_if_key == "serial_cobs":
+            cfg = cast(SerialCfgWrapper, cfg)
+            cfg.serial_cfg.serial_timeout = 0.5
+        return create_com_interface_default(cfg)
+
+    def get_tmtc_definitions(self) -> TmtcDefinitionWrapper:
+        from tmtccmd.config.globals import get_default_tmtc_defs
+
+        defs = get_default_tmtc_defs()
+        srv_5 = OpCodeEntry()
+        srv_5.add("0", "Event Test")
+        defs.add_service(
+            name=CoreServiceList.SERVICE_5.value,
+            info="PUS Service 5 Event",
+            op_code_entry=srv_5,
+        )
+        srv_17 = OpCodeEntry()
+        srv_17.add("0", "Ping Test")
+        defs.add_service(
+            name=CoreServiceList.SERVICE_17_ALT,
+            info="PUS Service 17 Test",
+            op_code_entry=srv_17,
+        )
+        srv_3 = OpCodeEntry()
+        defs.add_service(
+            name=CoreServiceList.SERVICE_3,
+            info="PUS Service 3 Housekeeping",
+            op_code_entry=srv_3,
+        )
+        return defs
+
+    def perform_mode_operation(self, tmtc_backend: CcsdsTmtcBackend, mode: int):
+        LOGGER.info("Mode operation hook was called")
+        pass
+
+    def get_object_ids(self) -> ObjectIdDictT:
+        from tmtccmd.config.objects import get_core_object_ids
+
+        return get_core_object_ids()
+
+
+class PusHandler(SpecificApidHandlerBase):
+    def __init__(
+        self,
+        verif_wrapper: VerificationWrapper,
+        printer: FsfwTmTcPrinter,
+        raw_logger: RawTmtcTimedLogWrapper,
+    ):
+        super().__init__(EXAMPLE_PUS_APID, None)
+        self.printer = printer
+        self.raw_logger = raw_logger
+        self.verif_wrapper = verif_wrapper
+
+    def handle_tm(self, packet: bytes, _user_args: any):
+        try:
+            tm_packet = PusTelemetry.unpack(packet)
+        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
+        if service == 1:
+            tm_packet = Service1Tm.unpack(data=packet, params=UnpackParams(1, 2))
+            res = self.verif_wrapper.add_tm(tm_packet)
+            if res is None:
+                LOGGER.info(
+                    f"Received Verification TM[{tm_packet.service}, {tm_packet.subservice}] "
+                    f"with Request ID {tm_packet.tc_req_id.as_u32():#08x}"
+                )
+                LOGGER.warning(
+                    f"No matching telecommand found for {tm_packet.tc_req_id}"
+                )
+            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:
+            LOGGER.info("No handling for HK packets implemented")
+            LOGGER.info(f"Raw packet: 0x[{packet.hex(sep=',')}]")
+            pus_tm = PusTelemetry.unpack(packet)
+            if pus_tm.subservice == 25:
+                if len(pus_tm.source_data) < 8:
+                    raise ValueError("No addressable ID in HK packet")
+                json_str = pus_tm.source_data[8:]
+            dedicated_handler = True
+        if service == 5:
+            tm_packet = Service5Tm.unpack(packet)
+        if service == 17:
+            tm_packet = Service17Tm.unpack(packet)
+            dedicated_handler = True
+            if tm_packet.subservice == 2:
+                self.printer.file_logger.info("Received Ping Reply TM[17,2]")
+                LOGGER.info("Received Ping Reply TM[17,2]")
+            else:
+                self.printer.file_logger.info(
+                    f"Received Test Packet with unknown subservice {tm_packet.subservice}"
+                )
+                LOGGER.info(
+                    f"Received Test Packet with unknown subservice {tm_packet.subservice}"
+                )
+        if tm_packet is None:
+            LOGGER.info(
+                f"The service {service} is not implemented in Telemetry Factory"
+            )
+            tm_packet = PusTelemetry.unpack(packet)
+        self.raw_logger.log_tm(tm_packet)
+        if not dedicated_handler and tm_packet is not None:
+            self.printer.handle_long_tm_print(packet_if=tm_packet, info_if=tm_packet)
+
+
+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))
+    return byte_string
+
+
+class TcHandler(TcHandlerBase):
+    def __init__(
+        self,
+        seq_count_provider: FileSeqCountProvider,
+        verif_wrapper: VerificationWrapper,
+    ):
+        super(TcHandler, self).__init__()
+        self.seq_count_provider = seq_count_provider
+        self.verif_wrapper = verif_wrapper
+        self.queue_helper = DefaultPusQueueHelper(
+            queue_wrapper=None,
+            seq_cnt_provider=seq_count_provider,
+        )
+
+    def send_cb(self, send_params: SendCbParams):
+        entry_helper = send_params.entry
+        if entry_helper.is_tc:
+            if entry_helper.entry_type == TcQueueEntryType.PUS_TC:
+                pus_tc_wrapper = entry_helper.to_pus_tc_entry()
+                pus_tc_wrapper.pus_tc.seq_count = (
+                    self.seq_count_provider.get_and_increment()
+                )
+                self.verif_wrapper.add_tc(pus_tc_wrapper.pus_tc)
+                raw_tc = pus_tc_wrapper.pus_tc.pack()
+                LOGGER.info(f"Sending {pus_tc_wrapper.pus_tc}")
+                send_params.com_if.send(raw_tc)
+        elif entry_helper.entry_type == TcQueueEntryType.LOG:
+            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 feed_cb(self, helper: 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
+            if (
+                service == CoreServiceList.SERVICE_17
+                or service == CoreServiceList.SERVICE_17_ALT
+            ):
+                q.add_log_cmd("Sending PUS ping telecommand")
+                return q.add_pus_tc(PusTelecommand(service=17, subservice=1))
+
+
+def main():
+    tmtccmd.init_printout(False)
+    hook_obj = SatRsConfigHook(json_cfg_path=default_json_path())
+    parser_wrapper = PreArgsParsingWrapper()
+    parser_wrapper.create_default_parent_parser()
+    parser_wrapper.create_default_parser()
+    parser_wrapper.add_def_proc_args()
+    post_args_wrapper = parser_wrapper.parse(hook_obj)
+    params = SetupParams()
+    proc_wrapper = ProcedureParamsWrapper()
+    if post_args_wrapper.use_gui:
+        post_args_wrapper.set_params_without_prompts(params, proc_wrapper)
+    else:
+        post_args_wrapper.set_params_with_prompts(params, proc_wrapper)
+    params.apid = EXAMPLE_PUS_APID
+    setup_args = SetupWrapper(
+        hook_obj=hook_obj, setup_params=params, proc_param_wrapper=proc_wrapper
+    )
+    # Create console logger helper and file loggers
+    tmtc_logger = RegularTmtcLogWrapper()
+    printer = FsfwTmTcPrinter(tmtc_logger.logger)
+    raw_logger = RawTmtcTimedLogWrapper(when=TimedLogWhen.PER_HOUR, interval=1)
+    verificator = PusVerificator()
+    verification_wrapper = VerificationWrapper(verificator, LOGGER, printer.file_logger)
+    # Create primary TM handler and add it to the CCSDS Packet Handler
+    tm_handler = PusHandler(verification_wrapper, printer, raw_logger)
+    ccsds_handler = CcsdsTmHandler(generic_handler=None)
+    ccsds_handler.add_apid_handler(tm_handler)
+
+    # Create TC handler
+    seq_count_provider = PusFileSeqCountProvider()
+    tc_handler = TcHandler(seq_count_provider, verification_wrapper)
+    tmtccmd.setup(setup_args=setup_args)
+    init_proc = params_to_procedure_conversion(setup_args.proc_param_wrapper)
+    tmtc_backend = tmtccmd.create_default_tmtc_backend(
+        setup_wrapper=setup_args,
+        tm_handler=ccsds_handler,
+        tc_handler=tc_handler,
+        init_procedure=init_proc,
+    )
+    tmtccmd.start(tmtc_backend=tmtc_backend, hook_obj=hook_obj)
+    try:
+        while True:
+            state = tmtc_backend.periodic_op(None)
+            if state.request == BackendRequest.TERMINATION_NO_ERROR:
+                sys.exit(0)
+            elif state.request == BackendRequest.DELAY_IDLE:
+                LOGGER.info("TMTC Client in IDLE mode")
+                time.sleep(3.0)
+            elif state.request == BackendRequest.DELAY_LISTENER:
+                time.sleep(0.8)
+            elif state.request == BackendRequest.DELAY_CUSTOM:
+                if state.next_delay.total_seconds() <= 0.4:
+                    time.sleep(state.next_delay.total_seconds())
+                else:
+                    time.sleep(0.4)
+            elif state.request == BackendRequest.CALL_NEXT:
+                pass
+    except KeyboardInterrupt:
+        sys.exit(0)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/satrs-example-stm32f3-disco/pyclient/requirements.txt b/satrs-example-stm32f3-disco/pyclient/requirements.txt
new file mode 100644
index 0000000..d9a7ac1
--- /dev/null
+++ b/satrs-example-stm32f3-disco/pyclient/requirements.txt
@@ -0,0 +1,2 @@
+tmtccmd == 4.0.0a0
+# -e git+https://github.com/robamu-org/tmtccmd.git@main#egg=tmtccmd
diff --git a/satrs-example-stm32f3-disco/src/blinky.rs b/satrs-example-stm32f3-disco/src/blinky.rs
new file mode 100644
index 0000000..eefdbfe
--- /dev/null
+++ b/satrs-example-stm32f3-disco/src/blinky.rs
@@ -0,0 +1,78 @@
+#![no_std]
+#![no_main]
+
+extern crate panic_itm;
+
+use cortex_m_rt::entry;
+
+use stm32f3_discovery::stm32f3xx_hal::delay::Delay;
+use stm32f3_discovery::stm32f3xx_hal::{pac, prelude::*};
+use stm32f3_discovery::leds::Leds;
+use stm32f3_discovery::switch_hal::{OutputSwitch, ToggleableOutputSwitch};
+
+#[entry]
+fn main()-> ! {
+    let dp = pac::Peripherals::take().unwrap();
+    let mut rcc = dp.RCC.constrain();
+    let cp = cortex_m::Peripherals::take().unwrap();
+    let mut flash = dp.FLASH.constrain();
+    let clocks = rcc.cfgr.freeze(&mut flash.acr);
+    let mut delay = Delay::new(cp.SYST, clocks);
+
+    let mut gpioe = dp.GPIOE.split(&mut rcc.ahb);
+    let mut leds = Leds::new(
+        gpioe.pe8,
+        gpioe.pe9,
+        gpioe.pe10,
+        gpioe.pe11,
+        gpioe.pe12,
+        gpioe.pe13,
+        gpioe.pe14,
+        gpioe.pe15,
+        &mut gpioe.moder,
+        &mut gpioe.otyper
+    );
+    let delay_ms = 200u16;
+    loop {
+        leds.ld3.toggle().ok();
+        delay.delay_ms(delay_ms);
+        leds.ld3.toggle().ok();
+        delay.delay_ms(delay_ms);
+
+        //explicit on/off
+        leds.ld4.on().ok();
+        delay.delay_ms(delay_ms);
+        leds.ld4.off().ok();
+        delay.delay_ms(delay_ms);
+
+        leds.ld5.on().ok();
+        delay.delay_ms(delay_ms);
+        leds.ld5.off().ok();
+        delay.delay_ms(delay_ms);
+
+        leds.ld6.on().ok();
+        delay.delay_ms(delay_ms);
+        leds.ld6.off().ok();
+        delay.delay_ms(delay_ms);
+        
+        leds.ld7.on().ok();
+        delay.delay_ms(delay_ms);
+        leds.ld7.off().ok();
+        delay.delay_ms(delay_ms);
+        
+        leds.ld8.on().ok();
+        delay.delay_ms(delay_ms);
+        leds.ld8.off().ok();
+        delay.delay_ms(delay_ms);
+        
+        leds.ld9.on().ok();
+        delay.delay_ms(delay_ms);
+        leds.ld9.off().ok();
+        delay.delay_ms(delay_ms);
+
+        leds.ld10.on().ok();
+        delay.delay_ms(delay_ms);
+        leds.ld10.off().ok();
+        delay.delay_ms(delay_ms);
+    }
+}
diff --git a/satrs-example-stm32f3-disco/src/main.rs b/satrs-example-stm32f3-disco/src/main.rs
new file mode 100644
index 0000000..8762cbf
--- /dev/null
+++ b/satrs-example-stm32f3-disco/src/main.rs
@@ -0,0 +1,604 @@
+#![no_std]
+#![no_main]
+extern crate panic_itm;
+
+use rtic::app;
+
+use heapless::{
+    mpmc::Q16,
+    pool,
+    pool::singleton::{Box, Pool},
+};
+#[allow(unused_imports)]
+use itm_logger::{debug, info, logger_init, warn};
+use satrs_core::spacepackets::{ecss::PusPacket, tm::PusTm};
+use satrs_core::{
+    pus::{EcssTmErrorWithSend, EcssTmSenderCore},
+    seq_count::SequenceCountProviderCore,
+};
+use stm32f3xx_hal::dma::dma1;
+use stm32f3xx_hal::gpio::{PushPull, AF7, PA2, PA3};
+use stm32f3xx_hal::pac::USART2;
+use stm32f3xx_hal::serial::{Rx, RxEvent, Serial, SerialDmaRx, SerialDmaTx, Tx, TxEvent};
+use systick_monotonic::{fugit::Duration, Systick};
+
+const UART_BAUD: u32 = 115200;
+const BLINK_FREQ_MS: u64 = 1000;
+const TX_HANDLER_FREQ_MS: u64 = 20;
+const MIN_DELAY_BETWEEN_TX_PACKETS_MS: u16 = 5;
+const MAX_TC_LEN: usize = 200;
+const MAX_TM_LEN: usize = 200;
+pub const PUS_APID: u16 = 0x02;
+
+type TxType = Tx<USART2, PA2<AF7<PushPull>>>;
+type RxType = Rx<USART2, PA3<AF7<PushPull>>>;
+type MsDuration = Duration<u64, 1, 1000>;
+type TxDmaTransferType = SerialDmaTx<&'static [u8], dma1::C7, TxType>;
+type RxDmaTransferType = SerialDmaRx<&'static mut [u8], dma1::C6, RxType>;
+
+// This is the predictable maximum overhead of the COBS encoding scheme.
+// It is simply the maximum packet lenght dividied by 254 rounded up.
+const COBS_TC_OVERHEAD: usize = (MAX_TC_LEN + 254 - 1) / 254;
+const COBS_TM_OVERHEAD: usize = (MAX_TM_LEN + 254 - 1) / 254;
+
+const TC_BUF_LEN: usize = MAX_TC_LEN + COBS_TC_OVERHEAD;
+const TM_BUF_LEN: usize = MAX_TC_LEN + COBS_TM_OVERHEAD;
+
+// This is a static buffer which should ONLY (!) be used as the TX DMA
+// transfer buffer.
+static mut DMA_TX_BUF: [u8; TM_BUF_LEN] = [0; TM_BUF_LEN];
+// This is a static buffer which should ONLY (!) be used as the RX DMA
+// transfer buffer.
+static mut DMA_RX_BUF: [u8; TC_BUF_LEN] = [0; TC_BUF_LEN];
+
+static TX_REQUESTS: Q16<(Box<poolmod::TM>, usize)> = Q16::new();
+
+const TC_POOL_SLOTS: usize = 12;
+const TM_POOL_SLOTS: usize = 12;
+use core::sync::atomic::{AtomicU16, Ordering};
+
+pub struct SeqCountProviderAtomicRef {
+    atomic: AtomicU16,
+    ordering: Ordering,
+}
+
+impl SeqCountProviderAtomicRef {
+    pub const fn new(ordering: Ordering) -> Self {
+        Self {
+            atomic: AtomicU16::new(0),
+            ordering,
+        }
+    }
+}
+
+impl SequenceCountProviderCore<u16> for SeqCountProviderAtomicRef {
+    fn get(&self) -> u16 {
+        self.atomic.load(self.ordering)
+    }
+
+    fn increment(&self) {
+        self.atomic.fetch_add(1, self.ordering);
+    }
+
+    fn get_and_increment(&self) -> u16 {
+        self.atomic.fetch_add(1, self.ordering)
+    }
+}
+
+static SEQ_COUNT_PROVIDER: SeqCountProviderAtomicRef =
+    SeqCountProviderAtomicRef::new(Ordering::Relaxed);
+
+// Otherwise, warnings because of heapless pool macro.
+#[allow(non_camel_case_types)]
+mod poolmod {
+    use super::*;
+    // Must hold full TC length including COBS overhead.
+    pool!(TC: [u8; TC_BUF_LEN]);
+    // Only encoded at the end, so no need to account for COBS overhead.
+    pool!(TM: [u8; MAX_TM_LEN]);
+}
+
+pub struct TxIdle {
+    tx: TxType,
+    dma_channel: dma1::C7,
+}
+
+#[derive(Debug)]
+pub enum TmStoreError {
+    StoreFull,
+    StoreSlotsTooSmall,
+}
+
+impl From<TmStoreError> for EcssTmErrorWithSend<TmStoreError> {
+    fn from(value: TmStoreError) -> Self {
+        Self::SendError(value)
+    }
+}
+
+pub struct TmSender {
+    mem_block: Option<Box<poolmod::TM>>,
+    ctx: &'static str,
+}
+
+impl TmSender {
+    pub fn new(mem_block: Box<poolmod::TM>, ctx: &'static str) -> Self {
+        Self {
+            mem_block: Some(mem_block),
+            ctx,
+        }
+    }
+}
+
+impl EcssTmSenderCore for TmSender {
+    type Error = TmStoreError;
+
+    fn send_tm(
+        &mut self,
+        tm: PusTm,
+    ) -> Result<(), satrs_core::pus::EcssTmErrorWithSend<Self::Error>> {
+        let mem_block = self.mem_block.take();
+        if mem_block.is_none() {
+            panic!("send_tm should only be called once");
+        }
+        let mut mem_block = mem_block.unwrap();
+        if tm.len_packed() > MAX_TM_LEN {
+            return Err(EcssTmErrorWithSend::SendError(
+                TmStoreError::StoreSlotsTooSmall,
+            ));
+        }
+        tm.write_to_bytes(mem_block.as_mut_slice())
+            .map_err(|e| EcssTmErrorWithSend::EcssTmError(e.into()))?;
+        info!(target: self.ctx, "Sending TM[{},{}] with size {}", tm.service(), tm.subservice(), tm.len_packed());
+        TX_REQUESTS
+            .enqueue((mem_block, tm.len_packed()))
+            .map_err(|_| TmStoreError::StoreFull)?;
+        Ok(())
+    }
+}
+
+pub enum UartTxState {
+    // Wrapped in an option because we need an owned type later.
+    Idle(Option<TxIdle>),
+    // Same as above
+    Transmitting(Option<TxDmaTransferType>),
+}
+
+#[app(device = stm32f3xx_hal::pac, peripherals = true, dispatchers = [TIM20_BRK, TIM20_UP, TIM20_TRG_COM])]
+mod app {
+    use super::*;
+    use core::slice::Iter;
+    use cortex_m::iprintln;
+    use satrs_core::pus::verification::FailParams;
+    use satrs_core::pus::verification::VerificationReporterCore;
+    use satrs_core::spacepackets::{
+        ecss::EcssEnumU16,
+        tc::PusTc,
+        time::cds::P_FIELD_BASE,
+        tm::{PusTm, PusTmSecondaryHeader},
+        CcsdsPacket, SpHeader,
+    };
+    #[allow(unused_imports)]
+    use stm32f3_discovery::leds::Direction;
+    use stm32f3_discovery::leds::Leds;
+    use stm32f3xx_hal::prelude::*;
+    use stm32f3xx_hal::Toggle;
+
+    use stm32f3_discovery::switch_hal::OutputSwitch;
+    #[allow(dead_code)]
+    type SerialType = Serial<USART2, (PA2<AF7<PushPull>>, PA3<AF7<PushPull>>)>;
+
+    #[shared]
+    struct Shared {
+        tx_transfer: UartTxState,
+        rx_transfer: Option<RxDmaTransferType>,
+    }
+
+    #[local]
+    struct Local {
+        leds: Leds,
+        last_dir: Direction,
+        verif_reporter: VerificationReporterCore,
+        curr_dir: Iter<'static, Direction>,
+    }
+
+    #[monotonic(binds = SysTick, default = true)]
+    type MonoTimer = Systick<1000>;
+
+    #[init(local = [
+        tc_pool_mem: [u8; TC_BUF_LEN * TC_POOL_SLOTS] = [0; TC_BUF_LEN * TC_POOL_SLOTS],
+        tm_pool_mem: [u8; MAX_TM_LEN * TM_POOL_SLOTS] = [0; MAX_TM_LEN * TM_POOL_SLOTS]
+    ])]
+    fn init(mut cx: init::Context) -> (Shared, Local, init::Monotonics) {
+        let mut rcc = cx.device.RCC.constrain();
+
+        let mono = Systick::new(cx.core.SYST, 8_000_000);
+        logger_init();
+        let mut flash = cx.device.FLASH.constrain();
+        let clocks = rcc
+            .cfgr
+            .use_hse(8.MHz())
+            .sysclk(8.MHz())
+            .pclk1(8.MHz())
+            .freeze(&mut flash.acr);
+        // setup ITM output
+        iprintln!(
+            &mut cx.core.ITM.stim[0],
+            "Starting sat-rs demo application for the STM32F3-Discovery"
+        );
+        let mut gpioe = cx.device.GPIOE.split(&mut rcc.ahb);
+        // Assign memory to the pools.
+        poolmod::TC::grow(cx.local.tc_pool_mem);
+        poolmod::TM::grow(cx.local.tm_pool_mem);
+
+        let verif_reporter = VerificationReporterCore::new(PUS_APID).unwrap();
+
+        let leds = Leds::new(
+            gpioe.pe8,
+            gpioe.pe9,
+            gpioe.pe10,
+            gpioe.pe11,
+            gpioe.pe12,
+            gpioe.pe13,
+            gpioe.pe14,
+            gpioe.pe15,
+            &mut gpioe.moder,
+            &mut gpioe.otyper,
+        );
+        let mut gpioa = cx.device.GPIOA.split(&mut rcc.ahb);
+        // USART2 pins
+        let mut pins = (
+            // TX pin: PA2
+            gpioa
+                .pa2
+                .into_af_push_pull(&mut gpioa.moder, &mut gpioa.otyper, &mut gpioa.afrl),
+            // RX pin: PA3
+            gpioa
+                .pa3
+                .into_af_push_pull(&mut gpioa.moder, &mut gpioa.otyper, &mut gpioa.afrl),
+        );
+        pins.1.internal_pull_up(&mut gpioa.pupdr, true);
+        let mut usart2 = Serial::new(
+            cx.device.USART2,
+            pins,
+            UART_BAUD.Bd(),
+            clocks,
+            &mut rcc.apb1,
+        );
+        usart2.configure_rx_interrupt(RxEvent::Idle, Toggle::On);
+        // This interrupt is enabled to re-schedule new transfers in the interrupt handler immediately.
+        usart2.configure_tx_interrupt(TxEvent::TransmissionComplete, Toggle::On);
+
+        let dma1 = cx.device.DMA1.split(&mut rcc.ahb);
+        let (tx_serial, mut rx_serial) = usart2.split();
+
+        // This interrupt is immediately triggered, clear it. It will only be reset
+        // by the hardware when data is received on RX (RXNE event)
+        rx_serial.clear_event(RxEvent::Idle);
+        let rx_transfer = rx_serial.read_exact(unsafe { DMA_RX_BUF.as_mut_slice() }, dma1.ch6);
+        info!(target: "init", "Spawning tasks");
+        blink::spawn().unwrap();
+        serial_tx_handler::spawn().unwrap();
+        (
+            Shared {
+                tx_transfer: UartTxState::Idle(Some(TxIdle {
+                    tx: tx_serial,
+                    dma_channel: dma1.ch7,
+                })),
+                rx_transfer: Some(rx_transfer),
+            },
+            Local {
+                leds,
+                last_dir: Direction::North,
+                curr_dir: Direction::iter(),
+                verif_reporter,
+            },
+            init::Monotonics(mono),
+        )
+    }
+
+    #[task(local = [leds, curr_dir, last_dir])]
+    fn blink(cx: blink::Context) {
+        let toggle_leds = |dir: &Direction| {
+            let leds = cx.local.leds;
+            let last_led = leds.for_direction(*cx.local.last_dir);
+            last_led.off().ok();
+            let led = leds.for_direction(*dir);
+            led.on().ok();
+            *cx.local.last_dir = *dir;
+        };
+
+        match cx.local.curr_dir.next() {
+            Some(dir) => {
+                toggle_leds(dir);
+            }
+            None => {
+                *cx.local.curr_dir = Direction::iter();
+                toggle_leds(cx.local.curr_dir.next().unwrap());
+            }
+        }
+        blink::spawn_after(MsDuration::from_ticks(BLINK_FREQ_MS)).unwrap();
+    }
+
+    #[task(
+        shared = [tx_transfer],
+        local = []
+    )]
+    fn serial_tx_handler(mut cx: serial_tx_handler::Context) {
+        if let Some((buf, len)) = TX_REQUESTS.dequeue() {
+            cx.shared.tx_transfer.lock(|tx_state| match tx_state {
+                UartTxState::Idle(tx) => {
+                    //debug!(target: "serial_tx_handler", "bytes: {:x?}", &buf[0..len]);
+                    // Safety: We only copy the data into the TX DMA buffer in this task.
+                    // If the DMA is active, another branch will be taken.
+                    let mut_tx_dma_buf = unsafe { &mut DMA_TX_BUF };
+                    // 0 sentinel value as start marker
+                    mut_tx_dma_buf[0] = 0;
+                    // Should never panic, we accounted for the overhead.
+                    // Write into transfer buffer directly, no need for intermediate
+                    // encoding buffer.
+                    let encoded_len = cobs::encode(&buf[0..len], &mut mut_tx_dma_buf[1..]);
+                    // 0 end marker
+                    mut_tx_dma_buf[encoded_len + 1] = 0;
+                    //debug!(target: "serial_tx_handler", "Sending {} bytes", encoded_len + 2);
+                    //debug!("sent: {:x?}", &mut_tx_dma_buf[0..encoded_len + 2]);
+                    let tx_idle = tx.take().unwrap();
+                    // Transfer completion and re-scheduling of new TX transfers will be done
+                    // by the IRQ handler.
+                    let transfer = tx_idle
+                        .tx
+                        .write_all(&mut_tx_dma_buf[0..encoded_len + 2], tx_idle.dma_channel);
+                    *tx_state = UartTxState::Transmitting(Some(transfer));
+                    // The memory block is automatically returned to the pool when it is dropped.
+                }
+                UartTxState::Transmitting(_) => {
+                    // This is a SW configuration error. Only the ISR which
+                    // detects transfer completion should be able to spawn a new
+                    // task, and that ISR should set the state to IDLE.
+                    panic!("invalid internal tx state detected")
+                }
+            })
+        } else {
+            cx.shared.tx_transfer.lock(|tx_state| {
+                if let UartTxState::Idle(_) = tx_state {
+                    serial_tx_handler::spawn_after(MsDuration::from_ticks(TX_HANDLER_FREQ_MS))
+                        .unwrap();
+                }
+            });
+        }
+    }
+
+    #[task(
+        local = [
+            stamp_buf: [u8; 7] = [0; 7],
+            decode_buf: [u8; MAX_TC_LEN] = [0; MAX_TC_LEN],
+            src_data_buf: [u8; MAX_TM_LEN] = [0; MAX_TM_LEN],
+            verif_reporter
+        ],
+    )]
+    fn serial_rx_handler(
+        cx: serial_rx_handler::Context,
+        received_packet: Box<poolmod::TC>,
+        rx_len: usize,
+    ) {
+        let tgt: &'static str = "serial_rx_handler";
+        cx.local.stamp_buf[0] = P_FIELD_BASE;
+        info!(target: tgt, "Received packet with {} bytes", rx_len);
+        let decode_buf = cx.local.decode_buf;
+        let packet = received_packet.as_slice();
+        let mut start_idx = None;
+        for (idx, byte) in packet.iter().enumerate() {
+            if *byte != 0 {
+                start_idx = Some(idx);
+                break;
+            }
+        }
+        if start_idx.is_none() {
+            warn!(
+                target: tgt,
+                "decoding error, can only process cobs encoded frames, data is all 0"
+            );
+            return;
+        }
+        let start_idx = start_idx.unwrap();
+        match cobs::decode(&received_packet.as_slice()[start_idx..], decode_buf) {
+            Ok(len) => {
+                info!(target: tgt, "Decoded packet length: {}", len);
+                let pus_tc = PusTc::from_bytes(decode_buf);
+                let verif_reporter = cx.local.verif_reporter;
+                match pus_tc {
+                    Ok((tc, tc_len)) => handle_tc(
+                        tc,
+                        tc_len,
+                        verif_reporter,
+                        cx.local.src_data_buf,
+                        cx.local.stamp_buf,
+                        tgt,
+                    ),
+                    Err(e) => {
+                        warn!(target: tgt, "Error unpacking PUS TC: {}", e);
+                    }
+                }
+            }
+            Err(_) => {
+                warn!(
+                    target: tgt,
+                    "decoding error, can only process cobs encoded frames"
+                )
+            }
+        }
+    }
+
+    fn handle_tc(
+        tc: PusTc,
+        tc_len: usize,
+        verif_reporter: &mut VerificationReporterCore,
+        src_data_buf: &mut [u8; MAX_TM_LEN],
+        stamp_buf: &[u8; 7],
+        tgt: &'static str,
+    ) {
+        info!(
+            target: tgt,
+            "Found PUS TC [{},{}] with length {}",
+            tc.service(),
+            tc.subservice(),
+            tc_len
+        );
+
+        let token = verif_reporter.add_tc(&tc);
+        if tc.apid() != PUS_APID {
+            warn!(target: tgt, "Received tc with unknown APID {}", tc.apid());
+            let sendable = verif_reporter
+                .acceptance_failure(
+                    src_data_buf,
+                    token,
+                    &SEQ_COUNT_PROVIDER,
+                    FailParams::new(stamp_buf, &EcssEnumU16::new(0), None),
+                )
+                .unwrap();
+            let mem_block = poolmod::TM::alloc().unwrap().init([0u8; MAX_TM_LEN]);
+            let mut sender = TmSender::new(mem_block, tgt);
+            if let Err(e) =
+                verif_reporter.send_acceptance_failure(sendable, &SEQ_COUNT_PROVIDER, &mut sender)
+            {
+                warn!(target: tgt, "Sending acceptance failure failed: {:?}", e.0);
+            };
+            return;
+        }
+        let sendable = verif_reporter
+            .acceptance_success(src_data_buf, token, &SEQ_COUNT_PROVIDER, stamp_buf)
+            .unwrap();
+
+        let mem_block = poolmod::TM::alloc().unwrap().init([0u8; MAX_TM_LEN]);
+        let mut sender = TmSender::new(mem_block, tgt);
+        let accepted_token = match verif_reporter.send_acceptance_success(
+            sendable,
+            &SEQ_COUNT_PROVIDER,
+            &mut sender,
+        ) {
+            Ok(token) => token,
+            Err(e) => {
+                warn!(target: "serial_rx_handler", "Sending acceptance success failed: {:?}", e.0);
+                return;
+            }
+        };
+
+        if tc.service() == 17 {
+            if tc.subservice() == 1 {
+                let sendable = verif_reporter
+                    .start_success(src_data_buf, accepted_token, &SEQ_COUNT_PROVIDER, stamp_buf)
+                    .unwrap();
+                let mem_block = poolmod::TM::alloc().unwrap().init([0u8; MAX_TM_LEN]);
+                let mut sender = TmSender::new(mem_block, tgt);
+                let started_token = match verif_reporter.send_start_success(
+                    sendable,
+                    &SEQ_COUNT_PROVIDER,
+                    &mut sender,
+                ) {
+                    Ok(token) => token,
+                    Err(e) => {
+                        warn!(target: tgt, "Sending acceptance success failed: {:?}", e.0);
+                        return;
+                    }
+                };
+                info!(
+                    target: tgt,
+                    "Received PUS ping telecommand, sending ping reply TM[17,2]"
+                );
+                let mut sp_header =
+                    SpHeader::tc_unseg(PUS_APID, SEQ_COUNT_PROVIDER.get(), 0).unwrap();
+                let sec_header = PusTmSecondaryHeader::new_simple(17, 2, stamp_buf);
+                let ping_reply = PusTm::new(&mut sp_header, sec_header, None, true);
+                let mut mem_block = poolmod::TM::alloc().unwrap().init([0u8; MAX_TM_LEN]);
+                let reply_len = ping_reply.write_to_bytes(mem_block.as_mut_slice()).unwrap();
+                if TX_REQUESTS.enqueue((mem_block, reply_len)).is_err() {
+                    warn!(target: tgt, "TC queue full");
+                    return;
+                }
+                SEQ_COUNT_PROVIDER.increment();
+                let sendable = verif_reporter
+                    .completion_success(src_data_buf, started_token, &SEQ_COUNT_PROVIDER, stamp_buf)
+                    .unwrap();
+                let mem_block = poolmod::TM::alloc().unwrap().init([0u8; MAX_TM_LEN]);
+                let mut sender = TmSender::new(mem_block, tgt);
+                if let Err(e) = verif_reporter.send_step_or_completion_success(
+                    sendable,
+                    &SEQ_COUNT_PROVIDER,
+                    &mut sender,
+                ) {
+                    warn!(target: tgt, "Sending completion success failed: {:?}", e.0);
+                }
+            } else {
+                // TODO: Invalid subservice
+            }
+        }
+    }
+
+    #[task(binds = DMA1_CH6, shared = [rx_transfer])]
+    fn rx_dma_isr(mut cx: rx_dma_isr::Context) {
+        cx.shared.rx_transfer.lock(|rx_transfer| {
+            let rx_ref = rx_transfer.as_ref().unwrap();
+            if rx_ref.is_complete() {
+                let uart_rx_owned = rx_transfer.take().unwrap();
+                let (buf, c, rx) = uart_rx_owned.stop();
+                // The received data is transferred to another task now to avoid any processing overhead
+                // during the interrupt. There are multiple ways to do this, we use a memory pool here
+                // to do this.
+                let mut mem_block = poolmod::TC::alloc()
+                    .expect("allocating memory block for rx failed")
+                    .init([0u8; TC_BUF_LEN]);
+                // Copy data into memory pool.
+                mem_block.copy_from_slice(buf);
+                *rx_transfer = Some(rx.read_exact(buf, c));
+                // Only send owning pointer to pool memory and the received packet length.
+                serial_rx_handler::spawn(mem_block, TC_BUF_LEN)
+                    .expect("spawning rx handler task failed");
+                // If this happens, there is a high chance that the maximum packet length was
+                // exceeded. Circular mode is not used here, so data might be missed.
+                warn!(
+                    "rx transfer with maximum length {}, might miss data",
+                    TC_BUF_LEN
+                );
+            }
+        });
+    }
+
+    #[task(binds = USART2_EXTI26, shared = [rx_transfer, tx_transfer])]
+    fn serial_isr(mut cx: serial_isr::Context) {
+        cx.shared.tx_transfer.lock(|tx_state| match tx_state {
+            UartTxState::Idle(_) => (),
+            UartTxState::Transmitting(transfer) => {
+                let transfer_ref = transfer.as_ref().unwrap();
+                if transfer_ref.is_complete() {
+                    let transfer = transfer.take().unwrap();
+                    let (_, dma_channel, tx) = transfer.stop();
+                    *tx_state = UartTxState::Idle(Some(TxIdle { tx, dma_channel }));
+                    serial_tx_handler::spawn_after(MsDuration::from_ticks(
+                        MIN_DELAY_BETWEEN_TX_PACKETS_MS.into(),
+                    ))
+                    .unwrap();
+                }
+            }
+        });
+        cx.shared.rx_transfer.lock(|rx_transfer| {
+            let rx_transfer_ref = rx_transfer.as_ref().unwrap();
+            // Received a partial packet.
+            if rx_transfer_ref.is_event_triggered(RxEvent::Idle) {
+                let rx_transfer_owned = rx_transfer.take().unwrap();
+                let (buf, ch, mut rx, rx_len) = rx_transfer_owned.stop_and_return_received_bytes();
+                // The received data is transferred to another task now to avoid any processing overhead
+                // during the interrupt. There are multiple ways to do this, we use a memory pool here
+                // to do this.
+                let mut mem_block = poolmod::TC::alloc()
+                    .expect("allocating memory block for rx failed")
+                    .init([0u8; TC_BUF_LEN]);
+                // Copy data into memory pool.
+                mem_block[0..rx_len as usize].copy_from_slice(&buf[0..rx_len as usize]);
+                rx.clear_event(RxEvent::Idle);
+                // Only send owning pointer to pool memory and the received packet length.
+                serial_rx_handler::spawn(mem_block, rx_len as usize)
+                    .expect("spawning rx handler task failed");
+                *rx_transfer = Some(rx.read_exact(buf, ch));
+            }
+        });
+    }
+}
diff --git a/satrs-example/CHANGELOG.md b/satrs-example/CHANGELOG.md
new file mode 100644
index 0000000..68e54a2
--- /dev/null
+++ b/satrs-example/CHANGELOG.md
@@ -0,0 +1,9 @@
+Change Log
+=======
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](http://keepachangelog.com/)
+and this project adheres to [Semantic Versioning](http://semver.org/).
+
+# [unreleased]
diff --git a/satrs-example/Cargo.toml b/satrs-example/Cargo.toml
new file mode 100644
index 0000000..34d8491
--- /dev/null
+++ b/satrs-example/Cargo.toml
@@ -0,0 +1,23 @@
+[package]
+name = "satrs-example"
+version = "0.1.0"
+edition = "2021"
+authors = ["Robin Mueller <muellerr@irs.uni-stuttgart.de>"]
+default-run = "satrs-example"
+
+[dependencies]
+fern = "0.6"
+chrono = "0.4"
+log = "0.4"
+crossbeam-channel = "0.5"
+delegate = "0.10"
+zerocopy = "0.6"
+csv = "1"
+num_enum = "0.6"
+thiserror = "1"
+
+[dependencies.satrs-core]
+path = "../satrs-core"
+
+[dependencies.satrs-mib]
+path = "../satrs-mib"
diff --git a/satrs-example/LICENSE-APACHE b/satrs-example/LICENSE-APACHE
new file mode 100644
index 0000000..16fe87b
--- /dev/null
+++ b/satrs-example/LICENSE-APACHE
@@ -0,0 +1,201 @@
+                              Apache License
+                        Version 2.0, January 2004
+                     http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+   "License" shall mean the terms and conditions for use, reproduction,
+   and distribution as defined by Sections 1 through 9 of this document.
+
+   "Licensor" shall mean the copyright owner or entity authorized by
+   the copyright owner that is granting the License.
+
+   "Legal Entity" shall mean the union of the acting entity and all
+   other entities that control, are controlled by, or are under common
+   control with that entity. For the purposes of this definition,
+   "control" means (i) the power, direct or indirect, to cause the
+   direction or management of such entity, whether by contract or
+   otherwise, or (ii) ownership of fifty percent (50%) or more of the
+   outstanding shares, or (iii) beneficial ownership of such entity.
+
+   "You" (or "Your") shall mean an individual or Legal Entity
+   exercising permissions granted by this License.
+
+   "Source" form shall mean the preferred form for making modifications,
+   including but not limited to software source code, documentation
+   source, and configuration files.
+
+   "Object" form shall mean any form resulting from mechanical
+   transformation or translation of a Source form, including but
+   not limited to compiled object code, generated documentation,
+   and conversions to other media types.
+
+   "Work" shall mean the work of authorship, whether in Source or
+   Object form, made available under the License, as indicated by a
+   copyright notice that is included in or attached to the work
+   (an example is provided in the Appendix below).
+
+   "Derivative Works" shall mean any work, whether in Source or Object
+   form, that is based on (or derived from) the Work and for which the
+   editorial revisions, annotations, elaborations, or other modifications
+   represent, as a whole, an original work of authorship. For the purposes
+   of this License, Derivative Works shall not include works that remain
+   separable from, or merely link (or bind by name) to the interfaces of,
+   the Work and Derivative Works thereof.
+
+   "Contribution" shall mean any work of authorship, including
+   the original version of the Work and any modifications or additions
+   to that Work or Derivative Works thereof, that is intentionally
+   submitted to Licensor for inclusion in the Work by the copyright owner
+   or by an individual or Legal Entity authorized to submit on behalf of
+   the copyright owner. For the purposes of this definition, "submitted"
+   means any form of electronic, verbal, or written communication sent
+   to the Licensor or its representatives, including but not limited to
+   communication on electronic mailing lists, source code control systems,
+   and issue tracking systems that are managed by, or on behalf of, the
+   Licensor for the purpose of discussing and improving the Work, but
+   excluding communication that is conspicuously marked or otherwise
+   designated in writing by the copyright owner as "Not a Contribution."
+
+   "Contributor" shall mean Licensor and any individual or Legal Entity
+   on behalf of whom a Contribution has been received by Licensor and
+   subsequently incorporated within the Work.
+
+2. Grant of Copyright License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   copyright license to reproduce, prepare Derivative Works of,
+   publicly display, publicly perform, sublicense, and distribute the
+   Work and such Derivative Works in Source or Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   (except as stated in this section) patent license to make, have made,
+   use, offer to sell, sell, import, and otherwise transfer the Work,
+   where such license applies only to those patent claims licensable
+   by such Contributor that are necessarily infringed by their
+   Contribution(s) alone or by combination of their Contribution(s)
+   with the Work to which such Contribution(s) was submitted. If You
+   institute patent litigation against any entity (including a
+   cross-claim or counterclaim in a lawsuit) alleging that the Work
+   or a Contribution incorporated within the Work constitutes direct
+   or contributory patent infringement, then any patent licenses
+   granted to You under this License for that Work shall terminate
+   as of the date such litigation is filed.
+
+4. Redistribution. You may reproduce and distribute copies of the
+   Work or Derivative Works thereof in any medium, with or without
+   modifications, and in Source or Object form, provided that You
+   meet the following conditions:
+
+   (a) You must give any other recipients of the Work or
+       Derivative Works a copy of this License; and
+
+   (b) You must cause any modified files to carry prominent notices
+       stating that You changed the files; and
+
+   (c) You must retain, in the Source form of any Derivative Works
+       that You distribute, all copyright, patent, trademark, and
+       attribution notices from the Source form of the Work,
+       excluding those notices that do not pertain to any part of
+       the Derivative Works; and
+
+   (d) If the Work includes a "NOTICE" text file as part of its
+       distribution, then any Derivative Works that You distribute must
+       include a readable copy of the attribution notices contained
+       within such NOTICE file, excluding those notices that do not
+       pertain to any part of the Derivative Works, in at least one
+       of the following places: within a NOTICE text file distributed
+       as part of the Derivative Works; within the Source form or
+       documentation, if provided along with the Derivative Works; or,
+       within a display generated by the Derivative Works, if and
+       wherever such third-party notices normally appear. The contents
+       of the NOTICE file are for informational purposes only and
+       do not modify the License. You may add Your own attribution
+       notices within Derivative Works that You distribute, alongside
+       or as an addendum to the NOTICE text from the Work, provided
+       that such additional attribution notices cannot be construed
+       as modifying the License.
+
+   You may add Your own copyright statement to Your modifications and
+   may provide additional or different license terms and conditions
+   for use, reproduction, or distribution of Your modifications, or
+   for any such Derivative Works as a whole, provided Your use,
+   reproduction, and distribution of the Work otherwise complies with
+   the conditions stated in this License.
+
+5. Submission of Contributions. Unless You explicitly state otherwise,
+   any Contribution intentionally submitted for inclusion in the Work
+   by You to the Licensor shall be under the terms and conditions of
+   this License, without any additional terms or conditions.
+   Notwithstanding the above, nothing herein shall supersede or modify
+   the terms of any separate license agreement you may have executed
+   with Licensor regarding such Contributions.
+
+6. Trademarks. This License does not grant permission to use the trade
+   names, trademarks, service marks, or product names of the Licensor,
+   except as required for reasonable and customary use in describing the
+   origin of the Work and reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty. Unless required by applicable law or
+   agreed to in writing, Licensor provides the Work (and each
+   Contributor provides its Contributions) on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+   implied, including, without limitation, any warranties or conditions
+   of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+   PARTICULAR PURPOSE. You are solely responsible for determining the
+   appropriateness of using or redistributing the Work and assume any
+   risks associated with Your exercise of permissions under this License.
+
+8. Limitation of Liability. In no event and under no legal theory,
+   whether in tort (including negligence), contract, or otherwise,
+   unless required by applicable law (such as deliberate and grossly
+   negligent acts) or agreed to in writing, shall any Contributor be
+   liable to You for damages, including any direct, indirect, special,
+   incidental, or consequential damages of any character arising as a
+   result of this License or out of the use or inability to use the
+   Work (including but not limited to damages for loss of goodwill,
+   work stoppage, computer failure or malfunction, or any and all
+   other commercial damages or losses), even if such Contributor
+   has been advised of the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability. While redistributing
+   the Work or Derivative Works thereof, You may choose to offer,
+   and charge a fee for, acceptance of support, warranty, indemnity,
+   or other liability obligations and/or rights consistent with this
+   License. However, in accepting such obligations, You may act only
+   on Your own behalf and on Your sole responsibility, not on behalf
+   of any other Contributor, and only if You agree to indemnify,
+   defend, and hold each Contributor harmless for any liability
+   incurred by, or claims asserted against, such Contributor by reason
+   of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
+
+APPENDIX: How to apply the Apache License to your work.
+
+   To apply the Apache License to your work, attach the following
+   boilerplate notice, with the fields enclosed by brackets "[]"
+   replaced with your own identifying information. (Don't include
+   the brackets!)  The text should be enclosed in the appropriate
+   comment syntax for the file format. We also recommend that a
+   file or class name and description of purpose be included on the
+   same "printed page" as the copyright notice for easier
+   identification within third-party archives.
+
+Copyright [yyyy] [name of copyright owner]
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+	http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
diff --git a/satrs-example/NOTICE b/satrs-example/NOTICE
new file mode 100644
index 0000000..717a583
--- /dev/null
+++ b/satrs-example/NOTICE
@@ -0,0 +1 @@
+This software contains code developed at the University of Stuttgart's Institute of Space Systems.
diff --git a/satrs-example/README.md b/satrs-example/README.md
new file mode 100644
index 0000000..021ae67
--- /dev/null
+++ b/satrs-example/README.md
@@ -0,0 +1,53 @@
+sat-rs example
+======
+
+This crate contains an example application which simulates an on-board software.
+It uses various components provided by the sat-rs framework to do this. As such, it shows how
+a more complex real on-board software could be built from these components.
+The application opens a UDP server on port 7301 to receive telecommands.
+
+You can run the application using `cargo run`. The `simpleclient` binary target sends a
+ping telecommand and then verifies the telemetry generated by the example application.
+It can be run like this:
+
+```rs
+cargo run --bin simpleclient
+```
+
+This repository also contains a more complex client using the
+[Python tmtccmd](https://github.com/robamu-org/tmtccmd) module.
+
+# Using the tmtccmd Python client
+
+The python client requires a valid installation of the
+[tmtccmd package](https://github.com/robamu-org/tmtccmd).
+
+It is recommended to use a virtual environment to do this. To set up one in the command line,
+you can use `python3 -m venv venv` on Unix systems or `py -m venv venv` on Windows systems.
+After doing this, you can check the [venv tutorial](https://docs.python.org/3/tutorial/venv.html)
+on how to activate the environment and then use the following command to install the required
+dependency:
+
+```sh
+pip install -r requirements.txt
+```
+
+Alternatively, if you would like to use the GUI functionality provided by `tmtccmd`, you can also
+install it manually with
+
+```sh
+pip install tmtccmd[gui]
+```
+
+After setting up the dependencies, you can simply run the `main.py` script to send commands
+to the OBSW example and to view and handle incoming telemetry. The script and the `tmtccmd`
+framework it uses allow to easily add and expose additional telecommand and telemetry handling
+as Python code. For example, you can use the following command to send a ping like done with
+the `simpleclient`:
+
+```sh
+./main.py -s test -o ping
+```
+
+You can also simply call the script without any arguments to view a list of services (`-s` flag)
+and corresponding op codes (`-o` flag) for each service.
diff --git a/satrs-example/pyclient/.gitignore b/satrs-example/pyclient/.gitignore
new file mode 100644
index 0000000..894ba5d
--- /dev/null
+++ b/satrs-example/pyclient/.gitignore
@@ -0,0 +1,8 @@
+__pycache__
+
+/venv
+/log
+/.idea/*
+!/.idea/runConfigurations
+
+/seqcnt.txt
diff --git a/satrs-example/pyclient/common.py b/satrs-example/pyclient/common.py
new file mode 100644
index 0000000..81df032
--- /dev/null
+++ b/satrs-example/pyclient/common.py
@@ -0,0 +1,50 @@
+from __future__ import annotations
+
+import dataclasses
+import enum
+import struct
+
+EXAMPLE_PUS_APID = 0x02
+
+
+class EventSeverity(enum.IntEnum):
+    INFO = 0
+    LOW = 1
+    MEDIUM = 2
+    HIGH = 3
+
+
+@dataclasses.dataclass
+class EventU32:
+    severity: EventSeverity
+    group_id: int
+    unique_id: int
+
+    @classmethod
+    def unpack(cls, data: bytes) -> EventU32:
+        if len(data) < 4:
+            raise ValueError("passed data too short")
+        event_raw = struct.unpack("!I", data[0:4])[0]
+        return cls(
+            severity=EventSeverity((event_raw >> 30) & 0b11),
+            group_id=(event_raw >> 16) & 0x3FFF,
+            unique_id=event_raw & 0xFFFF,
+        )
+
+
+class RequestTargetId(enum.IntEnum):
+    ACS = 1
+
+
+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))
+    return byte_string
diff --git a/satrs-example/pyclient/main.py b/satrs-example/pyclient/main.py
new file mode 100755
index 0000000..39217e7
--- /dev/null
+++ b/satrs-example/pyclient/main.py
@@ -0,0 +1,280 @@
+#!/usr/bin/env python3
+"""Example client for the sat-rs example application"""
+import logging
+import sys
+import time
+from typing import Optional
+
+import tmtccmd
+from spacepackets.ecss import PusTelemetry, PusVerificator
+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.core.base import BackendRequest
+from tmtccmd.pus import VerificationWrapper
+from tmtccmd.tm import CcsdsTmHandler, SpecificApidHandlerBase
+from tmtccmd.com import ComInterface
+from tmtccmd.config import (
+    default_json_path,
+    SetupParams,
+    HookBase,
+    TmtcDefinitionWrapper,
+    params_to_procedure_conversion,
+)
+from tmtccmd.config import PreArgsParsingWrapper, SetupWrapper
+from tmtccmd.logging import add_colorlog_console_logger
+from tmtccmd.logging.pus import (
+    RegularTmtcLogWrapper,
+    RawTmtcTimedLogWrapper,
+    TimedLogWhen,
+)
+from tmtccmd.tc import (
+    TcQueueEntryType,
+    ProcedureWrapper,
+    TcProcedureType,
+    FeedWrapper,
+    SendCbParams,
+    DefaultPusQueueHelper,
+    QueueWrapper,
+)
+from tmtccmd.util import FileSeqCountProvider, PusFileSeqCountProvider
+from tmtccmd.util.obj_id import ObjectIdDictT
+
+
+import pus_tc
+import tc_definitions
+from common import EXAMPLE_PUS_APID, EventU32
+
+_LOGGER = logging.getLogger()
+
+
+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]:
+        from tmtccmd.config.com import (
+            create_com_interface_default,
+            create_com_interface_cfg_default,
+        )
+
+        cfg = create_com_interface_cfg_default(
+            com_if_key=com_if_key,
+            json_cfg_path=self.cfg_path,
+            space_packet_ids=None,
+        )
+        return create_com_interface_default(cfg)
+
+    def get_tmtc_definitions(self) -> TmtcDefinitionWrapper:
+        return tc_definitions.tc_definitions()
+
+    def perform_mode_operation(self, tmtc_backend: CcsdsTmtcBackend, mode: int):
+        _LOGGER.info("Mode operation hook was called")
+        pass
+
+    def get_object_ids(self) -> ObjectIdDictT:
+        from tmtccmd.config.objects import get_core_object_ids
+
+        return get_core_object_ids()
+
+
+class PusHandler(SpecificApidHandlerBase):
+    def __init__(
+        self,
+        file_logger: logging.Logger,
+        verif_wrapper: VerificationWrapper,
+        raw_logger: RawTmtcTimedLogWrapper,
+    ):
+        super().__init__(EXAMPLE_PUS_APID, None)
+        self.file_logger = file_logger
+        self.raw_logger = raw_logger
+        self.verif_wrapper = verif_wrapper
+
+    def handle_tm(self, packet: bytes, _user_args: any):
+        try:
+            tm_packet = 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
+        if service == 1:
+            tm_packet = Service1Tm.unpack(
+                data=packet, params=UnpackParams(CdsShortTimestamp.empty(), 1, 2)
+            )
+            res = self.verif_wrapper.add_tm(tm_packet)
+            if res is None:
+                _LOGGER.info(
+                    f"Received Verification TM[{tm_packet.service}, {tm_packet.subservice}] "
+                    f"with Request ID {tm_packet.tc_req_id.as_u32():#08x}"
+                )
+                _LOGGER.warning(
+                    f"No matching telecommand found for {tm_packet.tc_req_id}"
+                )
+            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:
+            _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())
+            if pus_tm.subservice == 25:
+                if len(pus_tm.source_data) < 8:
+                    raise ValueError("No addressable ID in HK packet")
+                json_str = pus_tm.source_data[8:]
+            dedicated_handler = True
+        if service == 5:
+            tm_packet = PusTelemetry.unpack(
+                packet, time_reader=CdsShortTimestamp.empty()
+            )
+            src_data = tm_packet.source_data
+            event_u32 = EventU32.unpack(src_data)
+            _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:
+            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]")
+            else:
+                self.file_logger.info(
+                    f"Received Test Packet with unknown subservice {tm_packet.subservice}"
+                )
+                _LOGGER.info(
+                    f"Received Test Packet with unknown subservice {tm_packet.subservice}"
+                )
+        if tm_packet is None:
+            _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)
+
+
+class TcHandler(TcHandlerBase):
+    def __init__(
+        self,
+        seq_count_provider: FileSeqCountProvider,
+        verif_wrapper: VerificationWrapper,
+    ):
+        super(TcHandler, self).__init__()
+        self.seq_count_provider = seq_count_provider
+        self.verif_wrapper = verif_wrapper
+        self.queue_helper = DefaultPusQueueHelper(
+            queue_wrapper=QueueWrapper.empty(),
+            tc_sched_timestamp_len=CdsShortTimestamp.TIMESTAMP_SIZE,
+            seq_cnt_provider=seq_count_provider,
+            pus_verificator=self.verif_wrapper.pus_verificator,
+            default_pus_apid=EXAMPLE_PUS_APID,
+        )
+
+    def send_cb(self, send_params: SendCbParams):
+        entry_helper = send_params.entry
+        if entry_helper.is_tc:
+            if entry_helper.entry_type == TcQueueEntryType.PUS_TC:
+                pus_tc_wrapper = entry_helper.to_pus_tc_entry()
+                raw_tc = pus_tc_wrapper.pus_tc.pack()
+                _LOGGER.info(f"Sending {pus_tc_wrapper.pus_tc}")
+                send_params.com_if.send(raw_tc)
+        elif entry_helper.entry_type == TcQueueEntryType.LOG:
+            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 feed_cb(self, helper: 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)
+
+
+def main():
+    add_colorlog_console_logger(_LOGGER)
+    tmtccmd.init_printout(False)
+    hook_obj = SatRsConfigHook(json_cfg_path=default_json_path())
+    parser_wrapper = PreArgsParsingWrapper()
+    parser_wrapper.create_default_parent_parser()
+    parser_wrapper.create_default_parser()
+    parser_wrapper.add_def_proc_args()
+    params = SetupParams()
+    post_args_wrapper = parser_wrapper.parse(hook_obj, params)
+    proc_wrapper = ProcedureParamsWrapper()
+    if post_args_wrapper.use_gui:
+        post_args_wrapper.set_params_without_prompts(proc_wrapper)
+    else:
+        post_args_wrapper.set_params_with_prompts(proc_wrapper)
+    params.apid = EXAMPLE_PUS_APID
+    setup_args = SetupWrapper(
+        hook_obj=hook_obj, setup_params=params, proc_param_wrapper=proc_wrapper
+    )
+    # Create console logger helper and file loggers
+    tmtc_logger = RegularTmtcLogWrapper()
+    file_logger = tmtc_logger.logger
+    raw_logger = RawTmtcTimedLogWrapper(when=TimedLogWhen.PER_HOUR, interval=1)
+    verificator = PusVerificator()
+    verification_wrapper = VerificationWrapper(verificator, _LOGGER, file_logger)
+    # Create primary TM handler and add it to the CCSDS Packet Handler
+    tm_handler = PusHandler(file_logger, verification_wrapper, raw_logger)
+    ccsds_handler = CcsdsTmHandler(generic_handler=None)
+    ccsds_handler.add_apid_handler(tm_handler)
+
+    # Create TC handler
+    seq_count_provider = PusFileSeqCountProvider()
+    tc_handler = TcHandler(seq_count_provider, verification_wrapper)
+    tmtccmd.setup(setup_args=setup_args)
+    init_proc = params_to_procedure_conversion(setup_args.proc_param_wrapper)
+    tmtc_backend = tmtccmd.create_default_tmtc_backend(
+        setup_wrapper=setup_args,
+        tm_handler=ccsds_handler,
+        tc_handler=tc_handler,
+        init_procedure=init_proc,
+    )
+    tmtccmd.start(tmtc_backend=tmtc_backend, hook_obj=hook_obj)
+    try:
+        while True:
+            state = tmtc_backend.periodic_op(None)
+            if state.request == BackendRequest.TERMINATION_NO_ERROR:
+                sys.exit(0)
+            elif state.request == BackendRequest.DELAY_IDLE:
+                _LOGGER.info("TMTC Client in IDLE mode")
+                time.sleep(3.0)
+            elif state.request == BackendRequest.DELAY_LISTENER:
+                time.sleep(0.8)
+            elif state.request == BackendRequest.DELAY_CUSTOM:
+                if state.next_delay.total_seconds() <= 0.4:
+                    time.sleep(state.next_delay.total_seconds())
+                else:
+                    time.sleep(0.4)
+            elif state.request == BackendRequest.CALL_NEXT:
+                pass
+    except KeyboardInterrupt:
+        sys.exit(0)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/satrs-example/pyclient/pus_tc.py b/satrs-example/pyclient/pus_tc.py
new file mode 100644
index 0000000..4373cb4
--- /dev/null
+++ b/satrs-example/pyclient/pus_tc.py
@@ -0,0 +1,50 @@
+import datetime
+
+from spacepackets.ccsds import CdsShortTimestamp
+from spacepackets.ecss import PusTelecommand
+from tmtccmd.config import CoreServiceList
+from tmtccmd.tc import DefaultPusQueueHelper
+from tmtccmd.tc.pus_11_tc_sched import create_time_tagged_cmd
+from tmtccmd.tc.pus_3_fsfw_hk import create_request_one_hk_command
+
+from common import (
+    EXAMPLE_PUS_APID,
+    HkOpCodes,
+    make_addressable_id,
+    RequestTargetId,
+    AcsHkIds,
+)
+
+
+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":
+            q.add_log_cmd("Sending PUS ping telecommand")
+            return q.add_pus_tc(PusTelecommand(service=17, subservice=1))
+        elif op_code == "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)
+                )
+            )
+        pass
diff --git a/satrs-example/pyclient/pus_tm.py b/satrs-example/pyclient/pus_tm.py
new file mode 100644
index 0000000..e69de29
diff --git a/satrs-example/pyclient/requirements.txt b/satrs-example/pyclient/requirements.txt
new file mode 100644
index 0000000..bcb3cb4
--- /dev/null
+++ b/satrs-example/pyclient/requirements.txt
@@ -0,0 +1,2 @@
+tmtccmd == 5.0.0rc0
+# -e git+https://github.com/robamu-org/tmtccmd@97e5e51101a08b21472b3ddecc2063359f7e307a#egg=tmtccmd
diff --git a/satrs-example/pyclient/tc_definitions.py b/satrs-example/pyclient/tc_definitions.py
new file mode 100644
index 0000000..74fbff8
--- /dev/null
+++ b/satrs-example/pyclient/tc_definitions.py
@@ -0,0 +1,38 @@
+from tmtccmd.config import OpCodeEntry, TmtcDefinitionWrapper, CoreServiceList
+from tmtccmd.config.globals import get_default_tmtc_defs
+
+from common import HkOpCodes
+
+
+def tc_definitions() -> TmtcDefinitionWrapper:
+    defs = get_default_tmtc_defs()
+    srv_5 = OpCodeEntry()
+    srv_5.add("0", "Event Test")
+    defs.add_service(
+        name=CoreServiceList.SERVICE_5.value,
+        info="PUS Service 5 Event",
+        op_code_entry=srv_5,
+    )
+    srv_17 = OpCodeEntry()
+    srv_17.add("ping", "Ping Test")
+    srv_17.add("trigger_event", "Trigger Event")
+    defs.add_service(
+        name=CoreServiceList.SERVICE_17_ALT,
+        info="PUS Service 17 Test",
+        op_code_entry=srv_17,
+    )
+    srv_3 = OpCodeEntry()
+    srv_3.add(HkOpCodes.GENERATE_ONE_SHOT, "Generate AOCS one shot HK")
+    defs.add_service(
+        name=CoreServiceList.SERVICE_3,
+        info="PUS Service 3 Housekeeping",
+        op_code_entry=srv_3,
+    )
+    srv_11 = OpCodeEntry()
+    srv_11.add("0", "Scheduled TC Test")
+    defs.add_service(
+        name=CoreServiceList.SERVICE_11,
+        info="PUS Service 11 TC Scheduling",
+        op_code_entry=srv_11,
+    )
+    return defs
diff --git a/satrs-example/pyclient/tmtc_conf.json b/satrs-example/pyclient/tmtc_conf.json
new file mode 100644
index 0000000..ab02100
--- /dev/null
+++ b/satrs-example/pyclient/tmtc_conf.json
@@ -0,0 +1,6 @@
+{
+    "com_if": "udp",
+    "tcpip_udp_ip_addr": "127.0.0.1",
+    "tcpip_udp_port": 7301,
+    "tcpip_udp_recv_max_size": 1500
+}
\ No newline at end of file
diff --git a/fsrc-example/src/bin/client.rs b/satrs-example/src/bin/simpleclient.rs
similarity index 63%
rename from fsrc-example/src/bin/client.rs
rename to satrs-example/src/bin/simpleclient.rs
index 1f56418..d28eeb8 100644
--- a/fsrc-example/src/bin/client.rs
+++ b/satrs-example/src/bin/simpleclient.rs
@@ -1,27 +1,28 @@
-use fsrc_core::pus::verification::RequestId;
-use fsrc_example::{OBSW_SERVER_ADDR, SERVER_PORT};
-use spacepackets::ecss::PusPacket;
-use spacepackets::tc::PusTc;
-use spacepackets::tm::PusTm;
-use spacepackets::SpHeader;
+use satrs_core::pus::verification::RequestId;
+use satrs_core::{
+    spacepackets::ecss::{PusPacket, SerializablePusPacket},
+    spacepackets::tc::PusTc,
+    spacepackets::tm::PusTm,
+    spacepackets::SpHeader,
+};
+use satrs_example::{OBSW_SERVER_ADDR, SERVER_PORT};
 use std::net::{IpAddr, SocketAddr, UdpSocket};
 use std::time::Duration;
 
 fn main() {
     let mut buf = [0; 32];
     let addr = SocketAddr::new(IpAddr::V4(OBSW_SERVER_ADDR), SERVER_PORT);
-    let mut sph = SpHeader::tc(0x02, 0, 0).unwrap();
+    let mut sph = SpHeader::tc_unseg(0x02, 0, 0).unwrap();
     let pus_tc = PusTc::new_simple(&mut sph, 17, 1, None, true);
     let client = UdpSocket::bind("127.0.0.1:7302").expect("Connecting to UDP server failed");
     let tc_req_id = RequestId::new(&pus_tc);
-    println!(
-        "Packing and sending PUS ping command TC[17,1] with request ID {}",
-        tc_req_id
-    );
-    let size = pus_tc.write_to(&mut buf).expect("Creating PUS TC failed");
+    println!("Packing and sending PUS ping command TC[17,1] with request ID {tc_req_id}");
+    let size = pus_tc
+        .write_to_bytes(&mut buf)
+        .expect("Creating PUS TC failed");
     client
-        .send_to(&buf[0..size], &addr)
-        .expect(&*format!("Sending to {:?} failed", addr));
+        .send_to(&buf[0..size], addr)
+        .unwrap_or_else(|_| panic!("Sending to {addr:?} failed"));
     client
         .set_read_timeout(Some(Duration::from_secs(2)))
         .expect("Setting read timeout failed");
@@ -29,8 +30,7 @@ fn main() {
         let res = client.recv(&mut buf);
         match res {
             Ok(_len) => {
-                let (pus_tm, size) =
-                    PusTm::new_from_raw_slice(&buf, 7).expect("Parsing PUS TM failed");
+                let (pus_tm, size) = PusTm::from_bytes(&buf, 7).expect("Parsing PUS TM failed");
                 if pus_tm.service() == 17 && pus_tm.subservice() == 2 {
                     println!("Received PUS Ping Reply TM[17,2]")
                 } else if pus_tm.service() == 1 {
@@ -43,33 +43,21 @@ fn main() {
                     }
                     let req_id = RequestId::from_bytes(src_data).unwrap();
                     if pus_tm.subservice() == 1 {
-                        println!(
-                            "Received TM[1,1] acceptance success for request ID {}",
-                            req_id
-                        )
+                        println!("Received TM[1,1] acceptance success for request ID {req_id}")
                     } else if pus_tm.subservice() == 2 {
-                        println!(
-                            "Received TM[1,2] acceptance failure for request ID {}",
-                            req_id
-                        )
+                        println!("Received TM[1,2] acceptance failure for request ID {req_id}")
                     } else if pus_tm.subservice() == 3 {
-                        println!("Received TM[1,3] start success for request ID {}", req_id)
+                        println!("Received TM[1,3] start success for request ID {req_id}")
                     } else if pus_tm.subservice() == 4 {
-                        println!("Received TM[1,2] start failure for request ID {}", req_id)
+                        println!("Received TM[1,2] start failure for request ID {req_id}")
                     } else if pus_tm.subservice() == 5 {
-                        println!("Received TM[1,5] step success for request ID {}", req_id)
+                        println!("Received TM[1,5] step success for request ID {req_id}")
                     } else if pus_tm.subservice() == 6 {
-                        println!("Received TM[1,6] step failure for request ID {}", req_id)
+                        println!("Received TM[1,6] step failure for request ID {req_id}")
                     } else if pus_tm.subservice() == 7 {
-                        println!(
-                            "Received TM[1,7] completion success for request ID {}",
-                            req_id
-                        )
+                        println!("Received TM[1,7] completion success for request ID {req_id}")
                     } else if pus_tm.subservice() == 8 {
-                        println!(
-                            "Received TM[1,8] completion failure for request ID {}",
-                            req_id
-                        );
+                        println!("Received TM[1,8] completion failure for request ID {req_id}");
                     }
                 } else {
                     println!(
diff --git a/fsrc-example/src/bin/test.rs b/satrs-example/src/bin/test.rs
similarity index 60%
rename from fsrc-example/src/bin/test.rs
rename to satrs-example/src/bin/test.rs
index a979878..31b59dd 100644
--- a/fsrc-example/src/bin/test.rs
+++ b/satrs-example/src/bin/test.rs
@@ -1,5 +1,9 @@
+#![allow(dead_code)]
+
 use crossbeam_channel::{bounded, Receiver, Sender};
+use std::sync::atomic::{AtomicU16, Ordering};
 use std::thread;
+use zerocopy::{AsBytes, FromBytes, NetworkEndian, Unaligned, U16};
 
 trait FieldDataProvider: Send {
     fn get_data(&self) -> &[u8];
@@ -26,6 +30,18 @@ impl FieldDataProvider for FixedFieldDataWrapper {
 
 type FieldDataTraitObj = Box<dyn FieldDataProvider>;
 
+struct ExampleMgmSet {
+    mgm_vec: [f32; 3],
+    temperature: u16,
+}
+
+#[derive(FromBytes, AsBytes, Unaligned)]
+#[repr(C)]
+struct ExampleMgmSetZc {
+    mgm_vec: [u8; 12],
+    temperatur: U16<NetworkEndian>,
+}
+
 fn main() {
     let (s0, r0): (Sender<FieldDataTraitObj>, Receiver<FieldDataTraitObj>) = bounded(5);
     let data_wrapper = FixedFieldDataWrapper::from_two_u32(2, 3);
@@ -33,9 +49,18 @@ fn main() {
     let jh0 = thread::spawn(move || {
         let data = r0.recv().unwrap();
         let raw = data.get_data();
-        println!("Received data {:?}", raw);
+        println!("Received data {raw:?}");
     });
     let jh1 = thread::spawn(|| {});
     jh0.join().unwrap();
     jh1.join().unwrap();
+    //let mut max_val: u16 = u16::MAX;
+    //max_val += 1;
+    //println!("Max val: {}", max_val);
+    let atomic_u16: AtomicU16 = AtomicU16::new(u16::MAX);
+    atomic_u16.fetch_add(1, Ordering::SeqCst);
+    println!(
+        "atomic after overflow: {}",
+        atomic_u16.load(Ordering::SeqCst)
+    );
 }
diff --git a/fsrc-example/src/bin/obsw/ccsds.rs b/satrs-example/src/ccsds.rs
similarity index 53%
rename from fsrc-example/src/bin/obsw/ccsds.rs
rename to satrs-example/src/ccsds.rs
index b058e4d..1a5bb76 100644
--- a/fsrc-example/src/bin/obsw/ccsds.rs
+++ b/satrs-example/src/ccsds.rs
@@ -1,13 +1,13 @@
-use crate::tmtc::PUS_APID;
-use fsrc_core::tmtc::{CcsdsPacketHandler, PusDistributor, ReceivesCcsdsTc};
-use spacepackets::{CcsdsPacket, SpHeader};
+use crate::tmtc::{MpscStoreAndSendError, PusTcSource, PUS_APID};
+use satrs_core::spacepackets::{CcsdsPacket, SpHeader};
+use satrs_core::tmtc::{CcsdsPacketHandler, ReceivesCcsdsTc};
 
 pub struct CcsdsReceiver {
-    pub pus_handler: PusDistributor<()>,
+    pub tc_source: PusTcSource,
 }
 
 impl CcsdsPacketHandler for CcsdsReceiver {
-    type Error = ();
+    type Error = MpscStoreAndSendError;
 
     fn valid_apids(&self) -> &'static [u16] {
         &[PUS_APID]
@@ -19,19 +19,17 @@ impl CcsdsPacketHandler for CcsdsReceiver {
         tc_raw: &[u8],
     ) -> Result<(), Self::Error> {
         if sp_header.apid() == PUS_APID {
-            self.pus_handler
-                .pass_ccsds(sp_header, tc_raw)
-                .expect("Handling PUS packet failed");
+            return self.tc_source.pass_ccsds(sp_header, tc_raw);
         }
         Ok(())
     }
 
     fn handle_unknown_apid(
         &mut self,
-        _sp_header: &SpHeader,
+        sp_header: &SpHeader,
         _tc_raw: &[u8],
     ) -> Result<(), Self::Error> {
-        println!("Unknown APID detected");
+        println!("Unknown APID 0x{:x?} detected", sp_header.apid());
         Ok(())
     }
 }
diff --git a/satrs-example/src/hk.rs b/satrs-example/src/hk.rs
new file mode 100644
index 0000000..2e4727a
--- /dev/null
+++ b/satrs-example/src/hk.rs
@@ -0,0 +1,4 @@
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+pub enum AcsHkIds {
+    TestMgmSet = 1,
+}
diff --git a/satrs-example/src/lib.rs b/satrs-example/src/lib.rs
new file mode 100644
index 0000000..31fb63d
--- /dev/null
+++ b/satrs-example/src/lib.rs
@@ -0,0 +1,96 @@
+use num_enum::{IntoPrimitive, TryFromPrimitive};
+use satrs_core::events::{EventU32TypedSev, SeverityInfo};
+use satrs_core::objects::ObjectId;
+use std::net::Ipv4Addr;
+
+use satrs_mib::res_code::{ResultU16, ResultU16Info};
+use satrs_mib::resultcode;
+
+#[derive(Copy, Clone, PartialEq, Eq, Debug, TryFromPrimitive, IntoPrimitive)]
+#[repr(u8)]
+pub enum CustomPusServiceId {
+    Mode = 200,
+    Health = 201,
+}
+
+#[derive(Copy, Clone, Eq, PartialEq, Debug)]
+pub enum RequestTargetId {
+    AcsSubsystem = 1,
+}
+
+pub const ACS_OBJECT_ID: ObjectId = ObjectId {
+    id: RequestTargetId::AcsSubsystem as u32,
+    name: "ACS_SUBSYSTEM",
+};
+
+#[derive(Debug)]
+pub enum GroupId {
+    Tmtc = 0,
+    Hk = 1,
+}
+
+pub const OBSW_SERVER_ADDR: Ipv4Addr = Ipv4Addr::UNSPECIFIED;
+pub const SERVER_PORT: u16 = 7301;
+
+pub const TEST_EVENT: EventU32TypedSev<SeverityInfo> =
+    EventU32TypedSev::<SeverityInfo>::const_new(0, 0);
+
+pub mod tmtc_err {
+    use super::*;
+
+    #[resultcode]
+    pub const INVALID_PUS_SERVICE: ResultU16 = ResultU16::const_new(GroupId::Tmtc as u8, 0);
+    #[resultcode]
+    pub const INVALID_PUS_SUBSERVICE: ResultU16 = ResultU16::const_new(GroupId::Tmtc as u8, 1);
+    #[resultcode]
+    pub const PUS_SERVICE_NOT_IMPLEMENTED: ResultU16 = ResultU16::const_new(GroupId::Tmtc as u8, 2);
+    #[resultcode]
+    pub const UNKNOWN_TARGET_ID: ResultU16 = ResultU16::const_new(GroupId::Tmtc as u8, 3);
+
+    #[resultcode(
+        info = "Not enough data inside the TC application data field. Optionally includes: \
+          8 bytes of failure data containing 2 failure parameters, \
+          P1 (u32 big endian): Expected data length, P2: Found data length"
+    )]
+    pub const NOT_ENOUGH_APP_DATA: ResultU16 = ResultU16::const_new(GroupId::Tmtc as u8, 2);
+
+    pub const TMTC_RESULTS: &[ResultU16Info] = &[
+        INVALID_PUS_SERVICE_EXT,
+        INVALID_PUS_SUBSERVICE_EXT,
+        NOT_ENOUGH_APP_DATA_EXT,
+    ];
+}
+
+pub mod hk_err {
+    use super::*;
+
+    #[resultcode]
+    pub const TARGET_ID_MISSING: ResultU16 = ResultU16::const_new(GroupId::Hk as u8, 0);
+    #[resultcode]
+    pub const UNIQUE_ID_MISSING: ResultU16 = ResultU16::const_new(GroupId::Hk as u8, 1);
+    #[resultcode]
+    pub const UNKNOWN_TARGET_ID: ResultU16 = ResultU16::const_new(GroupId::Hk as u8, 2);
+    #[resultcode]
+    pub const COLLECTION_INTERVAL_MISSING: ResultU16 = ResultU16::const_new(GroupId::Hk as u8, 3);
+}
+
+#[allow(clippy::enum_variant_names)]
+#[derive(Copy, Clone, PartialEq, Eq)]
+pub enum TmSenderId {
+    PusVerification = 0,
+    PusTest = 1,
+    PusEvent = 2,
+    PusHk = 3,
+    PusAction = 4,
+    PusSched = 5,
+    AllEvents = 6,
+}
+
+#[derive(Copy, Clone, PartialEq, Eq)]
+pub enum TcReceiverId {
+    PusTest = 1,
+    PusEvent = 2,
+    PusHk = 3,
+    PusAction = 4,
+    PusSched = 5,
+}
diff --git a/satrs-example/src/logging.rs b/satrs-example/src/logging.rs
new file mode 100644
index 0000000..63788fb
--- /dev/null
+++ b/satrs-example/src/logging.rs
@@ -0,0 +1,16 @@
+pub fn setup_logger() -> Result<(), fern::InitError> {
+    fern::Dispatch::new()
+        .format(|out, message, record| {
+            out.finish(format_args!(
+                "{}[{}][{}] {}",
+                chrono::Local::now().format("[%Y-%m-%d][%H:%M:%S]"),
+                record.target(), //(std::thread::current().name().expect("unnamed_thread"),
+                record.level(),
+                message
+            ))
+        })
+        .level(log::LevelFilter::Debug)
+        .chain(std::io::stdout())
+        .apply()?;
+    Ok(())
+}
diff --git a/satrs-example/src/main.rs b/satrs-example/src/main.rs
new file mode 100644
index 0000000..e6a4241
--- /dev/null
+++ b/satrs-example/src/main.rs
@@ -0,0 +1,498 @@
+mod ccsds;
+mod hk;
+mod logging;
+mod pus;
+mod requests;
+mod tmtc;
+
+use log::{info, warn};
+
+use crate::hk::AcsHkIds;
+use crate::logging::setup_logger;
+use crate::pus::action::{Pus8Wrapper, PusService8ActionHandler};
+use crate::pus::event::Pus5Wrapper;
+use crate::pus::hk::{Pus3Wrapper, PusService3HkHandler};
+use crate::pus::scheduler::Pus11Wrapper;
+use crate::pus::test::Service17CustomWrapper;
+use crate::pus::PusTcMpscRouter;
+use crate::requests::{Request, RequestWithToken};
+use crate::tmtc::{core_tmtc_task, PusTcSource, TcArgs, TcStore, TmArgs, TmFunnel, PUS_APID};
+use satrs_core::event_man::{
+    EventManagerWithMpscQueue, MpscEventReceiver, MpscEventU32SendProvider, SendEventProvider,
+};
+use satrs_core::events::EventU32;
+use satrs_core::hk::HkRequest;
+use satrs_core::pool::{LocalPool, PoolCfg};
+use satrs_core::pus::event_man::{
+    DefaultPusMgmtBackendProvider, EventReporter, EventRequest, EventRequestWithToken,
+    PusEventDispatcher,
+};
+use satrs_core::pus::event_srv::PusService5EventHandler;
+use satrs_core::pus::hk::Subservice as HkSubservice;
+use satrs_core::pus::scheduler::PusScheduler;
+use satrs_core::pus::scheduler_srv::PusService11SchedHandler;
+use satrs_core::pus::test::PusService17TestHandler;
+use satrs_core::pus::verification::{
+    TcStateStarted, VerificationReporterCfg, VerificationReporterWithSender, VerificationToken,
+};
+use satrs_core::pus::{MpscTcInStoreReceiver, MpscTmInStoreSender};
+use satrs_core::seq_count::{CcsdsSimpleSeqCountProvider, SequenceCountProviderCore};
+use satrs_core::spacepackets::tm::PusTmZeroCopyWriter;
+use satrs_core::spacepackets::{
+    time::cds::TimeProvider,
+    time::TimeWriter,
+    tm::{PusTm, PusTmSecondaryHeader},
+    SequenceFlags, SpHeader,
+};
+use satrs_core::tmtc::tm_helper::SharedTmStore;
+use satrs_core::tmtc::{AddressableId, TargetId};
+use satrs_core::ChannelId;
+use satrs_example::{RequestTargetId, TcReceiverId, TmSenderId, OBSW_SERVER_ADDR, SERVER_PORT};
+use std::collections::HashMap;
+use std::net::{IpAddr, SocketAddr};
+use std::sync::mpsc::{channel, TryRecvError};
+use std::sync::{Arc, RwLock};
+use std::thread;
+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![
+        (30, 32),
+        (15, 64),
+        (15, 128),
+        (15, 256),
+        (15, 1024),
+        (15, 2048),
+    ]));
+    let shared_tm_store = SharedTmStore::new(Box::new(tm_pool));
+    let tm_store_event = shared_tm_store.clone();
+    let tc_pool = LocalPool::new(PoolCfg::new(vec![
+        (30, 32),
+        (15, 64),
+        (15, 128),
+        (15, 256),
+        (15, 1024),
+        (15, 2048),
+    ]));
+    let tc_store = TcStore {
+        pool: Arc::new(RwLock::new(Box::new(tc_pool))),
+    };
+
+    let seq_count_provider = CcsdsSimpleSeqCountProvider::new();
+    let mut msg_counter_map: HashMap<u8, u16> = HashMap::new();
+    let sock_addr = SocketAddr::new(IpAddr::V4(OBSW_SERVER_ADDR), SERVER_PORT);
+    let (tc_source_tx, tc_source_rx) = channel();
+    let (tm_funnel_tx, tm_funnel_rx) = channel();
+    let (tm_server_tx, tm_server_rx) = channel();
+    let verif_sender = MpscTmInStoreSender::new(
+        TmSenderId::PusVerification as ChannelId,
+        "verif_sender",
+        shared_tm_store.clone(),
+        tm_funnel_tx.clone(),
+    );
+    let verif_cfg = VerificationReporterCfg::new(PUS_APID, 1, 2, 8).unwrap();
+    // Every software component which needs to generate verification telemetry, gets a cloned
+    // verification reporter.
+    let verif_reporter = VerificationReporterWithSender::new(&verif_cfg, Box::new(verif_sender));
+    let mut reporter_event_handler = verif_reporter.clone();
+    let mut reporter_aocs = verif_reporter.clone();
+
+    // Create event handling components
+    // These sender handles are used to send event requests, for example to enable or disable
+    // certain events
+    let (event_request_tx, event_request_rx) = channel::<EventRequestWithToken>();
+    // The sender handle is the primary sender handle for all components which want to create events.
+    // The event manager will receive the RX handle to receive all the events.
+    let (event_sender, event_man_rx) = channel();
+    let event_recv = MpscEventReceiver::<EventU32>::new(event_man_rx);
+    let test_srv_event_sender = event_sender;
+    let mut event_man = EventManagerWithMpscQueue::new(Box::new(event_recv));
+
+    // All events sent to the manager are routed to the PUS event manager, which generates PUS event
+    // telemetry for each event.
+    let event_reporter = EventReporter::new(PUS_APID, 128).unwrap();
+    let pus_tm_backend = DefaultPusMgmtBackendProvider::<EventU32>::default();
+    let mut pus_event_dispatcher =
+        PusEventDispatcher::new(event_reporter, Box::new(pus_tm_backend));
+    let (pus_event_man_tx, pus_event_man_rx) = channel();
+    let pus_event_man_send_provider = MpscEventU32SendProvider::new(1, pus_event_man_tx);
+    event_man.subscribe_all(pus_event_man_send_provider.id());
+    event_man.add_sender(pus_event_man_send_provider);
+
+    // Some request are targetable. This map is used to retrieve sender handles based on a target ID.
+    let mut request_map = HashMap::new();
+    let (acs_thread_tx, acs_thread_rx) = channel::<RequestWithToken>();
+    request_map.insert(RequestTargetId::AcsSubsystem as TargetId, acs_thread_tx);
+
+    let tc_source_wrapper = PusTcSource {
+        tc_store: tc_store.clone(),
+        tc_source: tc_source_tx,
+    };
+
+    // Create clones here to allow moving the values
+    let tc_args = TcArgs {
+        tc_source: tc_source_wrapper.clone(),
+        tc_receiver: tc_source_rx,
+    };
+    let tm_args = TmArgs {
+        tm_store: shared_tm_store.clone(),
+        tm_sink_sender: tm_funnel_tx.clone(),
+        tm_server_rx,
+    };
+
+    let aocs_tm_funnel = tm_funnel_tx.clone();
+    let aocs_tm_store = shared_tm_store.clone();
+
+    let (pus_test_tx, pus_test_rx) = channel();
+    let (pus_event_tx, pus_event_rx) = channel();
+    let (pus_sched_tx, pus_sched_rx) = channel();
+    let (pus_hk_tx, pus_hk_rx) = channel();
+    let (pus_action_tx, pus_action_rx) = channel();
+    let pus_router = PusTcMpscRouter {
+        test_service_receiver: pus_test_tx,
+        event_service_receiver: pus_event_tx,
+        sched_service_receiver: pus_sched_tx,
+        hk_service_receiver: pus_hk_tx,
+        action_service_receiver: pus_action_tx,
+    };
+    let test_srv_tm_sender = MpscTmInStoreSender::new(
+        TmSenderId::PusTest as ChannelId,
+        "PUS_17_TM_SENDER",
+        shared_tm_store.clone(),
+        tm_funnel_tx.clone(),
+    );
+    let test_srv_receiver = MpscTcInStoreReceiver::new(
+        TcReceiverId::PusTest as ChannelId,
+        "PUS_17_TC_RECV",
+        pus_test_rx,
+    );
+    let pus17_handler = PusService17TestHandler::new(
+        Box::new(test_srv_receiver),
+        tc_store.pool.clone(),
+        Box::new(test_srv_tm_sender),
+        PUS_APID,
+        verif_reporter.clone(),
+    );
+    let mut pus_17_wrapper = Service17CustomWrapper {
+        pus17_handler,
+        test_srv_event_sender,
+    };
+
+    let sched_srv_tm_sender = MpscTmInStoreSender::new(
+        TmSenderId::PusSched as ChannelId,
+        "PUS_11_TM_SENDER",
+        shared_tm_store.clone(),
+        tm_funnel_tx.clone(),
+    );
+    let sched_srv_receiver = MpscTcInStoreReceiver::new(
+        TcReceiverId::PusSched as ChannelId,
+        "PUS_11_TC_RECV",
+        pus_sched_rx,
+    );
+    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(),
+        scheduler,
+    );
+    let mut pus_11_wrapper = Pus11Wrapper {
+        pus_11_handler,
+        tc_source_wrapper,
+    };
+
+    let event_srv_tm_sender = MpscTmInStoreSender::new(
+        TmSenderId::PusEvent as ChannelId,
+        "PUS_5_TM_SENDER",
+        shared_tm_store.clone(),
+        tm_funnel_tx.clone(),
+    );
+    let event_srv_receiver = MpscTcInStoreReceiver::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(),
+        event_request_tx,
+    );
+    let mut pus_5_wrapper = Pus5Wrapper { pus_5_handler };
+
+    let action_srv_tm_sender = MpscTmInStoreSender::new(
+        TmSenderId::PusAction as ChannelId,
+        "PUS_8_TM_SENDER",
+        shared_tm_store.clone(),
+        tm_funnel_tx.clone(),
+    );
+    let action_srv_receiver = MpscTcInStoreReceiver::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(),
+        request_map.clone(),
+    );
+    let mut pus_8_wrapper = Pus8Wrapper { pus_8_handler };
+
+    let hk_srv_tm_sender = MpscTmInStoreSender::new(
+        TmSenderId::PusHk as ChannelId,
+        "PUS_3_TM_SENDER",
+        shared_tm_store.clone(),
+        tm_funnel_tx.clone(),
+    );
+    let hk_srv_receiver =
+        MpscTcInStoreReceiver::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(),
+        request_map,
+    );
+    let mut pus_3_wrapper = Pus3Wrapper { pus_3_handler };
+
+    info!("Starting TMTC task");
+    let jh0 = thread::Builder::new()
+        .name("TMTC".to_string())
+        .spawn(move || {
+            core_tmtc_task(sock_addr, tc_args, tm_args, verif_reporter, pus_router);
+        })
+        .unwrap();
+
+    info!("Starting TM funnel task");
+    let jh1 = thread::Builder::new()
+        .name("TM Funnel".to_string())
+        .spawn(move || {
+            let tm_funnel = TmFunnel {
+                tm_server_tx,
+                tm_funnel_rx,
+            };
+            loop {
+                if let Ok(addr) = tm_funnel.tm_funnel_rx.recv() {
+                    // Read the TM, set sequence counter and message counter, and finally update
+                    // the CRC.
+                    let shared_pool = shared_tm_store.clone_backing_pool();
+                    let mut pool_guard = shared_pool.write().expect("Locking TM pool failed");
+                    let tm_raw = pool_guard
+                        .modify(&addr)
+                        .expect("Reading TM from pool failed");
+                    let mut zero_copy_writer = PusTmZeroCopyWriter::new(tm_raw)
+                        .expect("Creating TM zero copy writer failed");
+                    zero_copy_writer.set_apid(PUS_APID);
+                    zero_copy_writer.set_seq_count(seq_count_provider.get_and_increment());
+                    let entry = msg_counter_map
+                        .entry(zero_copy_writer.service())
+                        .or_insert(0);
+                    zero_copy_writer.set_msg_count(*entry);
+                    if *entry == u16::MAX {
+                        *entry = 0;
+                    } else {
+                        *entry += 1;
+                    }
+
+                    // This operation has to come last!
+                    zero_copy_writer.finish();
+                    tm_funnel
+                        .tm_server_tx
+                        .send(addr)
+                        .expect("Sending TM to server failed");
+                }
+            }
+        })
+        .unwrap();
+
+    info!("Starting event handling task");
+    let jh2 = thread::Builder::new()
+        .name("Event".to_string())
+        .spawn(move || {
+            let mut timestamp: [u8; 7] = [0; 7];
+            let mut sender = MpscTmInStoreSender::new(
+                TmSenderId::AllEvents as ChannelId,
+                "ALL_EVENTS_TX",
+                tm_store_event.clone(),
+                tm_funnel_tx,
+            );
+            let mut time_provider = TimeProvider::new_with_u16_days(0, 0);
+            let mut report_completion = |event_req: EventRequestWithToken, timestamp: &[u8]| {
+                let started_token: VerificationToken<TcStateStarted> = event_req
+                    .token
+                    .try_into()
+                    .expect("expected start verification token");
+                reporter_event_handler
+                    .completion_success(started_token, Some(timestamp))
+                    .expect("Sending completion success failed");
+            };
+            loop {
+                // handle event requests
+                if let Ok(event_req) = event_request_rx.try_recv() {
+                    match event_req.request {
+                        EventRequest::Enable(event) => {
+                            pus_event_dispatcher
+                                .enable_tm_for_event(&event)
+                                .expect("Enabling TM failed");
+                            update_time(&mut time_provider, &mut timestamp);
+                            report_completion(event_req, &timestamp);
+                        }
+                        EventRequest::Disable(event) => {
+                            pus_event_dispatcher
+                                .disable_tm_for_event(&event)
+                                .expect("Disabling TM failed");
+                            update_time(&mut time_provider, &mut timestamp);
+                            report_completion(event_req, &timestamp);
+                        }
+                    }
+                }
+
+                // Perform the event routing.
+                event_man
+                    .try_event_handling()
+                    .expect("event handling failed");
+
+                // Perform the generation of PUS event packets
+                if let Ok((event, _param)) = pus_event_man_rx.try_recv() {
+                    update_time(&mut time_provider, &mut timestamp);
+                    pus_event_dispatcher
+                        .generate_pus_event_tm_generic(&mut sender, &timestamp, event, None)
+                        .expect("Sending TM as event failed");
+                }
+                thread::sleep(Duration::from_millis(400));
+            }
+        })
+        .unwrap();
+
+    info!("Starting AOCS thread");
+    let jh3 = thread::Builder::new()
+        .name("AOCS".to_string())
+        .spawn(move || {
+            let mut timestamp: [u8; 7] = [0; 7];
+            let mut time_provider = TimeProvider::new_with_u16_days(0, 0);
+            loop {
+                match acs_thread_rx.try_recv() {
+                    Ok(request) => {
+                        info!(
+                            "ACS thread: Received HK request {:?}",
+                            request.targeted_request
+                        );
+                        update_time(&mut time_provider, &mut timestamp);
+                        match request.targeted_request.request {
+                            Request::Hk(hk_req) => match hk_req {
+                                HkRequest::OneShot(unique_id) => {
+                                    let target = request.targeted_request.target_id;
+                                    assert_eq!(target, RequestTargetId::AcsSubsystem as u32);
+                                    if request.targeted_request.target_id
+                                        == AcsHkIds::TestMgmSet as u32
+                                    {
+                                        let mut sp_header = SpHeader::tm(
+                                            PUS_APID,
+                                            SequenceFlags::Unsegmented,
+                                            0,
+                                            0,
+                                        )
+                                        .unwrap();
+                                        let sec_header = PusTmSecondaryHeader::new_simple(
+                                            3,
+                                            HkSubservice::TmHkPacket as u8,
+                                            &timestamp,
+                                        );
+                                        let mut buf: [u8; 8] = [0; 8];
+                                        let addressable_id = AddressableId {
+                                            target_id: target,
+                                            unique_id,
+                                        };
+                                        addressable_id.write_to_be_bytes(&mut buf).unwrap();
+                                        let pus_tm = PusTm::new(
+                                            &mut sp_header,
+                                            sec_header,
+                                            Some(&buf),
+                                            true,
+                                        );
+                                        let addr = aocs_tm_store
+                                            .add_pus_tm(&pus_tm)
+                                            .expect("Adding PUS TM failed");
+                                        aocs_tm_funnel.send(addr).expect("Sending HK TM failed");
+                                    }
+                                }
+                                HkRequest::Enable(_) => {}
+                                HkRequest::Disable(_) => {}
+                                HkRequest::ModifyCollectionInterval(_, _) => {}
+                            },
+                            Request::Mode(_mode_req) => {
+                                warn!("mode request handling not implemented yet")
+                            }
+                            Request::Action(_action_req) => {
+                                warn!("action request handling not implemented yet")
+                            }
+                        }
+                        let started_token = reporter_aocs
+                            .start_success(request.token, Some(&timestamp))
+                            .expect("Sending start success failed");
+                        reporter_aocs
+                            .completion_success(started_token, Some(&timestamp))
+                            .expect("Sending completion success failed");
+                    }
+                    Err(e) => match e {
+                        TryRecvError::Empty => {}
+                        TryRecvError::Disconnected => {
+                            warn!("ACS thread: Message Queue TX disconnected!")
+                        }
+                    },
+                }
+                thread::sleep(Duration::from_millis(500));
+            }
+        })
+        .unwrap();
+
+    info!("Starting PUS handler thread");
+    let jh4 = thread::Builder::new()
+        .name("PUS".to_string())
+        .spawn(move || loop {
+            pus_11_wrapper.release_tcs();
+            loop {
+                let mut all_queues_empty = true;
+                let mut is_srv_finished = |srv_handler_finished: bool| {
+                    if !srv_handler_finished {
+                        all_queues_empty = false;
+                    }
+                };
+                is_srv_finished(pus_17_wrapper.handle_next_packet());
+                is_srv_finished(pus_11_wrapper.handle_next_packet());
+                is_srv_finished(pus_5_wrapper.handle_next_packet());
+                is_srv_finished(pus_8_wrapper.handle_next_packet());
+                is_srv_finished(pus_3_wrapper.handle_next_packet());
+                if all_queues_empty {
+                    break;
+                }
+            }
+            thread::sleep(Duration::from_millis(200));
+        })
+        .unwrap();
+    jh0.join().expect("Joining UDP TMTC server thread failed");
+    jh1.join().expect("Joining TM Funnel thread failed");
+    jh2.join().expect("Joining Event Manager thread failed");
+    jh3.join().expect("Joining AOCS thread failed");
+    jh4.join().expect("Joining PUS handler thread failed");
+}
+
+pub fn update_time(time_provider: &mut TimeProvider, timestamp: &mut [u8]) {
+    time_provider
+        .update_from_now()
+        .expect("Could not get current time");
+    time_provider
+        .write_to_bytes(timestamp)
+        .expect("Writing timestamp failed");
+}
diff --git a/satrs-example/src/pus/action.rs b/satrs-example/src/pus/action.rs
new file mode 100644
index 0000000..4dd3e55
--- /dev/null
+++ b/satrs-example/src/pus/action.rs
@@ -0,0 +1,179 @@
+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,
+};
+use satrs_core::pus::{
+    EcssTcReceiver, EcssTmSender, PusPacketHandlerResult, PusPacketHandlingError, PusServiceBase,
+    PusServiceHandler,
+};
+use satrs_core::spacepackets::ecss::PusPacket;
+use satrs_core::spacepackets::tc::PusTc;
+use satrs_core::tmtc::TargetId;
+use satrs_example::tmtc_err;
+use std::collections::HashMap;
+use std::sync::mpsc::Sender;
+
+pub struct PusService8ActionHandler {
+    psb: PusServiceBase,
+    request_handlers: HashMap<TargetId, Sender<RequestWithToken>>,
+}
+
+impl PusService8ActionHandler {
+    pub fn new(
+        tc_receiver: Box<dyn EcssTcReceiver>,
+        shared_tc_pool: SharedPool,
+        tm_sender: Box<dyn EcssTmSender>,
+        tm_apid: u16,
+        verification_handler: StdVerifReporterWithSender,
+        request_handlers: HashMap<TargetId, Sender<RequestWithToken>>,
+    ) -> Self {
+        Self {
+            psb: PusServiceBase::new(
+                tc_receiver,
+                shared_tc_pool,
+                tm_sender,
+                tm_apid,
+                verification_handler,
+            ),
+            request_handlers,
+        }
+    }
+}
+
+impl PusService8ActionHandler {
+    fn handle_action_request_with_id(
+        &self,
+        token: VerificationToken<TcStateAccepted>,
+        tc: &PusTc,
+        time_stamp: &[u8],
+    ) -> Result<(), PusPacketHandlingError> {
+        let user_data = tc.user_data();
+        if user_data.is_none() || user_data.unwrap().len() < 8 {
+            self.psb()
+                .verification_handler
+                .borrow_mut()
+                .start_failure(
+                    token,
+                    FailParams::new(Some(time_stamp), &tmtc_err::NOT_ENOUGH_APP_DATA, None),
+                )
+                .expect("Sending start failure failed");
+            return Err(PusPacketHandlingError::NotEnoughAppData(
+                "Expected at least 4 bytes".into(),
+            ));
+        }
+        let user_data = user_data.unwrap();
+        let target_id = u32::from_be_bytes(user_data[0..4].try_into().unwrap());
+        let action_id = u32::from_be_bytes(user_data[4..8].try_into().unwrap());
+        if let Some(sender) = self.request_handlers.get(&target_id) {
+            sender
+                .send(RequestWithToken::new(
+                    target_id,
+                    Request::Action(ActionRequest::CmdWithU32Id((
+                        action_id,
+                        Vec::from(&user_data[8..]),
+                    ))),
+                    token,
+                ))
+                .expect("Forwarding action request failed");
+        } else {
+            let mut fail_data: [u8; 4] = [0; 4];
+            fail_data.copy_from_slice(&target_id.to_be_bytes());
+            self.psb()
+                .verification_handler
+                .borrow_mut()
+                .start_failure(
+                    token,
+                    FailParams::new(
+                        Some(time_stamp),
+                        &tmtc_err::UNKNOWN_TARGET_ID,
+                        Some(&fail_data),
+                    ),
+                )
+                .expect("Sending start failure failed");
+            return Err(PusPacketHandlingError::Other(format!(
+                "Unknown target ID {target_id}"
+            )));
+        }
+        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, _) = PusTc::from_bytes(&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);
+        match subservice {
+            128 => {
+                self.handle_action_request_with_id(token, &tc, &time_stamp)?;
+            }
+            _ => {
+                let fail_data = [subservice];
+                self.psb_mut()
+                    .verification_handler
+                    .get_mut()
+                    .start_failure(
+                        token,
+                        FailParams::new(
+                            Some(&time_stamp),
+                            &tmtc_err::INVALID_PUS_SUBSERVICE,
+                            Some(&fail_data),
+                        ),
+                    )
+                    .expect("Sending start failure failed");
+                return Err(PusPacketHandlingError::InvalidSubservice(subservice));
+            }
+        }
+        if let Some(partial_error) = partial_error {
+            return Ok(PusPacketHandlerResult::RequestHandledPartialSuccess(
+                partial_error,
+            ));
+        }
+        Ok(PusPacketHandlerResult::RequestHandled)
+    }
+}
+
+pub struct Pus8Wrapper {
+    pub(crate) pus_8_handler: PusService8ActionHandler,
+}
+
+impl Pus8Wrapper {
+    pub fn handle_next_packet(&mut self) -> bool {
+        match self.pus_8_handler.handle_next_packet() {
+            Ok(result) => match result {
+                PusPacketHandlerResult::RequestHandled => {}
+                PusPacketHandlerResult::RequestHandledPartialSuccess(e) => {
+                    warn!("PUS 8 partial packet handling success: {e:?}")
+                }
+                PusPacketHandlerResult::CustomSubservice(invalid, _) => {
+                    warn!("PUS 8 invalid subservice {invalid}");
+                }
+                PusPacketHandlerResult::SubserviceNotImplemented(subservice, _) => {
+                    warn!("PUS 8 subservice {subservice} not implemented");
+                }
+                PusPacketHandlerResult::Empty => {
+                    return true;
+                }
+            },
+            Err(error) => {
+                error!("PUS packet handling error: {error:?}")
+            }
+        }
+        false
+    }
+}
diff --git a/satrs-example/src/pus/event.rs b/satrs-example/src/pus/event.rs
new file mode 100644
index 0000000..0f2654e
--- /dev/null
+++ b/satrs-example/src/pus/event.rs
@@ -0,0 +1,33 @@
+use log::{error, warn};
+use satrs_core::pus::event_srv::PusService5EventHandler;
+use satrs_core::pus::{PusPacketHandlerResult, PusServiceHandler};
+
+pub struct Pus5Wrapper {
+    pub pus_5_handler: PusService5EventHandler,
+}
+
+impl Pus5Wrapper {
+    pub fn handle_next_packet(&mut self) -> bool {
+        match self.pus_5_handler.handle_next_packet() {
+            Ok(result) => match result {
+                PusPacketHandlerResult::RequestHandled => {}
+                PusPacketHandlerResult::RequestHandledPartialSuccess(e) => {
+                    warn!("PUS 5 partial packet handling success: {e:?}")
+                }
+                PusPacketHandlerResult::CustomSubservice(invalid, _) => {
+                    warn!("PUS 5 invalid subservice {invalid}");
+                }
+                PusPacketHandlerResult::SubserviceNotImplemented(subservice, _) => {
+                    warn!("PUS 5 subservice {subservice} not implemented");
+                }
+                PusPacketHandlerResult::Empty => {
+                    return true;
+                }
+            },
+            Err(error) => {
+                error!("PUS packet handling error: {error:?}")
+            }
+        }
+        false
+    }
+}
diff --git a/satrs-example/src/pus/hk.rs b/satrs-example/src/pus/hk.rs
new file mode 100644
index 0000000..b7e70c2
--- /dev/null
+++ b/satrs-example/src/pus/hk.rs
@@ -0,0 +1,193 @@
+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::{
+    EcssTcReceiver, EcssTmSender, PusPacketHandlerResult, PusPacketHandlingError, PusServiceBase,
+    PusServiceHandler,
+};
+use satrs_core::spacepackets::ecss::{hk, PusPacket};
+use satrs_core::spacepackets::tc::PusTc;
+use satrs_core::tmtc::{AddressableId, TargetId};
+use satrs_example::{hk_err, tmtc_err};
+use std::collections::HashMap;
+use std::sync::mpsc::Sender;
+
+pub struct PusService3HkHandler {
+    psb: PusServiceBase,
+    request_handlers: HashMap<TargetId, Sender<RequestWithToken>>,
+}
+
+impl PusService3HkHandler {
+    pub fn new(
+        tc_receiver: Box<dyn EcssTcReceiver>,
+        shared_tc_pool: SharedPool,
+        tm_sender: Box<dyn EcssTmSender>,
+        tm_apid: u16,
+        verification_handler: StdVerifReporterWithSender,
+        request_handlers: HashMap<TargetId, Sender<RequestWithToken>>,
+    ) -> Self {
+        Self {
+            psb: PusServiceBase::new(
+                tc_receiver,
+                shared_tc_pool,
+                tm_sender,
+                tm_apid,
+                verification_handler,
+            ),
+            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, _) = PusTc::from_bytes(&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 user_data = tc.user_data().unwrap();
+        if tc.user_data().is_none() {
+            self.psb
+                .verification_handler
+                .borrow_mut()
+                .start_failure(
+                    token,
+                    FailParams::new(Some(&time_stamp), &tmtc_err::NOT_ENOUGH_APP_DATA, None),
+                )
+                .expect("Sending start failure TM failed");
+            return Err(PusPacketHandlingError::NotEnoughAppData(
+                "Expected at least 8 bytes of app data".into(),
+            ));
+        }
+        if user_data.len() < 8 {
+            let err = if user_data.len() < 4 {
+                &hk_err::TARGET_ID_MISSING
+            } else {
+                &hk_err::UNIQUE_ID_MISSING
+            };
+            self.psb
+                .verification_handler
+                .borrow_mut()
+                .start_failure(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(),
+            ));
+        }
+        let addressable_id = AddressableId::from_raw_be(user_data).unwrap();
+        if !self
+            .request_handlers
+            .contains_key(&addressable_id.target_id)
+        {
+            self.psb
+                .verification_handler
+                .borrow_mut()
+                .start_failure(
+                    token,
+                    FailParams::new(Some(&time_stamp), &hk_err::UNKNOWN_TARGET_ID, None),
+                )
+                .expect("Sending start failure TM failed");
+            let tgt_id = addressable_id.target_id;
+            return Err(PusPacketHandlingError::NotEnoughAppData(format!(
+                "Unknown target ID {tgt_id}"
+            )));
+        }
+        let send_request = |target: TargetId, request: HkRequest| {
+            let sender = self
+                .request_handlers
+                .get(&addressable_id.target_id)
+                .unwrap();
+            sender
+                .send(RequestWithToken::new(target, Request::Hk(request), token))
+                .unwrap_or_else(|_| panic!("Sending HK request {request:?} failed"));
+        };
+        if subservice == hk::Subservice::TcEnableHkGeneration as u8 {
+            send_request(
+                addressable_id.target_id,
+                HkRequest::Enable(addressable_id.unique_id),
+            );
+        } else if subservice == hk::Subservice::TcDisableHkGeneration as u8 {
+            send_request(
+                addressable_id.target_id,
+                HkRequest::Disable(addressable_id.unique_id),
+            );
+        } else if subservice == hk::Subservice::TcGenerateOneShotHk as u8 {
+            send_request(
+                addressable_id.target_id,
+                HkRequest::OneShot(addressable_id.unique_id),
+            );
+        } else if subservice == hk::Subservice::TcModifyHkCollectionInterval as u8 {
+            if user_data.len() < 12 {
+                self.psb
+                    .verification_handler
+                    .borrow_mut()
+                    .start_failure(
+                        token,
+                        FailParams::new(
+                            Some(&time_stamp),
+                            &hk_err::COLLECTION_INTERVAL_MISSING,
+                            None,
+                        ),
+                    )
+                    .expect("Sending start failure TM failed");
+                return Err(PusPacketHandlingError::NotEnoughAppData(
+                    "Collection interval missing".into(),
+                ));
+            }
+            send_request(
+                addressable_id.target_id,
+                HkRequest::ModifyCollectionInterval(
+                    addressable_id.unique_id,
+                    CollectionIntervalFactor::from_be_bytes(user_data[8..12].try_into().unwrap()),
+                ),
+            );
+        }
+        Ok(PusPacketHandlerResult::RequestHandled)
+    }
+}
+
+pub struct Pus3Wrapper {
+    pub(crate) pus_3_handler: PusService3HkHandler,
+}
+
+impl Pus3Wrapper {
+    pub fn handle_next_packet(&mut self) -> bool {
+        match self.pus_3_handler.handle_next_packet() {
+            Ok(result) => match result {
+                PusPacketHandlerResult::RequestHandled => {}
+                PusPacketHandlerResult::RequestHandledPartialSuccess(e) => {
+                    warn!("PUS 3 partial packet handling success: {e:?}")
+                }
+                PusPacketHandlerResult::CustomSubservice(invalid, _) => {
+                    warn!("PUS 3 invalid subservice {invalid}");
+                }
+                PusPacketHandlerResult::SubserviceNotImplemented(subservice, _) => {
+                    warn!("PUS 3 subservice {subservice} not implemented");
+                }
+                PusPacketHandlerResult::Empty => {
+                    return true;
+                }
+            },
+            Err(error) => {
+                error!("PUS packet handling error: {error:?}")
+            }
+        }
+        false
+    }
+}
diff --git a/satrs-example/src/pus/mod.rs b/satrs-example/src/pus/mod.rs
new file mode 100644
index 0000000..d8b1c5b
--- /dev/null
+++ b/satrs-example/src/pus/mod.rs
@@ -0,0 +1,141 @@
+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::spacepackets::ecss::PusServiceId;
+use satrs_core::spacepackets::tc::PusTc;
+use satrs_core::spacepackets::time::cds::TimeProvider;
+use satrs_core::spacepackets::time::TimeWriter;
+use satrs_example::{tmtc_err, CustomPusServiceId};
+use std::sync::mpsc::Sender;
+
+pub mod action;
+pub mod event;
+pub mod hk;
+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 struct PusReceiver {
+    pub verif_reporter: StdVerifReporterWithSender,
+    pub pus_router: PusTcMpscRouter,
+    stamp_helper: TimeStampHelper,
+}
+
+struct TimeStampHelper {
+    stamper: TimeProvider,
+    time_stamp: [u8; 7],
+}
+
+impl TimeStampHelper {
+    pub fn new() -> Self {
+        Self {
+            stamper: TimeProvider::new_with_u16_days(0, 0),
+            time_stamp: [0; 7],
+        }
+    }
+
+    pub fn stamp(&self) -> &[u8] {
+        &self.time_stamp
+    }
+
+    pub fn update_from_now(&mut self) {
+        self.stamper
+            .update_from_now()
+            .expect("Updating timestamp failed");
+        self.stamper
+            .write_to_bytes(&mut self.time_stamp)
+            .expect("Writing timestamp failed");
+    }
+}
+
+impl PusReceiver {
+    pub fn new(verif_reporter: StdVerifReporterWithSender, pus_router: PusTcMpscRouter) -> Self {
+        Self {
+            verif_reporter,
+            pus_router,
+            stamp_helper: TimeStampHelper::new(),
+        }
+    }
+}
+
+impl PusReceiver {
+    pub fn handle_tc_packet(
+        &mut self,
+        store_addr: StoreAddr,
+        service: u8,
+        pus_tc: &PusTc,
+    ) -> Result<PusPacketHandlerResult, MpscStoreAndSendError> {
+        let init_token = self.verif_reporter.add_tc(pus_tc);
+        self.stamp_helper.update_from_now();
+        let accepted_token = self
+            .verif_reporter
+            .acceptance_success(init_token, Some(self.stamp_helper.stamp()))
+            .expect("Acceptance success failure");
+        let service = PusServiceId::try_from(service);
+        match service {
+            Ok(standard_service) => match standard_service {
+                PusServiceId::Test => {
+                    self.pus_router
+                        .test_service_receiver
+                        .send((store_addr, 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,
+                        FailParams::new(
+                            Some(self.stamp_helper.stamp()),
+                            &tmtc_err::PUS_SERVICE_NOT_IMPLEMENTED,
+                            Some(&[standard_service as u8]),
+                        ),
+                    );
+                    if result.is_err() {
+                        warn!("Sending verification failure failed");
+                    }
+                }
+            },
+            Err(e) => {
+                if let Ok(custom_service) = CustomPusServiceId::try_from(e.number) {
+                    match custom_service {
+                        CustomPusServiceId::Mode => {
+                            //self.handle_mode_service(pus_tc, accepted_token)
+                        }
+                        CustomPusServiceId::Health => {}
+                    }
+                } else {
+                    self.verif_reporter
+                        .start_failure(
+                            accepted_token,
+                            FailParams::new(
+                                Some(self.stamp_helper.stamp()),
+                                &tmtc_err::INVALID_PUS_SUBSERVICE,
+                                Some(&[e.number]),
+                            ),
+                        )
+                        .expect("Start failure verification failed")
+                }
+            }
+        }
+        Ok(PusPacketHandlerResult::RequestHandled)
+    }
+}
diff --git a/satrs-example/src/pus/scheduler.rs b/satrs-example/src/pus/scheduler.rs
new file mode 100644
index 0000000..35c84b8
--- /dev/null
+++ b/satrs-example/src/pus/scheduler.rs
@@ -0,0 +1,69 @@
+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};
+
+pub struct Pus11Wrapper {
+    pub pus_11_handler: PusService11SchedHandler,
+    pub tc_source_wrapper: PusTcSource,
+}
+
+impl Pus11Wrapper {
+    pub fn release_tcs(&mut self) {
+        let releaser = |enabled: bool, info: &TcInfo| -> bool {
+            if enabled {
+                self.tc_source_wrapper
+                    .tc_source
+                    .send(info.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
+            .pus_11_handler
+            .scheduler_mut()
+            .release_telecommands(releaser, pool.as_mut())
+        {
+            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() {
+            Ok(result) => match result {
+                PusPacketHandlerResult::RequestHandled => {}
+                PusPacketHandlerResult::RequestHandledPartialSuccess(e) => {
+                    warn!("PUS11 partial packet handling success: {e:?}")
+                }
+                PusPacketHandlerResult::CustomSubservice(invalid, _) => {
+                    warn!("PUS11 invalid subservice {invalid}");
+                }
+                PusPacketHandlerResult::SubserviceNotImplemented(subservice, _) => {
+                    warn!("PUS11: Subservice {subservice} not implemented");
+                }
+                PusPacketHandlerResult::Empty => {
+                    return true;
+                }
+            },
+            Err(error) => {
+                error!("PUS packet handling error: {error:?}")
+            }
+        }
+        false
+    }
+}
diff --git a/satrs-example/src/pus/test.rs b/satrs-example/src/pus/test.rs
new file mode 100644
index 0000000..5edae74
--- /dev/null
+++ b/satrs-example/src/pus/test.rs
@@ -0,0 +1,85 @@
+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::spacepackets::ecss::PusPacket;
+use satrs_core::spacepackets::tc::PusTc;
+use satrs_core::spacepackets::time::cds::TimeProvider;
+use satrs_core::spacepackets::time::TimeWriter;
+use satrs_example::{tmtc_err, TEST_EVENT};
+use std::sync::mpsc::Sender;
+
+pub struct Service17CustomWrapper {
+    pub pus17_handler: PusService17TestHandler,
+    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();
+        if res.is_err() {
+            warn!("PUS17 handler failed with error {:?}", res.unwrap_err());
+            return true;
+        }
+        match res.unwrap() {
+            PusPacketHandlerResult::RequestHandled => {
+                info!("Received PUS ping command TC[17,1]");
+                info!("Sent ping reply PUS TM[17,2]");
+            }
+            PusPacketHandlerResult::RequestHandledPartialSuccess(partial_err) => {
+                warn!(
+                    "Handled PUS ping command with partial success: {:?}",
+                    partial_err
+                );
+            }
+            PusPacketHandlerResult::SubserviceNotImplemented(subservice, _) => {
+                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, _) = PusTc::from_bytes(&buf).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();
+                if subservice == 128 {
+                    info!("Generating test event");
+                    self.test_srv_event_sender
+                        .send((TEST_EVENT.into(), None))
+                        .expect("Sending test event failed");
+                    let start_token = psb_mut
+                        .verification_handler
+                        .get_mut()
+                        .start_success(token, Some(&stamp_buf))
+                        .expect("Error sending start success");
+                    psb_mut
+                        .verification_handler
+                        .get_mut()
+                        .completion_success(start_token, Some(&stamp_buf))
+                        .expect("Error sending completion success");
+                } else {
+                    let fail_data = [tc.subservice()];
+                    self.pus17_handler
+                        .psb_mut()
+                        .verification_handler
+                        .get_mut()
+                        .start_failure(
+                            token,
+                            FailParams::new(
+                                Some(&stamp_buf),
+                                &tmtc_err::INVALID_PUS_SUBSERVICE,
+                                Some(&fail_data),
+                            ),
+                        )
+                        .expect("Sending start failure verification failed");
+                }
+            }
+            PusPacketHandlerResult::Empty => {
+                return true;
+            }
+        }
+        false
+    }
+}
diff --git a/satrs-example/src/requests.rs b/satrs-example/src/requests.rs
new file mode 100644
index 0000000..5fa2549
--- /dev/null
+++ b/satrs-example/src/requests.rs
@@ -0,0 +1,51 @@
+use satrs_core::hk::HkRequest;
+use satrs_core::mode::ModeRequest;
+use satrs_core::pus::verification::{TcStateAccepted, VerificationToken};
+use satrs_core::tmtc::TargetId;
+
+#[allow(dead_code)]
+#[derive(Clone, Eq, PartialEq, Debug)]
+pub enum ActionRequest {
+    CmdWithU32Id((u32, Vec<u8>)),
+    CmdWithStringId((String, Vec<u8>)),
+}
+
+#[allow(dead_code)]
+#[derive(Clone, Eq, PartialEq, Debug)]
+#[non_exhaustive]
+pub enum Request {
+    Hk(HkRequest),
+    Mode(ModeRequest),
+    Action(ActionRequest),
+}
+
+#[derive(Clone, Eq, PartialEq, Debug)]
+pub struct TargetedRequest {
+    pub(crate) target_id: TargetId,
+    pub(crate) request: Request,
+}
+
+impl TargetedRequest {
+    pub fn new(target_id: TargetId, request: Request) -> Self {
+        Self { target_id, request }
+    }
+}
+
+#[derive(Clone, Eq, PartialEq, Debug)]
+pub struct RequestWithToken {
+    pub(crate) targeted_request: TargetedRequest,
+    pub(crate) token: VerificationToken<TcStateAccepted>,
+}
+
+impl RequestWithToken {
+    pub fn new(
+        target_id: u32,
+        request: Request,
+        token: VerificationToken<TcStateAccepted>,
+    ) -> Self {
+        Self {
+            targeted_request: TargetedRequest::new(target_id, request),
+            token,
+        }
+    }
+}
diff --git a/satrs-example/src/tmtc.rs b/satrs-example/src/tmtc.rs
new file mode 100644
index 0000000..2a18dd3
--- /dev/null
+++ b/satrs-example/src/tmtc.rs
@@ -0,0 +1,232 @@
+use log::{info, warn};
+use satrs_core::hal::host::udp_server::{ReceiveResult, UdpTcServer};
+use std::net::SocketAddr;
+use std::sync::mpsc::{Receiver, SendError, Sender, TryRecvError};
+use std::thread;
+use std::time::Duration;
+use thiserror::Error;
+
+use crate::ccsds::CcsdsReceiver;
+use crate::pus::{PusReceiver, PusTcMpscRouter};
+use satrs_core::pool::{SharedPool, StoreAddr, StoreError};
+use satrs_core::pus::verification::StdVerifReporterWithSender;
+use satrs_core::pus::{ReceivesEcssPusTc, TcAddrWithToken};
+use satrs_core::spacepackets::ecss::{PusPacket, SerializablePusPacket};
+use satrs_core::spacepackets::tc::PusTc;
+use satrs_core::spacepackets::SpHeader;
+use satrs_core::tmtc::tm_helper::SharedTmStore;
+use satrs_core::tmtc::{CcsdsDistributor, CcsdsError, ReceivesCcsdsTc};
+
+pub const PUS_APID: u16 = 0x02;
+
+pub struct TmArgs {
+    pub tm_store: SharedTmStore,
+    pub tm_sink_sender: Sender<StoreAddr>,
+    pub tm_server_rx: Receiver<StoreAddr>,
+}
+
+pub struct TcArgs {
+    pub tc_source: PusTcSource,
+    pub tc_receiver: Receiver<StoreAddr>,
+}
+
+impl TcArgs {
+    #[allow(dead_code)]
+    fn split(self) -> (PusTcSource, Receiver<StoreAddr>) {
+        (self.tc_source, self.tc_receiver)
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Error)]
+pub enum MpscStoreAndSendError {
+    #[error("Store error: {0}")]
+    Store(#[from] StoreError),
+    #[error("TC send error: {0}")]
+    TcSend(#[from] SendError<TcAddrWithToken>),
+    #[error("TMTC send error: {0}")]
+    TmTcSend(#[from] SendError<StoreAddr>),
+}
+
+#[derive(Clone)]
+pub struct TcStore {
+    pub pool: SharedPool,
+}
+
+impl TcStore {
+    pub fn add_pus_tc(&mut self, pus_tc: &PusTc) -> Result<StoreAddr, StoreError> {
+        let mut pg = self.pool.write().expect("error locking TC store");
+        let (addr, buf) = pg.free_element(pus_tc.len_packed())?;
+        pus_tc
+            .write_to_bytes(buf)
+            .expect("writing PUS TC to store failed");
+        Ok(addr)
+    }
+}
+
+pub struct TmFunnel {
+    pub tm_funnel_rx: Receiver<StoreAddr>,
+    pub tm_server_tx: Sender<StoreAddr>,
+}
+
+pub struct UdpTmtcServer {
+    udp_tc_server: UdpTcServer<CcsdsError<MpscStoreAndSendError>>,
+    tm_rx: Receiver<StoreAddr>,
+    tm_store: SharedPool,
+}
+
+#[derive(Clone)]
+pub struct PusTcSource {
+    pub tc_source: Sender<StoreAddr>,
+    pub tc_store: TcStore,
+}
+
+impl ReceivesEcssPusTc for PusTcSource {
+    type Error = MpscStoreAndSendError;
+
+    fn pass_pus_tc(&mut self, _: &SpHeader, pus_tc: &PusTc) -> Result<(), Self::Error> {
+        let addr = self.tc_store.add_pus_tc(pus_tc)?;
+        self.tc_source.send(addr)?;
+        Ok(())
+    }
+}
+
+impl ReceivesCcsdsTc for PusTcSource {
+    type Error = MpscStoreAndSendError;
+
+    fn pass_ccsds(&mut self, _: &SpHeader, tc_raw: &[u8]) -> Result<(), Self::Error> {
+        let mut pool = self.tc_store.pool.write().expect("locking pool failed");
+        let addr = pool.add(tc_raw)?;
+        drop(pool);
+        self.tc_source.send(addr)?;
+        Ok(())
+    }
+}
+
+pub fn core_tmtc_task(
+    socket_addr: SocketAddr,
+    mut tc_args: TcArgs,
+    tm_args: TmArgs,
+    verif_reporter: StdVerifReporterWithSender,
+    pus_router: PusTcMpscRouter,
+) {
+    let mut pus_receiver = PusReceiver::new(verif_reporter, pus_router);
+
+    let ccsds_receiver = CcsdsReceiver {
+        tc_source: tc_args.tc_source.clone(),
+    };
+
+    let ccsds_distributor = CcsdsDistributor::new(Box::new(ccsds_receiver));
+
+    let udp_tc_server = UdpTcServer::new(socket_addr, 2048, Box::new(ccsds_distributor))
+        .expect("creating UDP TMTC server failed");
+
+    let mut udp_tmtc_server = UdpTmtcServer {
+        udp_tc_server,
+        tm_rx: tm_args.tm_server_rx,
+        tm_store: tm_args.tm_store.clone_backing_pool(),
+    };
+
+    let mut tc_buf: [u8; 4096] = [0; 4096];
+    loop {
+        core_tmtc_loop(
+            &mut udp_tmtc_server,
+            &mut tc_args,
+            &mut tc_buf,
+            &mut pus_receiver,
+        );
+        thread::sleep(Duration::from_millis(400));
+    }
+}
+
+fn core_tmtc_loop(
+    udp_tmtc_server: &mut UdpTmtcServer,
+    tc_args: &mut TcArgs,
+    tc_buf: &mut [u8],
+    pus_receiver: &mut PusReceiver,
+) {
+    while poll_tc_server(udp_tmtc_server) {}
+    match tc_args.tc_receiver.try_recv() {
+        Ok(addr) => {
+            let pool = tc_args
+                .tc_source
+                .tc_store
+                .pool
+                .read()
+                .expect("locking tc pool failed");
+            let data = pool.read(&addr).expect("reading pool failed");
+            tc_buf[0..data.len()].copy_from_slice(data);
+            drop(pool);
+            match PusTc::from_bytes(tc_buf) {
+                Ok((pus_tc, _)) => {
+                    pus_receiver
+                        .handle_tc_packet(addr, pus_tc.service(), &pus_tc)
+                        .ok();
+                }
+                Err(e) => {
+                    warn!("error creating PUS TC from raw data: {e}");
+                    warn!("raw data: {tc_buf:x?}");
+                }
+            }
+        }
+        Err(e) => {
+            if let TryRecvError::Disconnected = e {
+                warn!("tmtc thread: sender disconnected")
+            }
+        }
+    }
+    if let Some(recv_addr) = udp_tmtc_server.udp_tc_server.last_sender() {
+        core_tm_handling(udp_tmtc_server, &recv_addr);
+    }
+}
+
+fn poll_tc_server(udp_tmtc_server: &mut UdpTmtcServer) -> bool {
+    match udp_tmtc_server.udp_tc_server.try_recv_tc() {
+        Ok(_) => true,
+        Err(e) => match e {
+            ReceiveResult::ReceiverError(e) => match e {
+                CcsdsError::ByteConversionError(e) => {
+                    warn!("packet error: {e:?}");
+                    true
+                }
+                CcsdsError::CustomError(e) => {
+                    warn!("mpsc store and send error {e:?}");
+                    true
+                }
+            },
+            ReceiveResult::IoError(e) => {
+                warn!("IO error {e}");
+                false
+            }
+            ReceiveResult::NothingReceived => false,
+        },
+    }
+}
+
+fn core_tm_handling(udp_tmtc_server: &mut UdpTmtcServer, recv_addr: &SocketAddr) {
+    while let Ok(addr) = udp_tmtc_server.tm_rx.try_recv() {
+        let store_lock = udp_tmtc_server.tm_store.write();
+        if store_lock.is_err() {
+            warn!("Locking TM store failed");
+            continue;
+        }
+        let mut store_lock = store_lock.unwrap();
+        let pg = store_lock.read_with_guard(addr);
+        let read_res = pg.read();
+        if read_res.is_err() {
+            warn!("Error reading TM pool data");
+            continue;
+        }
+        let buf = read_res.unwrap();
+        if buf.len() > 9 {
+            let service = buf[7];
+            let subservice = buf[8];
+            info!("Sending PUS TM[{service},{subservice}]")
+        } else {
+            info!("Sending PUS TM");
+        }
+        let result = udp_tmtc_server.udp_tc_server.socket.send_to(buf, recv_addr);
+        if let Err(e) = result {
+            warn!("Sending TM with UDP socket failed: {e}")
+        }
+    }
+}
diff --git a/satrs-mib/CHANGELOG.md b/satrs-mib/CHANGELOG.md
new file mode 100644
index 0000000..68e54a2
--- /dev/null
+++ b/satrs-mib/CHANGELOG.md
@@ -0,0 +1,9 @@
+Change Log
+=======
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](http://keepachangelog.com/)
+and this project adheres to [Semantic Versioning](http://semver.org/).
+
+# [unreleased]
diff --git a/satrs-mib/Cargo.toml b/satrs-mib/Cargo.toml
new file mode 100644
index 0000000..e736fec
--- /dev/null
+++ b/satrs-mib/Cargo.toml
@@ -0,0 +1,27 @@
+[package]
+name = "satrs-mib"
+version = "0.1.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+serde-hex = "0.1.0"
+
+[dependencies.csv]
+version = "1"
+optional = true
+
+[dependencies.satrs-core]
+path = "../satrs-core"
+
+[dependencies.satrs-mib-codegen]
+path = "codegen"
+
+[dependencies.serde]
+version = "1"
+default-features = false
+
+[features]
+default = ["std"]
+std = ["csv", "serde/std"]
diff --git a/satrs-mib/LICENSE-APACHE b/satrs-mib/LICENSE-APACHE
new file mode 100644
index 0000000..16fe87b
--- /dev/null
+++ b/satrs-mib/LICENSE-APACHE
@@ -0,0 +1,201 @@
+                              Apache License
+                        Version 2.0, January 2004
+                     http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+   "License" shall mean the terms and conditions for use, reproduction,
+   and distribution as defined by Sections 1 through 9 of this document.
+
+   "Licensor" shall mean the copyright owner or entity authorized by
+   the copyright owner that is granting the License.
+
+   "Legal Entity" shall mean the union of the acting entity and all
+   other entities that control, are controlled by, or are under common
+   control with that entity. For the purposes of this definition,
+   "control" means (i) the power, direct or indirect, to cause the
+   direction or management of such entity, whether by contract or
+   otherwise, or (ii) ownership of fifty percent (50%) or more of the
+   outstanding shares, or (iii) beneficial ownership of such entity.
+
+   "You" (or "Your") shall mean an individual or Legal Entity
+   exercising permissions granted by this License.
+
+   "Source" form shall mean the preferred form for making modifications,
+   including but not limited to software source code, documentation
+   source, and configuration files.
+
+   "Object" form shall mean any form resulting from mechanical
+   transformation or translation of a Source form, including but
+   not limited to compiled object code, generated documentation,
+   and conversions to other media types.
+
+   "Work" shall mean the work of authorship, whether in Source or
+   Object form, made available under the License, as indicated by a
+   copyright notice that is included in or attached to the work
+   (an example is provided in the Appendix below).
+
+   "Derivative Works" shall mean any work, whether in Source or Object
+   form, that is based on (or derived from) the Work and for which the
+   editorial revisions, annotations, elaborations, or other modifications
+   represent, as a whole, an original work of authorship. For the purposes
+   of this License, Derivative Works shall not include works that remain
+   separable from, or merely link (or bind by name) to the interfaces of,
+   the Work and Derivative Works thereof.
+
+   "Contribution" shall mean any work of authorship, including
+   the original version of the Work and any modifications or additions
+   to that Work or Derivative Works thereof, that is intentionally
+   submitted to Licensor for inclusion in the Work by the copyright owner
+   or by an individual or Legal Entity authorized to submit on behalf of
+   the copyright owner. For the purposes of this definition, "submitted"
+   means any form of electronic, verbal, or written communication sent
+   to the Licensor or its representatives, including but not limited to
+   communication on electronic mailing lists, source code control systems,
+   and issue tracking systems that are managed by, or on behalf of, the
+   Licensor for the purpose of discussing and improving the Work, but
+   excluding communication that is conspicuously marked or otherwise
+   designated in writing by the copyright owner as "Not a Contribution."
+
+   "Contributor" shall mean Licensor and any individual or Legal Entity
+   on behalf of whom a Contribution has been received by Licensor and
+   subsequently incorporated within the Work.
+
+2. Grant of Copyright License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   copyright license to reproduce, prepare Derivative Works of,
+   publicly display, publicly perform, sublicense, and distribute the
+   Work and such Derivative Works in Source or Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   (except as stated in this section) patent license to make, have made,
+   use, offer to sell, sell, import, and otherwise transfer the Work,
+   where such license applies only to those patent claims licensable
+   by such Contributor that are necessarily infringed by their
+   Contribution(s) alone or by combination of their Contribution(s)
+   with the Work to which such Contribution(s) was submitted. If You
+   institute patent litigation against any entity (including a
+   cross-claim or counterclaim in a lawsuit) alleging that the Work
+   or a Contribution incorporated within the Work constitutes direct
+   or contributory patent infringement, then any patent licenses
+   granted to You under this License for that Work shall terminate
+   as of the date such litigation is filed.
+
+4. Redistribution. You may reproduce and distribute copies of the
+   Work or Derivative Works thereof in any medium, with or without
+   modifications, and in Source or Object form, provided that You
+   meet the following conditions:
+
+   (a) You must give any other recipients of the Work or
+       Derivative Works a copy of this License; and
+
+   (b) You must cause any modified files to carry prominent notices
+       stating that You changed the files; and
+
+   (c) You must retain, in the Source form of any Derivative Works
+       that You distribute, all copyright, patent, trademark, and
+       attribution notices from the Source form of the Work,
+       excluding those notices that do not pertain to any part of
+       the Derivative Works; and
+
+   (d) If the Work includes a "NOTICE" text file as part of its
+       distribution, then any Derivative Works that You distribute must
+       include a readable copy of the attribution notices contained
+       within such NOTICE file, excluding those notices that do not
+       pertain to any part of the Derivative Works, in at least one
+       of the following places: within a NOTICE text file distributed
+       as part of the Derivative Works; within the Source form or
+       documentation, if provided along with the Derivative Works; or,
+       within a display generated by the Derivative Works, if and
+       wherever such third-party notices normally appear. The contents
+       of the NOTICE file are for informational purposes only and
+       do not modify the License. You may add Your own attribution
+       notices within Derivative Works that You distribute, alongside
+       or as an addendum to the NOTICE text from the Work, provided
+       that such additional attribution notices cannot be construed
+       as modifying the License.
+
+   You may add Your own copyright statement to Your modifications and
+   may provide additional or different license terms and conditions
+   for use, reproduction, or distribution of Your modifications, or
+   for any such Derivative Works as a whole, provided Your use,
+   reproduction, and distribution of the Work otherwise complies with
+   the conditions stated in this License.
+
+5. Submission of Contributions. Unless You explicitly state otherwise,
+   any Contribution intentionally submitted for inclusion in the Work
+   by You to the Licensor shall be under the terms and conditions of
+   this License, without any additional terms or conditions.
+   Notwithstanding the above, nothing herein shall supersede or modify
+   the terms of any separate license agreement you may have executed
+   with Licensor regarding such Contributions.
+
+6. Trademarks. This License does not grant permission to use the trade
+   names, trademarks, service marks, or product names of the Licensor,
+   except as required for reasonable and customary use in describing the
+   origin of the Work and reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty. Unless required by applicable law or
+   agreed to in writing, Licensor provides the Work (and each
+   Contributor provides its Contributions) on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+   implied, including, without limitation, any warranties or conditions
+   of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+   PARTICULAR PURPOSE. You are solely responsible for determining the
+   appropriateness of using or redistributing the Work and assume any
+   risks associated with Your exercise of permissions under this License.
+
+8. Limitation of Liability. In no event and under no legal theory,
+   whether in tort (including negligence), contract, or otherwise,
+   unless required by applicable law (such as deliberate and grossly
+   negligent acts) or agreed to in writing, shall any Contributor be
+   liable to You for damages, including any direct, indirect, special,
+   incidental, or consequential damages of any character arising as a
+   result of this License or out of the use or inability to use the
+   Work (including but not limited to damages for loss of goodwill,
+   work stoppage, computer failure or malfunction, or any and all
+   other commercial damages or losses), even if such Contributor
+   has been advised of the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability. While redistributing
+   the Work or Derivative Works thereof, You may choose to offer,
+   and charge a fee for, acceptance of support, warranty, indemnity,
+   or other liability obligations and/or rights consistent with this
+   License. However, in accepting such obligations, You may act only
+   on Your own behalf and on Your sole responsibility, not on behalf
+   of any other Contributor, and only if You agree to indemnify,
+   defend, and hold each Contributor harmless for any liability
+   incurred by, or claims asserted against, such Contributor by reason
+   of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
+
+APPENDIX: How to apply the Apache License to your work.
+
+   To apply the Apache License to your work, attach the following
+   boilerplate notice, with the fields enclosed by brackets "[]"
+   replaced with your own identifying information. (Don't include
+   the brackets!)  The text should be enclosed in the appropriate
+   comment syntax for the file format. We also recommend that a
+   file or class name and description of purpose be included on the
+   same "printed page" as the copyright notice for easier
+   identification within third-party archives.
+
+Copyright [yyyy] [name of copyright owner]
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+	http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
diff --git a/satrs-mib/NOTICE b/satrs-mib/NOTICE
new file mode 100644
index 0000000..717a583
--- /dev/null
+++ b/satrs-mib/NOTICE
@@ -0,0 +1 @@
+This software contains code developed at the University of Stuttgart's Institute of Space Systems.
diff --git a/satrs-mib/README.md b/satrs-mib/README.md
new file mode 100644
index 0000000..ac5a5b4
--- /dev/null
+++ b/satrs-mib/README.md
@@ -0,0 +1,2 @@
+satrs-mib
+=========
diff --git a/satrs-mib/codegen/Cargo.toml b/satrs-mib/codegen/Cargo.toml
new file mode 100644
index 0000000..26d7409
--- /dev/null
+++ b/satrs-mib/codegen/Cargo.toml
@@ -0,0 +1,29 @@
+[package]
+name = "satrs-mib-codegen"
+version = "0.1.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+[lib]
+proc-macro = true
+
+[[test]]
+name = "tests"
+path = "tests/tests.rs"
+
+[dependencies]
+quote = "1"
+proc-macro2 = "1"
+
+[dependencies.satrs-core]
+path = "../../satrs-core"
+
+[dev-dependencies]
+trybuild = { version = "1", features = ["diff"] }
+
+[dev-dependencies.satrs-mib]
+path = ".."
+
+[dependencies.syn]
+version = "2"
+features = ["full"]
diff --git a/satrs-mib/codegen/src/lib.rs b/satrs-mib/codegen/src/lib.rs
new file mode 100644
index 0000000..906bc1a
--- /dev/null
+++ b/satrs-mib/codegen/src/lib.rs
@@ -0,0 +1,42 @@
+use quote::{format_ident, quote, ToTokens};
+use syn::{parse_macro_input, ItemConst, LitStr};
+
+#[proc_macro_attribute]
+pub fn resultcode(
+    args: proc_macro::TokenStream,
+    item: proc_macro::TokenStream,
+) -> proc_macro::TokenStream {
+    // Handle attributes first.
+    let mut info_str: Option<LitStr> = None;
+    let res_code_parser = syn::meta::parser(|meta| {
+        if meta.path.is_ident("info") {
+            info_str = Some(meta.value()?.parse()?);
+            Ok(())
+        } else {
+            Err(meta.error("unsupported property for resultcode attribute"))
+        }
+    });
+    parse_macro_input!(args with res_code_parser);
+    let item = parse_macro_input!(item as ItemConst);
+
+    // Generate additional generated info struct used for introspection.
+    let result_code_name = &item.ident;
+    let name_as_str = result_code_name.to_string();
+    let gen_struct_name = format_ident!("{}_EXT", result_code_name);
+    let info_str = info_str.map_or(String::from(""), |v| v.value());
+    // TODO: Group string
+    let generated_struct = quote! {
+        const #gen_struct_name: satrs_mib::res_code::ResultU16Info =
+            satrs_mib::res_code::ResultU16Info::const_new(
+                #name_as_str,
+                &#result_code_name,
+                "",
+                #info_str
+            );
+    };
+
+    // The input constant returncode is written to the output in any case.
+    let mut output = item.to_token_stream();
+    output.extend(generated_struct);
+    output.into()
+}
diff --git a/satrs-mib/codegen/tests/basic.rs b/satrs-mib/codegen/tests/basic.rs
new file mode 100644
index 0000000..d4cf1ab
--- /dev/null
+++ b/satrs-mib/codegen/tests/basic.rs
@@ -0,0 +1,8 @@
+//! Basic check which just verifies that everything compiles
+use satrs_core::res_code::ResultU16;
+use satrs_mib::resultcode;
+
+#[resultcode]
+const _TEST_RESULT: ResultU16 = ResultU16::const_new(0, 1);
+
+fn main() {}
diff --git a/satrs-mib/codegen/tests/basic_with_info.rs b/satrs-mib/codegen/tests/basic_with_info.rs
new file mode 100644
index 0000000..2030920
--- /dev/null
+++ b/satrs-mib/codegen/tests/basic_with_info.rs
@@ -0,0 +1,8 @@
+//! Basic check which just verifies that everything compiles
+use satrs_core::res_code::ResultU16;
+use satrs_mib::resultcode;
+
+#[resultcode(info = "This is a test result where the first parameter is foo")]
+const _TEST_RESULT: ResultU16 = ResultU16::const_new(0, 1);
+
+fn main() {}
diff --git a/satrs-mib/codegen/tests/tests.rs b/satrs-mib/codegen/tests/tests.rs
new file mode 100644
index 0000000..f5bd36c
--- /dev/null
+++ b/satrs-mib/codegen/tests/tests.rs
@@ -0,0 +1,8 @@
+#[test]
+fn tests() {
+    let t = trybuild::TestCases::new();
+    t.pass("tests/basic.rs");
+    t.pass("tests/basic_with_info.rs");
+    t.pass("tests/verify_gen_struct.rs");
+    //t.pass("tests/group_in_enum.rs");
+}
diff --git a/satrs-mib/codegen/tests/verify_gen_struct.rs b/satrs-mib/codegen/tests/verify_gen_struct.rs
new file mode 100644
index 0000000..ccd40e8
--- /dev/null
+++ b/satrs-mib/codegen/tests/verify_gen_struct.rs
@@ -0,0 +1,18 @@
+use satrs_core::res_code::ResultU16;
+use satrs_mib::res_code::ResultU16Info;
+use satrs_mib::resultcode;
+
+#[resultcode(info = "This is a test result where the first parameter is foo")]
+const TEST_RESULT: ResultU16 = ResultU16::const_new(0, 1);
+// Create named reference of auto-generated struct, which can be used by IDEs etc.
+const TEST_RESULT_EXT_REF: &ResultU16Info = &TEST_RESULT_EXT;
+
+fn main() {
+    assert_eq!(TEST_RESULT_EXT.name, "TEST_RESULT");
+    assert_eq!(TEST_RESULT_EXT.result, &TEST_RESULT);
+    assert_eq!(
+        TEST_RESULT_EXT.info,
+        "This is a test result where the first parameter is foo"
+    );
+    assert_eq!(TEST_RESULT_EXT_REF.name, "TEST_RESULT");
+}
diff --git a/satrs-mib/src/lib.rs b/satrs-mib/src/lib.rs
new file mode 100644
index 0000000..d2ba843
--- /dev/null
+++ b/satrs-mib/src/lib.rs
@@ -0,0 +1,8 @@
+#![no_std]
+#[cfg(feature = "alloc")]
+extern crate alloc;
+#[cfg(any(feature = "std", test))]
+extern crate std;
+
+pub use satrs_mib_codegen::*;
+pub mod res_code;
diff --git a/satrs-mib/src/res_code.rs b/satrs-mib/src/res_code.rs
new file mode 100644
index 0000000..39fa90f
--- /dev/null
+++ b/satrs-mib/src/res_code.rs
@@ -0,0 +1,168 @@
+#[cfg(feature = "std")]
+pub use stdmod::*;
+
+pub use satrs_core::res_code::ResultU16;
+
+use serde::{Deserialize, Serialize};
+use serde_hex::{SerHex, StrictCapPfx};
+#[derive(Debug, Copy, Clone, Serialize)]
+pub struct ResultU16Info {
+    pub name: &'static str,
+    pub result: &'static ResultU16,
+    pub group_str: &'static str,
+    pub info: &'static str,
+}
+
+impl ResultU16Info {
+    pub const fn const_new(
+        name: &'static str,
+        result: &'static ResultU16,
+        group_str: &'static str,
+        info: &'static str,
+    ) -> Self {
+        Self {
+            name,
+            result,
+            group_str,
+            info,
+        }
+    }
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct ResultU16InfoSerializable {
+    #[serde(with = "SerHex::<StrictCapPfx>")]
+    raw: u16,
+    #[serde(with = "SerHex::<StrictCapPfx>")]
+    group_id: u8,
+    #[serde(with = "SerHex::<StrictCapPfx>")]
+    unique_id: u8,
+    name: &'static str,
+    group_str: &'static str,
+    info: &'static str,
+}
+
+impl From<ResultU16Info> for ResultU16InfoSerializable {
+    fn from(v: ResultU16Info) -> Self {
+        Self {
+            raw: v.result.raw(),
+            group_id: v.result.group_id(),
+            unique_id: v.result.unique_id(),
+            name: v.name,
+            group_str: v.group_str,
+            info: v.info,
+        }
+    }
+}
+
+#[cfg(feature = "std")]
+pub mod stdmod {
+    use super::*;
+    use std::fs::File;
+    use std::io;
+
+    pub fn print_resultcodes_as_csv(
+        writer_builder: csv::WriterBuilder,
+        codes: &[ResultU16Info],
+    ) -> Result<(), csv::Error> {
+        let mut wtr = writer_builder.from_writer(io::stdout());
+        for result in codes {
+            wtr.serialize(ResultU16InfoSerializable::from(*result))?;
+        }
+        wtr.flush()?;
+        Ok(())
+    }
+
+    pub fn write_resultcodes_to_csv(
+        writer_builder: csv::WriterBuilder,
+        results: &[ResultU16Info],
+        file: File,
+    ) -> Result<(), csv::Error> {
+        let mut wtr = writer_builder.from_writer(file);
+        for result_code in results {
+            wtr.serialize(ResultU16InfoSerializable::from(*result_code))?;
+        }
+        wtr.flush()?;
+        Ok(())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::fs::File;
+    use std::io::{BufRead, BufReader};
+    use std::path::Path;
+    // Special solution for this crate because the code generated by a macro will use
+    // satrs_mib::res_code::*
+    use crate as satrs_mib;
+    use satrs_core::res_code::ResultU16;
+    use satrs_mib::resultcode;
+
+    #[derive(Debug)]
+    #[allow(dead_code)]
+    pub enum GroupId {
+        Tmtc = 0,
+    }
+
+    #[resultcode]
+    pub const INVALID_PUS_SERVICE: ResultU16 = ResultU16::const_new(GroupId::Tmtc as u8, 0);
+    #[resultcode]
+    pub const INVALID_PUS_SUBSERVICE: ResultU16 = ResultU16::const_new(GroupId::Tmtc as u8, 1);
+
+    #[resultcode(info = "Not enough data inside the TC application data field")]
+    pub const NOT_ENOUGH_APP_DATA: ResultU16 = ResultU16::const_new(GroupId::Tmtc as u8, 2);
+
+    pub const TMTC_RESULTS: &[ResultU16Info] = &[
+        INVALID_PUS_SERVICE_EXT,
+        INVALID_PUS_SUBSERVICE_EXT,
+        NOT_ENOUGH_APP_DATA_EXT,
+    ];
+
+    const CSV_NAME: &'static str = "dummy.csv";
+
+    #[test]
+    fn test_printout() {
+        let mut wtrb = csv::WriterBuilder::new();
+        wtrb.delimiter(';' as u8);
+        print_resultcodes_as_csv(wtrb, TMTC_RESULTS).expect("Priting result codes failed");
+    }
+
+    #[test]
+    fn test_csv_export() {
+        let csvpath = Path::new(CSV_NAME);
+        let mut wtrb = csv::WriterBuilder::new();
+        let file = File::create(csvpath).expect("Creating CSV file failed");
+        wtrb.delimiter(';' as u8);
+        write_resultcodes_to_csv(wtrb, TMTC_RESULTS, file).expect("CSV export failed");
+        assert!(csvpath.exists());
+        let file = File::open(csvpath).expect("Opening CSV file failed");
+        let buf_reader = BufReader::new(file);
+        for (idx, line) in buf_reader.lines().enumerate() {
+            match idx {
+                0 => {
+                    assert!(line.is_ok());
+                    let line = line.unwrap();
+                    assert_eq!(line, "raw;group_id;unique_id;name;group_str;info");
+                }
+                1 => {
+                    assert!(line.is_ok());
+                    let line = line.unwrap();
+                    assert_eq!(line, "0x0000;0x00;0x00;INVALID_PUS_SERVICE;;");
+                }
+                2 => {
+                    assert!(line.is_ok());
+                    let line = line.unwrap();
+                    assert_eq!(line, "0x0001;0x00;0x01;INVALID_PUS_SUBSERVICE;;");
+                }
+                3 => {
+                    assert!(line.is_ok());
+                    let line = line.unwrap();
+                    assert_eq!(line, "0x0002;0x00;0x02;NOT_ENOUGH_APP_DATA;;Not enough data inside the TC application data field");
+                }
+                _ => (),
+            }
+        }
+        std::fs::remove_file(Path::new("dummy.csv")).expect("Removing dummy csv failed");
+    }
+}
diff --git a/spacepackets b/spacepackets
deleted file mode 160000
index 94489da..0000000
--- a/spacepackets
+++ /dev/null
@@ -1 +0,0 @@
-Subproject commit 94489da00323dc6caf24e05e240c80fc10b5d8cc