From fe363d29627851f87f8a5be99ffef4848e97baa6 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 23 Oct 2022 22:32:30 +0200
Subject: [PATCH 01/40] some experimental eventcode

---
 fsrc-core/src/events.rs       |  3 +-
 fsrc-core/tests/pus_events.rs | 62 +++++++++++++++++++++++++++++++++++
 2 files changed, 63 insertions(+), 2 deletions(-)

diff --git a/fsrc-core/src/events.rs b/fsrc-core/src/events.rs
index fc9c66f..2934d1f 100644
--- a/fsrc-core/src/events.rs
+++ b/fsrc-core/src/events.rs
@@ -200,8 +200,7 @@ impl Event {
         })
     }
 
-    /// Const version of [new], but panics on invalid input which is invalid group ID
-    /// values
+    /// Const version of [new], but panics on invalid group ID input values.
     pub const fn const_new(
         severity: Severity,
         group_id: <Self as EventProvider>::GroupId,
diff --git a/fsrc-core/tests/pus_events.rs b/fsrc-core/tests/pus_events.rs
index 8b13789..2f554c1 100644
--- a/fsrc-core/tests/pus_events.rs
+++ b/fsrc-core/tests/pus_events.rs
@@ -1 +1,63 @@
+#![allow(dead_code, unused_imports)]
+use fsrc_core::events::{Event, EventProvider, LargestEventRaw, LargestGroupIdRaw, Severity};
 
+struct GroupIdIntrospection {
+    name: &'static str,
+    id: LargestGroupIdRaw,
+}
+
+struct EventIntrospection {
+    name: &'static str,
+    group_id: GroupIdIntrospection,
+    event: &'static Event,
+    info: &'static str,
+}
+
+//#[event(descr="This is some info event")]
+const INFO_EVENT_0: Event = Event::const_new(Severity::INFO, 0, 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,
+    info: "This is some info event",
+};
+
+//#[event(descr="This is some low severity event")]
+const SOME_LOW_SEV_EVENT: Event = Event::const_new(Severity::LOW, 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: &'static str = "TEST_GROUP_NAME";
+
+//#[event(desc="Some medium severity event")]
+const MEDIUM_SEV_EVENT_IN_OTHER_GROUP: Event =
+    Event::const_new(Severity::MEDIUM, TEST_GROUP_NAME, 0);
+
+// 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,
+    info: "Some medium severity event",
+};
+
+#[test]
+fn main() {
+    let test = stringify!(INFO_EVENT);
+    println!("{:?}", test);
+    for event in EVENT_LIST {
+        println!("{:?}", event);
+    }
+    //let test_struct =
+}

From 6fe373836457e5f96bf01e6a91325c267cfc6ef2 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 23 Oct 2022 23:15:11 +0200
Subject: [PATCH 02/40] that seems to work

---
 fsrc-core/src/events.rs        |  2 +-
 fsrc-core/src/pus/event_man.rs | 25 ++++++++++++++++++++++++-
 2 files changed, 25 insertions(+), 2 deletions(-)

diff --git a/fsrc-core/src/events.rs b/fsrc-core/src/events.rs
index 2934d1f..a74cb01 100644
--- a/fsrc-core/src/events.rs
+++ b/fsrc-core/src/events.rs
@@ -18,7 +18,7 @@ pub enum Severity {
     HIGH = 3,
 }
 
-pub trait EventProvider: PartialEq + Eq + Copy + Clone + Hash {
+pub trait EventProvider: EcssEnumeration + PartialEq + Eq + Copy + Clone + Hash {
     type Raw;
     type GroupId;
     type UniqueId;
diff --git a/fsrc-core/src/pus/event_man.rs b/fsrc-core/src/pus/event_man.rs
index 2e33618..8195b04 100644
--- a/fsrc-core/src/pus/event_man.rs
+++ b/fsrc-core/src/pus/event_man.rs
@@ -1,6 +1,9 @@
 use crate::events::EventProvider;
+use alloc::boxed::Box;
 use hashbrown::HashSet;
 
+use crate::pus::event::EventReporter;
+use crate::pus::{EcssTmError, EcssTmSender};
 #[cfg(feature = "heapless")]
 pub use heapless_mod::*;
 
@@ -84,4 +87,24 @@ pub mod heapless_mod {
     }
 }
 
-pub struct PusEventManager {}
+pub struct PusEventManager<BackendError, Provider: EventProvider> {
+    reporter: EventReporter,
+    backend: Box<dyn PusEventMgmtBackendProvider<Provider, Error = BackendError>>,
+}
+
+impl<BackendError, Provider: EventProvider> PusEventManager<BackendError, Provider> {
+    pub fn handle_event<E>(
+        &mut self,
+        sender: &mut (impl EcssTmSender<E> + ?Sized),
+        time_stamp: &[u8],
+        event: Provider,
+        aux_data: Option<&[u8]>,
+    ) -> Result<bool, EcssTmError<E>> {
+        if !self.backend.event_enabled(&event) {
+            return Ok(false);
+        }
+        self.reporter
+            .event_info(sender, time_stamp, event, aux_data)
+            .map(|_| true)
+    }
+}

From 478673327b98193c787e3bfbe0a6742f801714a5 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 24 Oct 2022 01:51:33 +0200
Subject: [PATCH 03/40] basic PUS event manager

---
 fsrc-core/src/event_man.rs     |  80 +++++----
 fsrc-core/src/events.rs        | 309 ++++++++++++++++++++++++++-------
 fsrc-core/src/pus/event.rs     |  14 +-
 fsrc-core/src/pus/event_man.rs |  83 +++++++--
 fsrc-core/tests/pus_events.rs  |  50 +++---
 5 files changed, 385 insertions(+), 151 deletions(-)

diff --git a/fsrc-core/src/event_man.rs b/fsrc-core/src/event_man.rs
index 4fe4092..5d1c6ba 100644
--- a/fsrc-core/src/event_man.rs
+++ b/fsrc-core/src/event_man.rs
@@ -1,5 +1,5 @@
 //! [Event][crate::events::Event] management and forwarding
-use crate::events::{Event, EventProvider, EventSmall};
+use crate::events::{EventU16TypedSev, EventU32, GenericEvent, HasSeverity};
 use alloc::boxed::Box;
 use alloc::vec;
 use alloc::vec::Vec;
@@ -11,34 +11,34 @@ enum ListenerType {
     Group(u16),
 }
 
-pub trait EventListener<Provider: EventProvider = Event> {
+pub trait EventListener<Provider: GenericEvent> {
     type Error;
 
     fn id(&self) -> u32;
     fn send_to(&mut self, event: Provider) -> Result<(), Self::Error>;
 }
 
-struct Listener<E, Provider: EventProvider = Event> {
+struct Listener<E, Provider: GenericEvent> {
     ltype: ListenerType,
     dest: Box<dyn EventListener<Provider, Error = E>>,
 }
 
-pub trait ReceivesAllEvent<Provider: EventProvider = Event> {
+pub trait ReceivesAllEvent<Provider: GenericEvent> {
     fn receive(&mut self) -> Option<Provider>;
 }
 
-pub struct EventManager<E, Provider: EventProvider = Event> {
+pub struct EventManager<E, Provider: GenericEvent> {
     listeners: HashMap<ListenerType, Vec<Listener<E, Provider>>>,
     event_receiver: Box<dyn ReceivesAllEvent<Provider>>,
 }
 
-pub enum HandlerResult<Provider: EventProvider = Event> {
+pub enum HandlerResult<Provider: GenericEvent> {
     Empty,
     Handled(u32, Provider),
 }
 
-impl<E> EventManager<E, Event> {
-    pub fn new(event_receiver: Box<dyn ReceivesAllEvent<Event>>) -> Self {
+impl<E> EventManager<E, EventU32> {
+    pub fn new(event_receiver: Box<dyn ReceivesAllEvent<EventU32>>) -> Self {
         EventManager {
             listeners: HashMap::new(),
             event_receiver,
@@ -46,43 +46,43 @@ impl<E> EventManager<E, Event> {
     }
 }
 
-impl<E> EventManager<E, Event> {
+impl<E> EventManager<E, EventU32> {
     pub fn subscribe_single(
         &mut self,
-        event: Event,
-        dest: impl EventListener<Event, Error = E> + 'static,
+        event: EventU32,
+        dest: impl EventListener<EventU32, Error = E> + 'static,
     ) {
         self.update_listeners(ListenerType::Single(event.raw_as_largest_type()), dest);
     }
 
     pub fn subscribe_group(
         &mut self,
-        group_id: <Event as EventProvider>::GroupId,
-        dest: impl EventListener<Event, Error = E> + 'static,
+        group_id: <EventU32 as GenericEvent>::GroupId,
+        dest: impl EventListener<EventU32, Error = E> + 'static,
     ) {
         self.update_listeners(ListenerType::Group(group_id), dest);
     }
 }
 
-impl<E> EventManager<E, EventSmall> {
+impl<E, SEVERITY: HasSeverity + Copy> EventManager<E, EventU16TypedSev<SEVERITY>> {
     pub fn subscribe_single(
         &mut self,
-        event: EventSmall,
-        dest: impl EventListener<EventSmall, Error = E> + 'static,
+        event: EventU16TypedSev<SEVERITY>,
+        dest: impl EventListener<EventU16TypedSev<SEVERITY>, Error = E> + 'static,
     ) {
         self.update_listeners(ListenerType::Single(event.raw_as_largest_type()), dest);
     }
 
     pub fn subscribe_group(
         &mut self,
-        group_id: <EventSmall as EventProvider>::GroupId,
-        dest: impl EventListener<EventSmall, Error = E> + 'static,
+        group_id: <EventU16TypedSev<SEVERITY> as GenericEvent>::GroupId,
+        dest: impl EventListener<EventU16TypedSev<SEVERITY>, Error = E> + 'static,
     ) {
         self.update_listeners(ListenerType::Group(group_id.into()), dest);
     }
 }
 
-impl<E, Provider: EventProvider> EventManager<E, Provider> {
+impl<E, Provider: GenericEvent + Copy> EventManager<E, Provider> {
     fn update_listeners(
         &mut self,
         key: ListenerType,
@@ -145,17 +145,17 @@ impl<E, Provider: EventProvider> EventManager<E, Provider> {
 mod tests {
     use super::{EventListener, HandlerResult, ReceivesAllEvent};
     use crate::event_man::EventManager;
-    use crate::events::{Event, EventProvider, Severity};
+    use crate::events::{EventU32, GenericEvent, 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>,
+        mpsc_receiver: Receiver<EventU32>,
     }
-    impl ReceivesAllEvent<Event> for EventReceiver {
-        fn receive(&mut self) -> Option<Event> {
+    impl ReceivesAllEvent<EventU32> for EventReceiver {
+        fn receive(&mut self) -> Option<EventU32> {
             self.mpsc_receiver.try_recv().ok()
         }
     }
@@ -163,21 +163,21 @@ mod tests {
     #[derive(Clone)]
     struct MpscEventSenderQueue {
         id: u32,
-        mpsc_sender: Sender<Event>,
+        mpsc_sender: Sender<EventU32>,
     }
 
-    impl EventListener<Event> for MpscEventSenderQueue {
-        type Error = SendError<Event>;
+    impl EventListener<EventU32> for MpscEventSenderQueue {
+        type Error = SendError<EventU32>;
 
         fn id(&self) -> u32 {
             self.id
         }
-        fn send_to(&mut self, event: Event) -> Result<(), Self::Error> {
+        fn send_to(&mut self, event: EventU32) -> Result<(), Self::Error> {
             self.mpsc_sender.send(event)
         }
     }
 
-    fn check_next_event(expected: Event, receiver: &Receiver<Event>) {
+    fn check_next_event(expected: EventU32, receiver: &Receiver<EventU32>) {
         for _ in 0..5 {
             if let Ok(event) = receiver.try_recv() {
                 assert_eq!(event, expected);
@@ -187,7 +187,11 @@ mod tests {
         }
     }
 
-    fn check_handled_event(res: HandlerResult, expected: Event, expected_num_sent: u32) {
+    fn check_handled_event(
+        res: HandlerResult<EventU32>,
+        expected: EventU32,
+        expected_num_sent: u32,
+    ) {
         assert!(matches!(res, HandlerResult::Handled { .. }));
         if let HandlerResult::Handled(num_recipients, event) = res {
             assert_eq!(event, expected);
@@ -201,10 +205,10 @@ mod tests {
         let event_man_receiver = EventReceiver {
             mpsc_receiver: manager_queue,
         };
-        let mut event_man: EventManager<SendError<Event>, Event> =
+        let mut event_man: EventManager<SendError<EventU32>, EventU32> =
             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 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 {
             id: 0,
@@ -244,15 +248,15 @@ mod tests {
         let event_man_receiver = EventReceiver {
             mpsc_receiver: manager_queue,
         };
-        let mut event_man: EventManager<SendError<Event>, Event> =
+        let mut event_man: EventManager<SendError<EventU32>, EventU32> =
             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 = 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,
@@ -286,10 +290,10 @@ mod tests {
         let event_man_receiver = EventReceiver {
             mpsc_receiver: manager_queue,
         };
-        let mut event_man: EventManager<SendError<Event>, Event> =
+        let mut event_man: EventManager<SendError<EventU32>, EventU32> =
             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 = 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 {
diff --git a/fsrc-core/src/events.rs b/fsrc-core/src/events.rs
index a74cb01..4a27cf0 100644
--- a/fsrc-core/src/events.rs
+++ b/fsrc-core/src/events.rs
@@ -1,6 +1,7 @@
 //! Event support module
 
 use core::hash::Hash;
+use delegate::delegate;
 use spacepackets::ecss::{EcssEnumeration, ToBeBytes};
 use spacepackets::{ByteConversionError, SizeMissmatch};
 use std::marker::PhantomData;
@@ -18,7 +19,34 @@ pub enum Severity {
     HIGH = 3,
 }
 
-pub trait EventProvider: EcssEnumeration + PartialEq + Eq + Copy + Clone + Hash {
+pub trait HasSeverity {
+    const SEVERITY: Severity;
+}
+#[derive(Debug, PartialEq, Eq)]
+pub struct SeverityInfo {}
+impl HasSeverity for SeverityInfo {
+    const SEVERITY: Severity = Severity::INFO;
+}
+
+#[derive(Debug, PartialEq, Eq)]
+pub struct SeverityLow {}
+impl HasSeverity for SeverityLow {
+    const SEVERITY: Severity = Severity::LOW;
+}
+
+#[derive(Debug, PartialEq, Eq)]
+pub struct SeverityMedium {}
+impl HasSeverity for SeverityMedium {
+    const SEVERITY: Severity = Severity::MEDIUM;
+}
+
+#[derive(Debug, PartialEq, Eq)]
+pub struct SeverityHigh {}
+impl HasSeverity for SeverityHigh {
+    const SEVERITY: Severity = Severity::HIGH;
+}
+
+pub trait GenericEvent: EcssEnumeration {
     type Raw;
     type GroupId;
     type UniqueId;
@@ -149,43 +177,78 @@ macro_rules! event_provider_impl {
         }
     };
 }
+
+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)
+            }
+        }
+    };
+}
+
 #[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
-pub struct Event {
+pub struct EventU32 {
     base: EventBase<u32, u16, u16>,
 }
 
-impl EventProvider for Event {
-    type Raw = u32;
-    type GroupId = u16;
-    type UniqueId = u16;
+#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
+pub struct EventU32TypedSev<SEVERITY> {
+    event: EventU32,
+    phantom: PhantomData<SEVERITY>,
+}
 
-    event_provider_impl!();
-
-    fn raw_as_largest_type(&self) -> LargestEventRaw {
-        self.raw()
-    }
-
-    fn group_id_as_largest_type(&self) -> LargestGroupIdRaw {
-        self.group_id()
+impl<SEVERITY: HasSeverity> From<EventU32TypedSev<SEVERITY>> for EventU32 {
+    fn from(e: EventU32TypedSev<SEVERITY>) -> Self {
+        Self { base: e.event.base }
     }
 }
 
-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 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
+impl_event_provider!(EventU32, EventU32TypedSev, u32, u16, u16);
+
+impl EventU32 {
     pub fn new(
         severity: Severity,
-        group_id: <Self as EventProvider>::GroupId,
-        unique_id: <Self as EventProvider>::UniqueId,
+        group_id: <Self as GenericEvent>::GroupId,
+        unique_id: <Self as GenericEvent>::UniqueId,
     ) -> Option<Self> {
         if group_id > (2u16.pow(14) - 1) {
             return None;
@@ -199,12 +262,10 @@ impl Event {
             },
         })
     }
-
-    /// Const version of [new], but panics on invalid group ID input values.
     pub const fn const_new(
         severity: Severity,
-        group_id: <Self as EventProvider>::GroupId,
-        unique_id: <Self as EventProvider>::UniqueId,
+        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");
@@ -220,7 +281,54 @@ impl Event {
     }
 }
 
-impl From<u32> for Event {
+impl<SEVERITY: HasSeverity> EventU32TypedSev<SEVERITY> {
+    /// 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(
+        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 [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();
@@ -231,7 +339,12 @@ impl From<u32> for Event {
     }
 }
 
-impl EcssEnumeration for Event {
+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 EcssEnumeration for EventU32 {
     fn pfc(&self) -> u8 {
         32
     }
@@ -241,12 +354,26 @@ impl EcssEnumeration for Event {
     }
 }
 
+//noinspection RsTraitImplementation
+impl<SEVERITY: HasSeverity> EcssEnumeration for EventU32TypedSev<SEVERITY> {
+    delegate!(to self.event {
+        fn pfc(&self) -> u8;
+        fn write_to_bytes(&self, buf: &mut [u8]) -> Result<(), ByteConversionError>;
+    });
+}
+
 #[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
-pub struct EventSmall {
+pub struct EventU16 {
     base: EventBase<u16, u8, u8>,
 }
 
-impl EventSmall {
+#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
+pub struct EventU16TypedSev<SEVERITY> {
+    event: EventU16,
+    phantom: PhantomData<SEVERITY>,
+}
+
+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
     ///
@@ -260,8 +387,8 @@ impl EventSmall {
     ///       raw event ID
     pub fn new(
         severity: Severity,
-        group_id: <Self as EventProvider>::GroupId,
-        unique_id: <Self as EventProvider>::UniqueId,
+        group_id: <Self as GenericEvent>::GroupId,
+        unique_id: <Self as GenericEvent>::UniqueId,
     ) -> Option<Self> {
         if group_id > (2u8.pow(6) - 1) {
             return None;
@@ -278,8 +405,8 @@ impl EventSmall {
 
     pub const fn const_new(
         severity: Severity,
-        group_id: <Self as EventProvider>::GroupId,
-        unique_id: <Self as EventProvider>::UniqueId,
+        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");
@@ -294,24 +421,55 @@ impl EventSmall {
         }
     }
 }
-
-impl EventProvider for EventSmall {
-    type Raw = u16;
-    type GroupId = u8;
-    type UniqueId = u8;
-
-    event_provider_impl!();
-
-    fn raw_as_largest_type(&self) -> LargestEventRaw {
-        self.raw().into()
+impl<SEVERITY: HasSeverity> EventU16TypedSev<SEVERITY> {
+    /// 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(
+        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,
+        })
     }
 
-    fn group_id_as_largest_type(&self) -> LargestGroupIdRaw {
-        self.group_id().into()
+    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 EcssEnumeration for EventSmall {
+impl_event_provider!(EventU16, EventU16TypedSev, u16, u8, u8);
+
+impl EcssEnumeration for EventU16 {
     fn pfc(&self) -> u8 {
         16
     }
@@ -321,8 +479,16 @@ impl EcssEnumeration for EventSmall {
     }
 }
 
-impl From<u16> for EventSmall {
-    fn from(raw: <Self as EventProvider>::Raw) -> Self {
+//noinspection RsTraitImplementation
+impl<SEVERITY: HasSeverity> EcssEnumeration for EventU16TypedSev<SEVERITY> {
+    delegate!(to self.event {
+        fn pfc(&self) -> u8;
+        fn write_to_bytes(&self, buf: &mut [u8]) -> Result<(), ByteConversionError>;
+    });
+}
+
+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;
@@ -331,10 +497,15 @@ impl From<u16> for EventSmall {
     }
 }
 
+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);
+
 #[cfg(test)]
 mod tests {
-    use super::Event;
-    use crate::events::{EventProvider, EventSmall, Severity};
+    use super::EventU32TypedSev;
+    use super::*;
     use spacepackets::ecss::EcssEnumeration;
     use spacepackets::ByteConversionError;
     use std::mem::size_of;
@@ -343,20 +514,24 @@ mod tests {
         assert_eq!(size_of::<T>(), val);
     }
 
-    const INFO_EVENT: Event = Event::const_new(Severity::INFO, 0, 0);
-    const INFO_EVENT_SMALL: EventSmall = EventSmall::const_new(Severity::INFO, 0, 0);
-    const HIGH_SEV_EVENT: Event = Event::const_new(Severity::HIGH, 0x3FFF, 0xFFFF);
-    const HIGH_SEV_EVENT_SMALL: EventSmall = EventSmall::const_new(Severity::HIGH, 0x3F, 0xff);
+    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);
 
     #[test]
     fn test_normal_from_raw_conversion() {
-        let conv_from_raw = Event::from(INFO_EVENT.raw());
+        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 = EventSmall::from(INFO_EVENT_SMALL.raw());
+        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);
     }
 
@@ -408,18 +583,18 @@ mod tests {
 
     #[test]
     fn invalid_group_id_normal() {
-        assert!(Event::new(Severity::MEDIUM, 2_u16.pow(14), 0).is_none());
+        assert!(EventU32TypedSev::<SeverityMedium>::new(2_u16.pow(14), 0).is_none());
     }
 
     #[test]
     fn invalid_group_id_small() {
-        assert!(EventSmall::new(Severity::MEDIUM, 2_u8.pow(6), 0).is_none());
+        assert!(EventU16TypedSev::<SeverityMedium>::new(2_u8.pow(6), 0).is_none());
     }
 
     #[test]
     fn regular_new() {
         assert_eq!(
-            Event::new(Severity::INFO, 0, 0).expect("Creating regular event failed"),
+            EventU32TypedSev::<SeverityInfo>::new(0, 0).expect("Creating regular event failed"),
             INFO_EVENT
         );
     }
@@ -427,7 +602,7 @@ mod tests {
     #[test]
     fn small_new() {
         assert_eq!(
-            EventSmall::new(Severity::INFO, 0, 0).expect("Creating regular event failed"),
+            EventU16TypedSev::<SeverityInfo>::new(0, 0).expect("Creating regular event failed"),
             INFO_EVENT_SMALL
         );
     }
diff --git a/fsrc-core/src/pus/event.rs b/fsrc-core/src/pus/event.rs
index bea74a4..bfc3fa0 100644
--- a/fsrc-core/src/pus/event.rs
+++ b/fsrc-core/src/pus/event.rs
@@ -255,7 +255,7 @@ mod allocvec {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::events::{Event, Severity};
+    use crate::events::{EventU32, Severity};
     use crate::pus::tests::CommonTmInfo;
     use spacepackets::ByteConversionError;
     use std::collections::VecDeque;
@@ -270,7 +270,7 @@ mod tests {
     #[derive(Debug, Eq, PartialEq)]
     struct TmInfo {
         pub common: CommonTmInfo,
-        pub event: Event,
+        pub event: EventU32,
         pub aux_data: Vec<u8>,
     }
 
@@ -284,9 +284,7 @@ mod tests {
             assert!(tm.source_data().is_some());
             let src_data = tm.source_data().unwrap();
             assert!(src_data.len() >= 4);
-            let event = Event::try_from(u32::from_be_bytes(src_data[0..4].try_into().unwrap()));
-            assert!(event.is_ok());
-            let event = event.unwrap();
+            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..]);
@@ -313,7 +311,7 @@ mod tests {
         reporter: &mut EventReporter,
         sender: &mut TestSender,
         time_stamp: &[u8],
-        event: Event,
+        event: EventU32,
         severity: Severity,
         aux_data: Option<&[u8]>,
     ) {
@@ -355,7 +353,7 @@ mod tests {
         if let Some(err_data) = error_data {
             error_copy.extend_from_slice(err_data);
         }
-        let event = Event::new(severity, EXAMPLE_GROUP_ID, EXAMPLE_EVENT_ID_0)
+        let event = EventU32::new(severity, EXAMPLE_GROUP_ID, EXAMPLE_EVENT_ID_0)
             .expect("Error creating example event");
         report_basic_event(
             &mut reporter,
@@ -418,7 +416,7 @@ mod tests {
         expected_found_len: usize,
     ) {
         let time_stamp_empty: [u8; 7] = [0; 7];
-        let event = Event::new(Severity::INFO, EXAMPLE_GROUP_ID, EXAMPLE_EVENT_ID_0)
+        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());
diff --git a/fsrc-core/src/pus/event_man.rs b/fsrc-core/src/pus/event_man.rs
index 8195b04..86581f6 100644
--- a/fsrc-core/src/pus/event_man.rs
+++ b/fsrc-core/src/pus/event_man.rs
@@ -1,5 +1,6 @@
-use crate::events::EventProvider;
+use crate::events::{EventU16TypedSev, EventU32TypedSev, GenericEvent, HasSeverity, Severity};
 use alloc::boxed::Box;
+use core::hash::Hash;
 use hashbrown::HashSet;
 
 use crate::pus::event::EventReporter;
@@ -17,7 +18,7 @@ pub use heapless_mod::*;
 /// 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: EventProvider> {
+pub trait PusEventMgmtBackendProvider<Provider: GenericEvent> {
     type Error;
 
     fn event_enabled(&self, event: &Provider) -> bool;
@@ -31,12 +32,12 @@ pub trait PusEventMgmtBackendProvider<Provider: EventProvider> {
 /// 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.
 #[derive(Default)]
-pub struct DefaultPusMgmtBackendProvider<Provider: EventProvider> {
+pub struct DefaultPusMgmtBackendProvider<Provider: GenericEvent> {
     disabled: HashSet<Provider>,
 }
 
-impl<Provider: EventProvider> PusEventMgmtBackendProvider<Provider>
-    for DefaultPusMgmtBackendProvider<Provider>
+impl<Provider: GenericEvent + PartialEq + Eq + Hash + Copy + Clone>
+    PusEventMgmtBackendProvider<Provider> for DefaultPusMgmtBackendProvider<Provider>
 {
     type Error = ();
     fn event_enabled(&self, event: &Provider) -> bool {
@@ -55,18 +56,18 @@ impl<Provider: EventProvider> PusEventMgmtBackendProvider<Provider>
 #[cfg(feature = "heapless")]
 pub mod heapless_mod {
     use super::*;
-    use crate::events::{EventProvider, LargestEventRaw};
+    use crate::events::{GenericEvent, LargestEventRaw};
     use std::marker::PhantomData;
 
     // 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 HeaplessPusMgmtBckendProvider<const N: usize, Provider: EventProvider> {
+    pub struct HeaplessPusMgmtBckendProvider<const N: usize, Provider: GenericEvent> {
         disabled: heapless::FnvIndexSet<LargestEventRaw, N>,
         phantom: PhantomData<Provider>,
     }
 
-    impl<const N: usize, Provider: EventProvider> PusEventMgmtBackendProvider<Provider>
+    impl<const N: usize, Provider: GenericEvent> PusEventMgmtBackendProvider<Provider>
         for HeaplessPusMgmtBckendProvider<N, Provider>
     {
         type Error = ();
@@ -87,24 +88,76 @@ pub mod heapless_mod {
     }
 }
 
-pub struct PusEventManager<BackendError, Provider: EventProvider> {
+pub struct PusEventManager<BackendError, Provider: GenericEvent> {
     reporter: EventReporter,
     backend: Box<dyn PusEventMgmtBackendProvider<Provider, Error = BackendError>>,
 }
 
-impl<BackendError, Provider: EventProvider> PusEventManager<BackendError, Provider> {
-    pub fn handle_event<E>(
+impl<BackendError, Event: GenericEvent> PusEventManager<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<E>(
         &mut self,
+        severity: Severity,
         sender: &mut (impl EcssTmSender<E> + ?Sized),
         time_stamp: &[u8],
-        event: Provider,
+        event: Event,
         aux_data: Option<&[u8]>,
     ) -> Result<bool, EcssTmError<E>> {
         if !self.backend.event_enabled(&event) {
             return Ok(false);
         }
-        self.reporter
-            .event_info(sender, time_stamp, event, aux_data)
-            .map(|_| true)
+        match severity {
+            Severity::INFO => self
+                .reporter
+                .event_info(sender, time_stamp, event, aux_data)
+                .map(|_| true),
+            Severity::LOW => self
+                .reporter
+                .event_low_severity(sender, time_stamp, event, aux_data)
+                .map(|_| true),
+            Severity::MEDIUM => self
+                .reporter
+                .event_medium_severity(sender, time_stamp, event, aux_data)
+                .map(|_| true),
+            Severity::HIGH => self
+                .reporter
+                .event_high_severity(sender, time_stamp, event, aux_data)
+                .map(|_| true),
+        }
+    }
+}
+
+impl<BackendError, SEVERITY: HasSeverity>
+    PusEventManager<BackendError, EventU32TypedSev<SEVERITY>>
+{
+    pub fn generate_pus_event_tm<E>(
+        &mut self,
+        sender: &mut (impl EcssTmSender<E> + ?Sized),
+        time_stamp: &[u8],
+        event: EventU32TypedSev<SEVERITY>,
+        aux_data: Option<&[u8]>,
+    ) -> Result<bool, EcssTmError<E>> {
+        self.generate_pus_event_tm_generic(SEVERITY::SEVERITY, sender, time_stamp, event, aux_data)
+    }
+}
+
+impl<BackendError, SEVERITY: HasSeverity>
+    PusEventManager<BackendError, EventU16TypedSev<SEVERITY>>
+{
+    pub fn generate_pus_event_tm<E>(
+        &mut self,
+        sender: &mut (impl EcssTmSender<E> + ?Sized),
+        time_stamp: &[u8],
+        event: EventU16TypedSev<SEVERITY>,
+        aux_data: Option<&[u8]>,
+    ) -> Result<bool, EcssTmError<E>> {
+        self.generate_pus_event_tm_generic(SEVERITY::SEVERITY, sender, time_stamp, event, aux_data)
     }
 }
diff --git a/fsrc-core/tests/pus_events.rs b/fsrc-core/tests/pus_events.rs
index 2f554c1..db82b52 100644
--- a/fsrc-core/tests/pus_events.rs
+++ b/fsrc-core/tests/pus_events.rs
@@ -1,23 +1,26 @@
 #![allow(dead_code, unused_imports)]
-use fsrc_core::events::{Event, EventProvider, LargestEventRaw, LargestGroupIdRaw, Severity};
+use fsrc_core::events::{
+    EventU32TypedSev, GenericEvent, HasSeverity, LargestEventRaw, LargestGroupIdRaw, Severity,
+    SeverityInfo, SeverityLow, SeverityMedium,
+};
 
 struct GroupIdIntrospection {
     name: &'static str,
     id: LargestGroupIdRaw,
 }
 
-struct EventIntrospection {
+struct EventIntrospection<SEVERITY: HasSeverity + 'static> {
     name: &'static str,
     group_id: GroupIdIntrospection,
-    event: &'static Event,
+    event: &'static EventU32TypedSev<SEVERITY>,
     info: &'static str,
 }
 
 //#[event(descr="This is some info event")]
-const INFO_EVENT_0: Event = Event::const_new(Severity::INFO, 0, 0);
+const INFO_EVENT_0: EventU32TypedSev<SeverityInfo> = EventU32TypedSev::const_new(0, 0);
 
 // This is ideally auto-generated
-const INFO_EVENT_0_INTROSPECTION: EventIntrospection = EventIntrospection {
+const INFO_EVENT_0_INTROSPECTION: EventIntrospection<SeverityInfo> = EventIntrospection {
     name: "INFO_EVENT_0",
     group_id: GroupIdIntrospection {
         id: 0,
@@ -28,9 +31,9 @@ const INFO_EVENT_0_INTROSPECTION: EventIntrospection = EventIntrospection {
 };
 
 //#[event(descr="This is some low severity event")]
-const SOME_LOW_SEV_EVENT: Event = Event::const_new(Severity::LOW, 0, 12);
+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];
+//const EVENT_LIST: [&'static Event; 2] = [&INFO_EVENT_0, &SOME_LOW_SEV_EVENT];
 
 //#[event_group]
 const TEST_GROUP_NAME: u16 = 1;
@@ -38,26 +41,27 @@ const TEST_GROUP_NAME: u16 = 1;
 const TEST_GROUP_NAME_NAME: &'static str = "TEST_GROUP_NAME";
 
 //#[event(desc="Some medium severity event")]
-const MEDIUM_SEV_EVENT_IN_OTHER_GROUP: Event =
-    Event::const_new(Severity::MEDIUM, TEST_GROUP_NAME, 0);
+const MEDIUM_SEV_EVENT_IN_OTHER_GROUP: EventU32TypedSev<SeverityMedium> =
+    EventU32TypedSev::const_new(TEST_GROUP_NAME, 0);
 
 // 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,
-    info: "Some medium severity event",
-};
+const MEDIUM_SEV_EVENT_IN_OTHER_GROUP_INTROSPECTION: EventIntrospection<SeverityMedium> =
+    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,
+        info: "Some medium severity event",
+    };
 
 #[test]
 fn main() {
-    let test = stringify!(INFO_EVENT);
-    println!("{:?}", test);
-    for event in EVENT_LIST {
-        println!("{:?}", event);
-    }
+    //let test = stringify!(INFO_EVENT);
+    //println!("{:?}", test);
+    //for event in EVENT_LIST {
+    //    println!("{:?}", event);
+    //}
     //let test_struct =
 }

From ac8718f1afcf3dd8ba353f696db7ecb86ca4bf3a Mon Sep 17 00:00:00 2001
From: Robin Mueller <muellerr@irs.uni-stuttgart.de>
Date: Mon, 24 Oct 2022 14:03:21 +0200
Subject: [PATCH 04/40] cool stuff

---
 fsrc-core/src/events.rs       | 11 ++++++++
 fsrc-core/tests/pus_events.rs | 47 +++++++++++++++++++++++++++--------
 2 files changed, 48 insertions(+), 10 deletions(-)

diff --git a/fsrc-core/src/events.rs b/fsrc-core/src/events.rs
index 4a27cf0..2523a2e 100644
--- a/fsrc-core/src/events.rs
+++ b/fsrc-core/src/events.rs
@@ -279,6 +279,17 @@ impl EventU32 {
             },
         }
     }
+
+    pub const fn const_from_info(event: EventU32TypedSev<SeverityInfo>) -> Self {
+        Self {
+            base: event.event.base
+        }
+    }
+    pub const fn const_from_medium(event: EventU32TypedSev<SeverityMedium>) -> Self {
+        Self {
+            base: event.event.base
+        }
+    }
 }
 
 impl<SEVERITY: HasSeverity> EventU32TypedSev<SEVERITY> {
diff --git a/fsrc-core/tests/pus_events.rs b/fsrc-core/tests/pus_events.rs
index db82b52..f0edbe2 100644
--- a/fsrc-core/tests/pus_events.rs
+++ b/fsrc-core/tests/pus_events.rs
@@ -1,32 +1,34 @@
 #![allow(dead_code, unused_imports)]
-use fsrc_core::events::{
-    EventU32TypedSev, GenericEvent, HasSeverity, LargestEventRaw, LargestGroupIdRaw, Severity,
-    SeverityInfo, SeverityLow, SeverityMedium,
-};
 
+use std::convert::AsRef;
+use fsrc_core::events::{EventU32, EventU32TypedSev, GenericEvent, HasSeverity, LargestEventRaw, LargestGroupIdRaw, Severity, SeverityInfo, SeverityLow, SeverityMedium};
+
+#[derive(Debug)]
 struct GroupIdIntrospection {
     name: &'static str,
     id: LargestGroupIdRaw,
 }
 
-struct EventIntrospection<SEVERITY: HasSeverity + 'static> {
+#[derive(Debug)]
+struct EventIntrospection {
     name: &'static str,
     group_id: GroupIdIntrospection,
-    event: &'static EventU32TypedSev<SEVERITY>,
+    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<SeverityInfo> = EventIntrospection {
+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,
+    event: &INFO_EVENT_0_ERASED,
     info: "This is some info event",
 };
 
@@ -43,19 +45,38 @@ const TEST_GROUP_NAME_NAME: &'static 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<SeverityMedium> =
+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,
+        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: [&'static 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: [&'static EventIntrospection; 1] = [
+    &MEDIUM_SEV_EVENT_IN_OTHER_GROUP_INTROSPECTION
+];
+const BLAH: &'static [&EventIntrospection] = &INTROSPECTION_FOR_TEST_GROUP_NAME;
+
+const ALL_EVENTS: [&'static [&EventIntrospection]; 2] = [
+    INTROSPECTION_FOR_TABLE,
+    BLAH
+];
+
 #[test]
 fn main() {
     //let test = stringify!(INFO_EVENT);
@@ -63,5 +84,11 @@ fn main() {
     //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 =
 }

From d93dd92fda2c714c5c65d262411899bf620fc85d Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 25 Oct 2022 23:32:12 +0200
Subject: [PATCH 05/40] completion and fixes

---
 fsrc-core/src/events.rs       | 46 +++++++++++++++++++++++++++--------
 fsrc-core/tests/pus_events.rs | 16 ++++++------
 2 files changed, 44 insertions(+), 18 deletions(-)

diff --git a/fsrc-core/src/events.rs b/fsrc-core/src/events.rs
index 2523a2e..12d71a4 100644
--- a/fsrc-core/src/events.rs
+++ b/fsrc-core/src/events.rs
@@ -225,6 +225,16 @@ macro_rules! try_from_impls {
     };
 }
 
+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>,
@@ -280,16 +290,10 @@ impl EventU32 {
         }
     }
 
-    pub const fn const_from_info(event: EventU32TypedSev<SeverityInfo>) -> Self {
-        Self {
-            base: event.event.base
-        }
-    }
-    pub const fn const_from_medium(event: EventU32TypedSev<SeverityMedium>) -> Self {
-        Self {
-            base: event.event.base
-        }
-    }
+    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> {
@@ -431,6 +435,10 @@ impl EventU16 {
             },
         }
     }
+    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> {
     /// Generate a small event. The raw representation of a small event has 16 bits.
@@ -532,6 +540,9 @@ mod tests {
     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())
@@ -693,4 +704,19 @@ mod tests {
         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/tests/pus_events.rs b/fsrc-core/tests/pus_events.rs
index f0edbe2..cb7e1e1 100644
--- a/fsrc-core/tests/pus_events.rs
+++ b/fsrc-core/tests/pus_events.rs
@@ -40,7 +40,7 @@ const SOME_LOW_SEV_EVENT: EventU32TypedSev<SeverityLow> = EventU32TypedSev::cons
 //#[event_group]
 const TEST_GROUP_NAME: u16 = 1;
 // Auto-generated?
-const TEST_GROUP_NAME_NAME: &'static str = "TEST_GROUP_NAME";
+const TEST_GROUP_NAME_NAME: &str = "TEST_GROUP_NAME";
 
 //#[event(desc="Some medium severity event")]
 const MEDIUM_SEV_EVENT_IN_OTHER_GROUP: EventU32TypedSev<SeverityMedium> =
@@ -60,21 +60,21 @@ const MEDIUM_SEV_EVENT_IN_OTHER_GROUP_INTROSPECTION: EventIntrospection =
     };
 
 const CONST_SLICE: &'static [u8] = &[0, 1, 2, 3];
-const INTROSPECTION_FOR_TEST_GROUP_0: [&'static EventIntrospection; 2] = [
+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_TABLE: &'static [&EventIntrospection] = &INTROSPECTION_FOR_TEST_GROUP_0;
 
-const INTROSPECTION_FOR_TEST_GROUP_NAME: [&'static EventIntrospection; 1] = [
+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 BLAH: &'static [&EventIntrospection] = &INTROSPECTION_FOR_TEST_GROUP_NAME;
 
-const ALL_EVENTS: [&'static [&EventIntrospection]; 2] = [
-    INTROSPECTION_FOR_TABLE,
-    BLAH
+const ALL_EVENTS: [&[&EventIntrospection]; 2] = [
+    &INTROSPECTION_FOR_TEST_GROUP_0,
+    &INTROSPECTION_FOR_TEST_GROUP_NAME
 ];
 
 #[test]

From 18a3be84393ceffad31055cb70455dfc22f732d3 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 25 Oct 2022 23:38:45 +0200
Subject: [PATCH 06/40] cargo doc

---
 fsrc-core/src/events.rs       | 45 ++++++++++++++++-------------------
 fsrc-core/tests/pus_events.rs | 40 +++++++++++++++----------------
 2 files changed, 41 insertions(+), 44 deletions(-)

diff --git a/fsrc-core/src/events.rs b/fsrc-core/src/events.rs
index 12d71a4..b2dbec8 100644
--- a/fsrc-core/src/events.rs
+++ b/fsrc-core/src/events.rs
@@ -22,6 +22,7 @@ pub enum Severity {
 pub trait HasSeverity {
     const SEVERITY: Severity;
 }
+
 #[derive(Debug, PartialEq, Eq)]
 pub struct SeverityInfo {}
 impl HasSeverity for SeverityInfo {
@@ -229,10 +230,10 @@ 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
+                base: event.event.base,
             }
         }
-    }
+    };
 }
 
 #[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
@@ -255,6 +256,17 @@ impl<SEVERITY: HasSeverity> From<EventU32TypedSev<SEVERITY>> for EventU32 {
 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,
@@ -297,17 +309,8 @@ impl EventU32 {
 }
 
 impl<SEVERITY: HasSeverity> EventU32TypedSev<SEVERITY> {
-    /// 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
+    /// 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,
@@ -418,6 +421,7 @@ impl EventU16 {
         })
     }
 
+    /// Const version of [new], but panics on invalid group ID input values.
     pub const fn const_new(
         severity: Severity,
         group_id: <Self as GenericEvent>::GroupId,
@@ -440,18 +444,10 @@ impl EventU16 {
     const_from_fn!(const_from_medium, EventU16TypedSev, SeverityMedium);
     const_from_fn!(const_from_high, EventU16TypedSev, SeverityHigh);
 }
+
 impl<SEVERITY: HasSeverity> EventU16TypedSev<SEVERITY> {
-    /// 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
+    /// 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,
@@ -463,6 +459,7 @@ impl<SEVERITY: HasSeverity> EventU16TypedSev<SEVERITY> {
         })
     }
 
+    /// Const version of [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,
diff --git a/fsrc-core/tests/pus_events.rs b/fsrc-core/tests/pus_events.rs
index cb7e1e1..b304939 100644
--- a/fsrc-core/tests/pus_events.rs
+++ b/fsrc-core/tests/pus_events.rs
@@ -1,7 +1,10 @@
 #![allow(dead_code, unused_imports)]
 
+use fsrc_core::events::{
+    EventU32, EventU32TypedSev, GenericEvent, HasSeverity, LargestEventRaw, LargestGroupIdRaw,
+    Severity, SeverityInfo, SeverityLow, SeverityMedium,
+};
 use std::convert::AsRef;
-use fsrc_core::events::{EventU32, EventU32TypedSev, GenericEvent, HasSeverity, LargestEventRaw, LargestGroupIdRaw, Severity, SeverityInfo, SeverityLow, SeverityMedium};
 
 #[derive(Debug)]
 struct GroupIdIntrospection {
@@ -45,36 +48,33 @@ 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);
+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 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_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 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
+    &INTROSPECTION_FOR_TEST_GROUP_NAME,
 ];
 
 #[test]

From 4b5b11486e0e38af3b51582b2a43a972aa639697 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Wed, 26 Oct 2022 00:23:10 +0200
Subject: [PATCH 07/40] doc cfg support

---
 fsrc-core/Cargo.toml              |  4 +++
 fsrc-core/src/event_man.rs        |  2 +-
 fsrc-core/src/events.rs           | 41 +++++++++++++++++++++++++++----
 fsrc-core/src/lib.rs              |  3 +++
 fsrc-core/src/pus/event_man.rs    |  9 ++++---
 fsrc-core/src/pus/verification.rs |  4 +--
 spacepackets                      |  2 +-
 7 files changed, 53 insertions(+), 12 deletions(-)

diff --git a/fsrc-core/Cargo.toml b/fsrc-core/Cargo.toml
index 69df909..35072fe 100644
--- a/fsrc-core/Cargo.toml
+++ b/fsrc-core/Cargo.toml
@@ -42,3 +42,7 @@ default = ["std"]
 std = ["downcast-rs/std", "alloc", "bus", "postcard/use-std", "crossbeam-channel/std"]
 alloc = []
 heapless = []
+
+[package.metadata.docs.rs]
+all-features = true
+rustdoc-args = ["--cfg", "doc_cfg"]
diff --git a/fsrc-core/src/event_man.rs b/fsrc-core/src/event_man.rs
index 5d1c6ba..33884b6 100644
--- a/fsrc-core/src/event_man.rs
+++ b/fsrc-core/src/event_man.rs
@@ -1,4 +1,4 @@
-//! [Event][crate::events::Event] management and forwarding
+//! Event management and forwarding
 use crate::events::{EventU16TypedSev, EventU32, GenericEvent, HasSeverity};
 use alloc::boxed::Box;
 use alloc::vec;
diff --git a/fsrc-core/src/events.rs b/fsrc-core/src/events.rs
index b2dbec8..02f4dfd 100644
--- a/fsrc-core/src/events.rs
+++ b/fsrc-core/src/events.rs
@@ -1,5 +1,32 @@
 //! 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 fsrc_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::hash::Hash;
 use delegate::delegate;
 use spacepackets::ecss::{EcssEnumeration, ToBeBytes};
@@ -23,24 +50,28 @@ pub trait HasSeverity {
     const SEVERITY: Severity;
 }
 
+/// Type level support struct
 #[derive(Debug, PartialEq, Eq)]
 pub struct SeverityInfo {}
 impl HasSeverity for SeverityInfo {
     const SEVERITY: Severity = Severity::INFO;
 }
 
+/// Type level support struct
 #[derive(Debug, PartialEq, Eq)]
 pub struct SeverityLow {}
 impl HasSeverity for SeverityLow {
     const SEVERITY: Severity = Severity::LOW;
 }
 
+/// Type level support struct
 #[derive(Debug, PartialEq, Eq)]
 pub struct SeverityMedium {}
 impl HasSeverity for SeverityMedium {
     const SEVERITY: Severity = Severity::MEDIUM;
 }
 
+/// Type level support struct
 #[derive(Debug, PartialEq, Eq)]
 pub struct SeverityHigh {}
 impl HasSeverity for SeverityHigh {
@@ -76,7 +107,7 @@ impl TryFrom<u8> for Severity {
 }
 
 #[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
-pub struct EventBase<RAW, GID, UID> {
+struct EventBase<RAW, GID, UID> {
     severity: Severity,
     group_id: GID,
     unique_id: UID,
@@ -322,7 +353,7 @@ impl<SEVERITY: HasSeverity> EventU32TypedSev<SEVERITY> {
         })
     }
 
-    /// Const version of [new], but panics on invalid group ID input values.
+    /// 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,
@@ -421,7 +452,7 @@ impl EventU16 {
         })
     }
 
-    /// Const version of [new], but panics on invalid group ID input values.
+    /// 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,
@@ -459,7 +490,7 @@ impl<SEVERITY: HasSeverity> EventU16TypedSev<SEVERITY> {
         })
     }
 
-    /// Const version of [new], but panics on invalid group ID input values.
+    /// 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,
diff --git a/fsrc-core/src/lib.rs b/fsrc-core/src/lib.rs
index 02298a0..e8349da 100644
--- a/fsrc-core/src/lib.rs
+++ b/fsrc-core/src/lib.rs
@@ -15,13 +15,16 @@ 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 objects;
 #[cfg(feature = "alloc")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "alloc")))]
 pub mod pool;
 pub mod pus;
 pub mod tmtc;
diff --git a/fsrc-core/src/pus/event_man.rs b/fsrc-core/src/pus/event_man.rs
index 86581f6..5b48143 100644
--- a/fsrc-core/src/pus/event_man.rs
+++ b/fsrc-core/src/pus/event_man.rs
@@ -6,12 +6,14 @@ use hashbrown::HashSet;
 use crate::pus::event::EventReporter;
 use crate::pus::{EcssTmError, EcssTmSender};
 #[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.
+/// 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)
@@ -59,6 +61,7 @@ pub mod heapless_mod {
     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)]
diff --git a/fsrc-core/src/pus/verification.rs b/fsrc-core/src/pus/verification.rs
index 479dc11..41b74e1 100644
--- a/fsrc-core/src/pus/verification.rs
+++ b/fsrc-core/src/pus/verification.rs
@@ -987,7 +987,7 @@ mod stdmod {
     }
 
     /// Verification sender with a [mpsc::Sender] backend.
-    /// It implements the [VerificationSender] trait to be used as PUS Verification TM sender.
+    /// It implements the [EcssTmSender] trait to be used as PUS Verification TM sender.
     impl MpscVerifSender {
         pub fn new(tm_store: SharedPool, tx: mpsc::Sender<StoreAddr>) -> Self {
             Self {
@@ -1014,7 +1014,7 @@ mod stdmod {
     }
 
     /// Verification sender with a [crossbeam_channel::Sender] backend.
-    /// It implements the [VerificationSender] trait to be used as PUS Verification TM sender
+    /// It implements the [EcssTmSender] trait to be used as PUS Verification TM sender
     pub struct CrossbeamVerifSender {
         base: StdSenderBase<crossbeam_channel::Sender<StoreAddr>>,
     }
diff --git a/spacepackets b/spacepackets
index a2673c9..65e85f2 160000
--- a/spacepackets
+++ b/spacepackets
@@ -1 +1 @@
-Subproject commit a2673c98707ecbbabb9535bef607025c92b54724
+Subproject commit 65e85f20e03507f19a0d5086ee19360ff7596c27

From 294ae2cf52d0fdc33c97c5be8636a5ed1cb6201c Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Wed, 26 Oct 2022 00:29:11 +0200
Subject: [PATCH 08/40] some minor adaptions

---
 fsrc-core/src/hal/mod.rs | 1 +
 fsrc-core/src/pus/mod.rs | 5 +++--
 2 files changed, 4 insertions(+), 2 deletions(-)

diff --git a/fsrc-core/src/hal/mod.rs b/fsrc-core/src/hal/mod.rs
index ddaf8f3..c422a72 100644
--- a/fsrc-core/src/hal/mod.rs
+++ b/fsrc-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/fsrc-core/src/pus/mod.rs b/fsrc-core/src/pus/mod.rs
index a09b398..82e49f9 100644
--- a/fsrc-core/src/pus/mod.rs
+++ b/fsrc-core/src/pus/mod.rs
@@ -32,8 +32,9 @@ impl<E> From<ByteConversionError> for EcssTmError<E> {
     }
 }
 
-/// Generic trait for a user supplied sender object. This sender object is responsible for sending
-/// telemetry to a TM sink. The [Downcast] trait
+/// Generic trait for a user supplied sender object.
+///
+/// This sender object is responsible for sending telemetry to a TM sink. 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 EcssTmSender<E>: Downcast + Send {

From c57a4efd88cf7cd3b0681b8b557cbe32a02b2271 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Thu, 27 Oct 2022 23:56:47 +0200
Subject: [PATCH 09/40] needs some research

---
 fsrc-core/src/event_man.rs | 92 +++++++++++++++++++++++---------------
 1 file changed, 55 insertions(+), 37 deletions(-)

diff --git a/fsrc-core/src/event_man.rs b/fsrc-core/src/event_man.rs
index 33884b6..fec1b6c 100644
--- a/fsrc-core/src/event_man.rs
+++ b/fsrc-core/src/event_man.rs
@@ -15,7 +15,10 @@ pub trait EventListener<Provider: GenericEvent> {
     type Error;
 
     fn id(&self) -> u32;
-    fn send_to(&mut self, event: Provider) -> Result<(), Self::Error>;
+    fn send_to_no_data(&mut self, event: Provider) -> Result<(), Self::Error> {
+        self.send_to(event, None)
+    }
+    fn send_to(&mut self, event: Provider, aux_data: Option<&[u8]>) -> Result<(), Self::Error>;
 }
 
 struct Listener<E, Provider: GenericEvent> {
@@ -24,7 +27,7 @@ struct Listener<E, Provider: GenericEvent> {
 }
 
 pub trait ReceivesAllEvent<Provider: GenericEvent> {
-    fn receive(&mut self) -> Option<Provider>;
+    fn receive(&mut self) -> Option<(Provider, Option<&[u8]>)>;
 }
 
 pub struct EventManager<E, Provider: GenericEvent> {
@@ -114,23 +117,28 @@ impl<E, Provider: GenericEvent + Copy> EventManager<E, Provider> {
     pub fn try_event_handling(&mut self) -> Result<HandlerResult<Provider>, E> {
         let mut err_status = None;
         let mut num_recipients = 0;
-        let mut send_handler = |event: Provider, llist: &mut Vec<Listener<E, Provider>>| {
-            for listener in llist.iter_mut() {
-                if let Err(e) = listener.dest.send_to(event) {
-                    err_status = Some(Err(e));
-                } else {
-                    num_recipients += 1;
+        let mut send_handler =
+            |event: Provider, aux_data: Option<&[u8]>, llist: &mut Vec<Listener<E, Provider>>| {
+                for listener in llist.iter_mut() {
+                    if let Err(e) = listener.dest.send_to(event, aux_data) {
+                        err_status = Some(Err(e));
+                    } else {
+                        num_recipients += 1;
+                    }
                 }
-            }
-        };
-        if let Some(event) = self.event_receiver.receive() {
+            };
+        if let Some((event, aux_data)) = self.event_receiver.receive() {
             let single_key = ListenerType::Single(event.raw_as_largest_type());
             if self.listeners.contains_key(&single_key) {
-                send_handler(event, self.listeners.get_mut(&single_key).unwrap());
+                send_handler(
+                    event,
+                    aux_data,
+                    self.listeners.get_mut(&single_key).unwrap(),
+                );
             }
             let group_key = ListenerType::Group(event.group_id_as_largest_type());
             if self.listeners.contains_key(&group_key) {
-                send_handler(event, self.listeners.get_mut(&group_key).unwrap());
+                send_handler(event, aux_data, self.listeners.get_mut(&group_key).unwrap());
             }
             if let Some(err) = err_status {
                 return err;
@@ -151,36 +159,46 @@ mod tests {
     use std::thread;
     use std::time::Duration;
 
-    struct EventReceiver {
-        mpsc_receiver: Receiver<EventU32>,
+    type EventAndParams<'a> = (EventU32, Option<&'a [u8]>);
+
+    struct EventReceiver<'a> {
+        mpsc_receiver: Receiver<EventAndParams<'a>>,
     }
-    impl ReceivesAllEvent<EventU32> for EventReceiver {
-        fn receive(&mut self) -> Option<EventU32> {
-            self.mpsc_receiver.try_recv().ok()
+
+    impl ReceivesAllEvent<EventU32> for EventReceiver<'_> {
+        fn receive(&mut self) -> Option<(EventU32, Option<&[u8]>)> {
+            if let Some((event, _params)) = self.mpsc_receiver.try_recv().ok() {
+                return Some((event, None));
+            }
+            None
         }
     }
 
     #[derive(Clone)]
-    struct MpscEventSenderQueue {
+    struct MpscEventSenderQueue<'a> {
         id: u32,
-        mpsc_sender: Sender<EventU32>,
+        mpsc_sender: Sender<EventAndParams<'a>>,
     }
 
-    impl EventListener<EventU32> for MpscEventSenderQueue {
-        type Error = SendError<EventU32>;
+    impl<'a> EventListener<EventU32> for MpscEventSenderQueue<'a> {
+        type Error = SendError<EventAndParams<'a>>;
 
         fn id(&self) -> u32 {
             self.id
         }
-        fn send_to(&mut self, event: EventU32) -> Result<(), Self::Error> {
-            self.mpsc_sender.send(event)
+        fn send_to(
+            &mut self,
+            event: EventU32,
+            _aux_data: Option<&[u8]>,
+        ) -> Result<(), Self::Error> {
+            self.mpsc_sender.send((event, None))
         }
     }
 
-    fn check_next_event(expected: EventU32, receiver: &Receiver<EventU32>) {
+    fn check_next_event(expected: EventU32, receiver: &Receiver<EventAndParams>) {
         for _ in 0..5 {
             if let Ok(event) = receiver.try_recv() {
-                assert_eq!(event, expected);
+                assert_eq!(event.0, expected);
                 break;
             }
             thread::sleep(Duration::from_millis(1));
@@ -205,7 +223,7 @@ mod tests {
         let event_man_receiver = EventReceiver {
             mpsc_receiver: manager_queue,
         };
-        let mut event_man: EventManager<SendError<EventU32>, EventU32> =
+        let mut event_man: EventManager<SendError<EventAndParams>, EventU32> =
             EventManager::new(Box::new(event_man_receiver));
         let event_grp_0 = EventU32::new(Severity::INFO, 0, 0).unwrap();
         let event_grp_1_0 = EventU32::new(Severity::HIGH, 1, 0).unwrap();
@@ -224,7 +242,7 @@ mod tests {
 
         // Test event with one listener
         event_sender
-            .send(event_grp_0)
+            .send((event_grp_0, None))
             .expect("Sending single error failed");
         let res = event_man.try_event_handling();
         assert!(res.is_ok());
@@ -233,7 +251,7 @@ mod tests {
 
         // Test event which is sent to all group listeners
         event_sender
-            .send(event_grp_1_0)
+            .send((event_grp_1_0, None))
             .expect("Sending group error failed");
         let res = event_man.try_event_handling();
         assert!(res.is_ok());
@@ -248,7 +266,7 @@ mod tests {
         let event_man_receiver = EventReceiver {
             mpsc_receiver: manager_queue,
         };
-        let mut event_man: EventManager<SendError<EventU32>, EventU32> =
+        let mut event_man: EventManager<SendError<EventAndParams>, EventU32> =
             EventManager::new(Box::new(event_man_receiver));
         let res = event_man.try_event_handling();
         assert!(res.is_ok());
@@ -266,10 +284,10 @@ mod tests {
         event_man.subscribe_group(event_grp_1_0.group_id(), event_grp_0_and_1_listener);
 
         event_sender
-            .send(event_grp_0)
+            .send((event_grp_0, None))
             .expect("Sending Event Group 0 failed");
         event_sender
-            .send(event_grp_1_0)
+            .send((event_grp_1_0, None))
             .expect("Sendign Event Group 1 failed");
         let res = event_man.try_event_handling();
         assert!(res.is_ok());
@@ -290,7 +308,7 @@ mod tests {
         let event_man_receiver = EventReceiver {
             mpsc_receiver: manager_queue,
         };
-        let mut event_man: EventManager<SendError<EventU32>, EventU32> =
+        let mut event_man: EventManager<SendError<EventAndParams>, EventU32> =
             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();
@@ -307,7 +325,7 @@ mod tests {
         event_man.subscribe_single(event_0, event_listener_0.clone());
         event_man.subscribe_single(event_0, event_listener_1);
         event_sender
-            .send(event_0)
+            .send((event_0, None))
             .expect("Triggering Event 0 failed");
         let res = event_man.try_event_handling();
         assert!(res.is_ok());
@@ -316,10 +334,10 @@ mod tests {
         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)
+            .send((event_0, None))
             .expect("Triggering Event 0 failed");
         event_sender
-            .send(event_1)
+            .send((event_1, None))
             .expect("Triggering Event 1 failed");
 
         // 3 Events messages will be sent now
@@ -336,7 +354,7 @@ mod tests {
         // 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)
+            .send((event_1, None))
             .expect("Triggering Event 1 failed");
         let res = event_man.try_event_handling();
         assert!(res.is_ok());

From 10849229e6237b5746f9c1ad2eb437100ac6a762 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Fri, 28 Oct 2022 02:02:28 +0200
Subject: [PATCH 10/40] more docs for event manager

---
 fsrc-core/src/event_man.rs | 170 +++++++++++++++++++++++--------------
 1 file changed, 107 insertions(+), 63 deletions(-)

diff --git a/fsrc-core/src/event_man.rs b/fsrc-core/src/event_man.rs
index fec1b6c..cce5e12 100644
--- a/fsrc-core/src/event_man.rs
+++ b/fsrc-core/src/event_man.rs
@@ -1,5 +1,25 @@
 //! Event management and forwarding
-use crate::events::{EventU16TypedSev, EventU32, GenericEvent, HasSeverity};
+//!
+//! This module provides components to perform event routing. The most important component for this
+//! task is the [EventManager]. It has a map of event listeners and uses a dynamic [EventReceiver]
+//! instance to receive all events and then route them to event subscribers where appropriate.
+//!
+//! 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.
+//! This can be done with the [EventManager] like this:
+//!
+//!  1. Provide a concrete [SendEventProvider] implementation and a concrete [EventReceiver]
+//!     implementation. These 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. It is recommended that these implementations
+//!     derive [Clone].
+//!  2. Each event creator gets a sender component which allows it to send events to the manager.
+//!  3. The event manager receives all receiver ends so all events are routed to the
+//!     manager.
+//!  4. Each event receiver and/or subscriber gets a receiver component. The sender component is
+//!     used with the [SendEventProvider] trait and the subscription API provided by the
+//!     [EventManager] to subscribe for individual events or whole group of events.
+use crate::events::{GenericEvent, LargestEventRaw, LargestGroupIdRaw};
 use alloc::boxed::Box;
 use alloc::vec;
 use alloc::vec::Vec;
@@ -7,32 +27,42 @@ use hashbrown::HashMap;
 
 #[derive(PartialEq, Eq, Hash, Copy, Clone)]
 enum ListenerType {
-    Single(u32),
-    Group(u16),
+    Single(LargestEventRaw),
+    Group(LargestGroupIdRaw),
+    All,
 }
 
-pub trait EventListener<Provider: GenericEvent> {
+pub trait SendEventProvider<Provider: GenericEvent> {
     type Error;
 
     fn id(&self) -> u32;
-    fn send_to_no_data(&mut self, event: Provider) -> Result<(), Self::Error> {
-        self.send_to(event, None)
+    fn send_no_data(&mut self, event: Provider) -> Result<(), Self::Error> {
+        self.send(event, None)
     }
-    fn send_to(&mut self, event: Provider, aux_data: Option<&[u8]>) -> Result<(), Self::Error>;
+    fn send(&mut self, event: Provider, aux_data: Option<&[u8]>) -> Result<(), Self::Error>;
 }
 
-struct Listener<E, Provider: GenericEvent> {
+struct Listener<E, Event: GenericEvent> {
     ltype: ListenerType,
-    dest: Box<dyn EventListener<Provider, Error = E>>,
+    send_provider: Box<dyn SendEventProvider<Event, Error = E>>,
 }
 
-pub trait ReceivesAllEvent<Provider: GenericEvent> {
-    fn receive(&mut self) -> Option<(Provider, Option<&[u8]>)>;
+/// Generic abstraction for an event receiver.
+pub trait EventReceiver<Event: GenericEvent> {
+    /// 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(&mut self, aux_data: &mut [u8]) -> Option<Event>;
 }
 
-pub struct EventManager<E, Provider: GenericEvent> {
-    listeners: HashMap<ListenerType, Vec<Listener<E, Provider>>>,
-    event_receiver: Box<dyn ReceivesAllEvent<Provider>>,
+/// Generic event manager implementation.
+pub struct EventManager<E, Event: GenericEvent> {
+    aux_data_buf: Vec<u8>,
+    listeners: HashMap<ListenerType, Vec<Listener<E, Event>>>,
+    event_receiver: Box<dyn EventReceiver<Event>>,
 }
 
 pub enum HandlerResult<Provider: GenericEvent> {
@@ -40,48 +70,50 @@ pub enum HandlerResult<Provider: GenericEvent> {
     Handled(u32, Provider),
 }
 
-impl<E> EventManager<E, EventU32> {
-    pub fn new(event_receiver: Box<dyn ReceivesAllEvent<EventU32>>) -> Self {
+impl<E, Event: GenericEvent + Copy> EventManager<E, Event> {
+    pub fn new(event_receiver: Box<dyn EventReceiver<Event>>, buf_len_aux_data: usize) -> Self {
         EventManager {
+            aux_data_buf: vec![0; buf_len_aux_data],
             listeners: HashMap::new(),
             event_receiver,
         }
     }
-}
-
-impl<E> EventManager<E, EventU32> {
     pub fn subscribe_single(
         &mut self,
-        event: EventU32,
-        dest: impl EventListener<EventU32, Error = E> + 'static,
+        event: Event,
+        dest: impl SendEventProvider<Event, Error = E> + 'static,
     ) {
         self.update_listeners(ListenerType::Single(event.raw_as_largest_type()), dest);
     }
 
     pub fn subscribe_group(
         &mut self,
-        group_id: <EventU32 as GenericEvent>::GroupId,
-        dest: impl EventListener<EventU32, Error = E> + 'static,
+        group_id: LargestGroupIdRaw,
+        dest: impl SendEventProvider<Event, Error = E> + 'static,
     ) {
         self.update_listeners(ListenerType::Group(group_id), dest);
     }
-}
 
-impl<E, SEVERITY: HasSeverity + Copy> EventManager<E, EventU16TypedSev<SEVERITY>> {
-    pub fn subscribe_single(
-        &mut self,
-        event: EventU16TypedSev<SEVERITY>,
-        dest: impl EventListener<EventU16TypedSev<SEVERITY>, Error = E> + 'static,
-    ) {
-        self.update_listeners(ListenerType::Single(event.raw_as_largest_type()), dest);
+    pub fn subscribe_all(&mut self, dest: impl SendEventProvider<Event, Error = E> + 'static) {
+        self.update_listeners(ListenerType::All, dest);
     }
 
-    pub fn subscribe_group(
+    /// Helper function which removes single subscriptions for which a group subscription already
+    /// exists.
+    pub fn remove_single_subscriptions_for_group(
         &mut self,
-        group_id: <EventU16TypedSev<SEVERITY> as GenericEvent>::GroupId,
-        dest: impl EventListener<EventU16TypedSev<SEVERITY>, Error = E> + 'static,
+        group_id: LargestGroupIdRaw,
+        dest: impl SendEventProvider<Event, Error=E> + 'static
     ) {
-        self.update_listeners(ListenerType::Group(group_id.into()), dest);
+        if self.listeners.contains_key(&ListenerType::Group(group_id)) {
+            for (ltype, listeners) in &mut self.listeners {
+                if let ListenerType::Single(_) = ltype {
+                    listeners.retain(|f| {
+                        f.send_provider.id() != dest.id()
+                    });
+                }
+            }
+        }
     }
 }
 
@@ -89,27 +121,27 @@ impl<E, Provider: GenericEvent + Copy> EventManager<E, Provider> {
     fn update_listeners(
         &mut self,
         key: ListenerType,
-        dest: impl EventListener<Provider, Error = E> + 'static,
+        dest: impl SendEventProvider<Provider, Error = E> + 'static,
     ) {
         if !self.listeners.contains_key(&key) {
             self.listeners.insert(
                 key,
                 vec![Listener {
                     ltype: key,
-                    dest: Box::new(dest),
+                    send_provider: 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() {
+                if entry.ltype == key && entry.send_provider.id() == dest.id() {
                     return;
                 }
             }
             vec.push(Listener {
                 ltype: key,
-                dest: Box::new(dest),
+                send_provider: Box::new(dest),
             });
         }
     }
@@ -120,25 +152,35 @@ impl<E, Provider: GenericEvent + Copy> EventManager<E, Provider> {
         let mut send_handler =
             |event: Provider, aux_data: Option<&[u8]>, llist: &mut Vec<Listener<E, Provider>>| {
                 for listener in llist.iter_mut() {
-                    if let Err(e) = listener.dest.send_to(event, aux_data) {
+                    if let Err(e) = listener.send_provider.send(event, aux_data) {
                         err_status = Some(Err(e));
                     } else {
                         num_recipients += 1;
                     }
                 }
             };
-        if let Some((event, aux_data)) = self.event_receiver.receive() {
+        if let Some(event) = self
+            .event_receiver
+            .receive(self.aux_data_buf.as_mut_slice())
+        {
             let single_key = ListenerType::Single(event.raw_as_largest_type());
             if self.listeners.contains_key(&single_key) {
                 send_handler(
                     event,
-                    aux_data,
+                    Some(self.aux_data_buf.as_slice()),
                     self.listeners.get_mut(&single_key).unwrap(),
                 );
             }
             let group_key = ListenerType::Group(event.group_id_as_largest_type());
             if self.listeners.contains_key(&group_key) {
-                send_handler(event, aux_data, self.listeners.get_mut(&group_key).unwrap());
+                send_handler(
+                    event,
+                    Some(self.aux_data_buf.as_slice()),
+                    self.listeners.get_mut(&group_key).unwrap(),
+                );
+            }
+            if let Some(all_receivers) = self.listeners.get_mut(&ListenerType::All) {
+                send_handler(event, Some(self.aux_data_buf.as_slice()), all_receivers);
             }
             if let Some(err) = err_status {
                 return err;
@@ -151,24 +193,30 @@ impl<E, Provider: GenericEvent + Copy> EventManager<E, Provider> {
 
 #[cfg(test)]
 mod tests {
-    use super::{EventListener, HandlerResult, ReceivesAllEvent};
+    use super::{EventReceiver, HandlerResult, SendEventProvider};
     use crate::event_man::EventManager;
     use crate::events::{EventU32, GenericEvent, Severity};
     use alloc::boxed::Box;
     use std::sync::mpsc::{channel, Receiver, SendError, Sender};
-    use std::thread;
     use std::time::Duration;
+    use std::{thread, vec};
+    use vec::Vec;
 
     type EventAndParams<'a> = (EventU32, Option<&'a [u8]>);
 
-    struct EventReceiver<'a> {
-        mpsc_receiver: Receiver<EventAndParams<'a>>,
+    struct MpscEventReceiver {
+        mpsc_receiver: Receiver<(EventU32, Option<Vec<u8>>)>,
     }
 
-    impl ReceivesAllEvent<EventU32> for EventReceiver<'_> {
-        fn receive(&mut self) -> Option<(EventU32, Option<&[u8]>)> {
-            if let Some((event, _params)) = self.mpsc_receiver.try_recv().ok() {
-                return Some((event, None));
+    impl EventReceiver<EventU32> for MpscEventReceiver {
+        fn receive(&mut self, aux_data: &mut [u8]) -> Option<EventU32> {
+            if let Some((event, params)) = self.mpsc_receiver.try_recv().ok() {
+                if let Some(params) = params {
+                    if params.len() < aux_data.len() {
+                        aux_data[0..params.len()].copy_from_slice(params.as_slice())
+                    }
+                }
+                return Some(event);
             }
             None
         }
@@ -180,17 +228,13 @@ mod tests {
         mpsc_sender: Sender<EventAndParams<'a>>,
     }
 
-    impl<'a> EventListener<EventU32> for MpscEventSenderQueue<'a> {
+    impl<'a> SendEventProvider<EventU32> for MpscEventSenderQueue<'a> {
         type Error = SendError<EventAndParams<'a>>;
 
         fn id(&self) -> u32 {
             self.id
         }
-        fn send_to(
-            &mut self,
-            event: EventU32,
-            _aux_data: Option<&[u8]>,
-        ) -> Result<(), Self::Error> {
+        fn send(&mut self, event: EventU32, _aux_data: Option<&[u8]>) -> Result<(), Self::Error> {
             self.mpsc_sender.send((event, None))
         }
     }
@@ -220,11 +264,11 @@ mod tests {
     #[test]
     fn test_basic() {
         let (event_sender, manager_queue) = channel();
-        let event_man_receiver = EventReceiver {
+        let event_man_receiver = MpscEventReceiver {
             mpsc_receiver: manager_queue,
         };
         let mut event_man: EventManager<SendError<EventAndParams>, EventU32> =
-            EventManager::new(Box::new(event_man_receiver));
+            EventManager::new(Box::new(event_man_receiver), 128);
         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();
@@ -263,11 +307,11 @@ mod tests {
     #[test]
     fn test_multi_group() {
         let (event_sender, manager_queue) = channel();
-        let event_man_receiver = EventReceiver {
+        let event_man_receiver = MpscEventReceiver {
             mpsc_receiver: manager_queue,
         };
         let mut event_man: EventManager<SendError<EventAndParams>, EventU32> =
-            EventManager::new(Box::new(event_man_receiver));
+            EventManager::new(Box::new(event_man_receiver), 128);
         let res = event_man.try_event_handling();
         assert!(res.is_ok());
         let hres = res.unwrap();
@@ -305,11 +349,11 @@ mod tests {
     #[test]
     fn test_listening_to_same_event_and_multi_type() {
         let (event_sender, manager_queue) = channel();
-        let event_man_receiver = EventReceiver {
+        let event_man_receiver = MpscEventReceiver {
             mpsc_receiver: manager_queue,
         };
         let mut event_man: EventManager<SendError<EventAndParams>, EventU32> =
-            EventManager::new(Box::new(event_man_receiver));
+            EventManager::new(Box::new(event_man_receiver), 128);
         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();

From 819c121fd7002fc4a0547dd2c83013be367291ef Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Fri, 28 Oct 2022 02:02:50 +0200
Subject: [PATCH 11/40] cargo fmt

---
 fsrc-core/src/event_man.rs | 6 ++----
 1 file changed, 2 insertions(+), 4 deletions(-)

diff --git a/fsrc-core/src/event_man.rs b/fsrc-core/src/event_man.rs
index cce5e12..d050a70 100644
--- a/fsrc-core/src/event_man.rs
+++ b/fsrc-core/src/event_man.rs
@@ -103,14 +103,12 @@ impl<E, Event: GenericEvent + Copy> EventManager<E, Event> {
     pub fn remove_single_subscriptions_for_group(
         &mut self,
         group_id: LargestGroupIdRaw,
-        dest: impl SendEventProvider<Event, Error=E> + 'static
+        dest: impl SendEventProvider<Event, Error = E> + 'static,
     ) {
         if self.listeners.contains_key(&ListenerType::Group(group_id)) {
             for (ltype, listeners) in &mut self.listeners {
                 if let ListenerType::Single(_) = ltype {
-                    listeners.retain(|f| {
-                        f.send_provider.id() != dest.id()
-                    });
+                    listeners.retain(|f| f.send_provider.id() != dest.id());
                 }
             }
         }

From b7da30d741e5047316d1e314cbc2184b856f958b Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sat, 29 Oct 2022 01:10:51 +0200
Subject: [PATCH 12/40] added unittest for all subscription

---
 fsrc-core/src/event_man.rs | 39 +++++++++++++++++++++++++++++++++++++-
 1 file changed, 38 insertions(+), 1 deletion(-)

diff --git a/fsrc-core/src/event_man.rs b/fsrc-core/src/event_man.rs
index d050a70..6135613 100644
--- a/fsrc-core/src/event_man.rs
+++ b/fsrc-core/src/event_man.rs
@@ -18,7 +18,12 @@
 //!     manager.
 //!  4. Each event receiver and/or subscriber gets a receiver component. The sender component is
 //!     used with the [SendEventProvider] trait and the subscription API provided by the
-//!     [EventManager] to subscribe for individual events or whole group of events.
+//!     [EventManager] to subscribe for individual events, whole group of events or all events
+//!
+//! 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.
 use crate::events::{GenericEvent, LargestEventRaw, LargestGroupIdRaw};
 use alloc::boxed::Box;
 use alloc::vec;
@@ -402,4 +407,36 @@ mod tests {
         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 {
+            mpsc_receiver: manager_queue,
+        };
+        let mut event_man: EventManager<SendError<EventAndParams>, EventU32> =
+            EventManager::new(Box::new(event_man_receiver), 128);
+        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);
+        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);
+    }
 }

From 0b94256b9d8384c2ab9767522e7d25a2ac00b49c Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sat, 29 Oct 2022 01:16:00 +0200
Subject: [PATCH 13/40] some clarifications

---
 fsrc-core/src/event_man.rs | 19 +++++++++++--------
 1 file changed, 11 insertions(+), 8 deletions(-)

diff --git a/fsrc-core/src/event_man.rs b/fsrc-core/src/event_man.rs
index 6135613..9627c79 100644
--- a/fsrc-core/src/event_man.rs
+++ b/fsrc-core/src/event_man.rs
@@ -1,24 +1,27 @@
 //! Event management and forwarding
 //!
 //! This module provides components to perform event routing. The most important component for this
-//! task is the [EventManager]. It has a map of event listeners and uses a dynamic [EventReceiver]
+//! task is the [EventManager]. It uses a map of event listeners and uses a dynamic [EventReceiver]
 //! instance to receive all events and then route them to event subscribers where appropriate.
 //!
 //! 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.
-//! This can be done with the [EventManager] like this:
+//! and IPC mechanism for software and hardware events which are also packaged as telemetry or can
+//! trigger a system response. This can be done with the [EventManager] like this:
 //!
 //!  1. Provide a concrete [SendEventProvider] implementation and a concrete [EventReceiver]
 //!     implementation. These 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. It is recommended that these implementations
 //!     derive [Clone].
-//!  2. Each event creator gets a sender component which allows it to send events to the manager.
-//!  3. The event manager receives all receiver ends so all events are routed to the
+//!  2. Each event creator gets a (cloned) sender component which allows it to send events to the
 //!     manager.
-//!  4. Each event receiver and/or subscriber gets a receiver component. The sender component is
-//!     used with the [SendEventProvider] trait and the subscription API provided by the
-//!     [EventManager] to subscribe for individual events, whole group of events or all events
+//!  3. The event manager receives the receiver component so all events are routed to the
+//!     manager.
+//!  4. Additional channels are created for each event receiver and/or subscriber.
+//!     The sender component is used with the [SendEventProvider] trait and the subscription API
+//!     provided by the [EventManager] to subscribe for individual events, whole group of events or
+//!     all events. The receiver/subscribers can then receive all subscribed events via the receiver
+//!     end.
 //!
 //! 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.

From 190b6d035a8d19cbe648e145412054ae7f329f99 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sat, 29 Oct 2022 11:23:19 +0200
Subject: [PATCH 14/40] some components are generic

---
 fsrc-core/src/event_man.rs | 71 +++++++++++++++++++++-----------------
 1 file changed, 40 insertions(+), 31 deletions(-)

diff --git a/fsrc-core/src/event_man.rs b/fsrc-core/src/event_man.rs
index 9627c79..27d3b04 100644
--- a/fsrc-core/src/event_man.rs
+++ b/fsrc-core/src/event_man.rs
@@ -33,6 +33,9 @@ use alloc::vec;
 use alloc::vec::Vec;
 use hashbrown::HashMap;
 
+#[cfg(feature = "std")]
+pub use stdmod::MpscEventReceiver;
+
 #[derive(PartialEq, Eq, Hash, Copy, Clone)]
 enum ListenerType {
     Single(LargestEventRaw),
@@ -197,25 +200,26 @@ impl<E, Provider: GenericEvent + Copy> EventManager<E, Provider> {
     }
 }
 
-#[cfg(test)]
-mod tests {
-    use super::{EventReceiver, HandlerResult, SendEventProvider};
-    use crate::event_man::EventManager;
-    use crate::events::{EventU32, GenericEvent, Severity};
-    use alloc::boxed::Box;
-    use std::sync::mpsc::{channel, Receiver, SendError, Sender};
-    use std::time::Duration;
-    use std::{thread, vec};
-    use vec::Vec;
+#[cfg(feature = "std")]
+pub mod stdmod {
+    use crate::event_man::EventReceiver;
+    use crate::events::{EventU16, EventU32, GenericEvent};
+    use std::sync::mpsc::Receiver;
+    use std::vec::Vec;
 
-    type EventAndParams<'a> = (EventU32, Option<&'a [u8]>);
-
-    struct MpscEventReceiver {
-        mpsc_receiver: Receiver<(EventU32, Option<Vec<u8>>)>,
+    pub struct MpscEventReceiver<Event: GenericEvent = EventU32> {
+        mpsc_receiver: Receiver<(Event, Option<Vec<u8>>)>,
     }
 
-    impl EventReceiver<EventU32> for MpscEventReceiver {
-        fn receive(&mut self, aux_data: &mut [u8]) -> Option<EventU32> {
+    impl<Event: GenericEvent> MpscEventReceiver<Event> {
+        pub fn new(receiver: Receiver<(Event, Option<Vec<u8>>)>) -> Self {
+            Self {
+                mpsc_receiver: receiver,
+            }
+        }
+    }
+    impl<Event: GenericEvent> EventReceiver<Event> for MpscEventReceiver<Event> {
+        fn receive(&mut self, aux_data: &mut [u8]) -> Option<Event> {
             if let Some((event, params)) = self.mpsc_receiver.try_recv().ok() {
                 if let Some(params) = params {
                     if params.len() < aux_data.len() {
@@ -228,6 +232,20 @@ mod tests {
         }
     }
 
+    pub type MpscEventU32Receiver = MpscEventReceiver<EventU32>;
+    pub type MpscEventU16Receiver = MpscEventReceiver<EventU16>;
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::event_man::EventManager;
+    use crate::events::{EventU32, GenericEvent, Severity};
+    use alloc::boxed::Box;
+    use std::sync::mpsc::{channel, Receiver, SendError, Sender};
+
+    type EventAndParams<'a> = (EventU32, Option<&'a [u8]>);
+
     #[derive(Clone)]
     struct MpscEventSenderQueue<'a> {
         id: u32,
@@ -240,8 +258,8 @@ mod tests {
         fn id(&self) -> u32 {
             self.id
         }
-        fn send(&mut self, event: EventU32, _aux_data: Option<&[u8]>) -> Result<(), Self::Error> {
-            self.mpsc_sender.send((event, None))
+        fn send(&mut self, event: EventU32, aux_data: Option<&'a [u8]>) -> Result<(), Self::Error> {
+            self.mpsc_sender.send((event, aux_data))
         }
     }
 
@@ -251,7 +269,6 @@ mod tests {
                 assert_eq!(event.0, expected);
                 break;
             }
-            thread::sleep(Duration::from_millis(1));
         }
     }
 
@@ -270,9 +287,7 @@ mod tests {
     #[test]
     fn test_basic() {
         let (event_sender, manager_queue) = channel();
-        let event_man_receiver = MpscEventReceiver {
-            mpsc_receiver: manager_queue,
-        };
+        let event_man_receiver = MpscEventReceiver::new(manager_queue);
         let mut event_man: EventManager<SendError<EventAndParams>, EventU32> =
             EventManager::new(Box::new(event_man_receiver), 128);
         let event_grp_0 = EventU32::new(Severity::INFO, 0, 0).unwrap();
@@ -313,9 +328,7 @@ mod tests {
     #[test]
     fn test_multi_group() {
         let (event_sender, manager_queue) = channel();
-        let event_man_receiver = MpscEventReceiver {
-            mpsc_receiver: manager_queue,
-        };
+        let event_man_receiver = MpscEventReceiver::new(manager_queue);
         let mut event_man: EventManager<SendError<EventAndParams>, EventU32> =
             EventManager::new(Box::new(event_man_receiver), 128);
         let res = event_man.try_event_handling();
@@ -355,9 +368,7 @@ mod tests {
     #[test]
     fn test_listening_to_same_event_and_multi_type() {
         let (event_sender, manager_queue) = channel();
-        let event_man_receiver = MpscEventReceiver {
-            mpsc_receiver: manager_queue,
-        };
+        let event_man_receiver = MpscEventReceiver::new(manager_queue);
         let mut event_man: EventManager<SendError<EventAndParams>, EventU32> =
             EventManager::new(Box::new(event_man_receiver), 128);
         let event_0 = EventU32::new(Severity::INFO, 0, 5).unwrap();
@@ -414,9 +425,7 @@ mod tests {
     #[test]
     fn test_all_events_listener() {
         let (event_sender, manager_queue) = channel();
-        let event_man_receiver = MpscEventReceiver {
-            mpsc_receiver: manager_queue,
-        };
+        let event_man_receiver = MpscEventReceiver::new(manager_queue);
         let mut event_man: EventManager<SendError<EventAndParams>, EventU32> =
             EventManager::new(Box::new(event_man_receiver), 128);
         let event_0 = EventU32::new(Severity::INFO, 0, 5).unwrap();

From af288a1b2ba3f33f8ed05c78dd8ff02ddec18b66 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sat, 29 Oct 2022 13:05:29 +0200
Subject: [PATCH 15/40] first tests with auxiliary data

---
 fsrc-core/src/event_man.rs | 200 +++++++++++++++++++++++--------------
 fsrc-core/src/lib.rs       |   1 +
 fsrc-core/src/util.rs      |  97 ++++++++++++++++++
 3 files changed, 225 insertions(+), 73 deletions(-)
 create mode 100644 fsrc-core/src/util.rs

diff --git a/fsrc-core/src/event_man.rs b/fsrc-core/src/event_man.rs
index 27d3b04..381ccd7 100644
--- a/fsrc-core/src/event_man.rs
+++ b/fsrc-core/src/event_man.rs
@@ -27,7 +27,8 @@
 //! 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.
-use crate::events::{GenericEvent, LargestEventRaw, LargestGroupIdRaw};
+use crate::events::{EventU16, EventU32, GenericEvent, LargestEventRaw, LargestGroupIdRaw};
+use crate::util::{AuxData, AuxDataHeapless};
 use alloc::boxed::Box;
 use alloc::vec;
 use alloc::vec::Vec;
@@ -43,48 +44,69 @@ enum ListenerType {
     All,
 }
 
-pub trait SendEventProvider<Provider: GenericEvent> {
+pub type EventWithHeaplessAuxData<Event> = (Event, Option<AuxDataHeapless>);
+pub type EventU32WithHeaplessAuxData = EventWithHeaplessAuxData<EventU32>;
+pub type EventU16WithHeaplessAuxData = EventWithHeaplessAuxData<EventU16>;
+
+pub type EventWithAuxData<Event> = (Event, Option<AuxData>);
+pub type EventU32WithAuxData = EventWithAuxData<EventU32>;
+pub type EventU16WithAuxData = EventWithAuxData<EventU16>;
+
+pub trait SendEventProvider<Provider: GenericEvent, AuxDataProvider = AuxData> {
     type Error;
 
     fn id(&self) -> u32;
     fn send_no_data(&mut self, event: Provider) -> Result<(), Self::Error> {
         self.send(event, None)
     }
-    fn send(&mut self, event: Provider, aux_data: Option<&[u8]>) -> Result<(), Self::Error>;
+    fn send(
+        &mut self,
+        event: Provider,
+        aux_data: Option<AuxDataProvider>,
+    ) -> Result<(), Self::Error>;
 }
 
-struct Listener<E, Event: GenericEvent> {
+struct Listener<E, Event: GenericEvent, AuxDataProvider = AuxData> {
     ltype: ListenerType,
-    send_provider: Box<dyn SendEventProvider<Event, Error = E>>,
+    send_provider: Box<dyn SendEventProvider<Event, AuxDataProvider, Error = E>>,
 }
 
 /// Generic abstraction for an event receiver.
-pub trait EventReceiver<Event: GenericEvent> {
+pub trait EventReceiver<Event: GenericEvent, AuxDataProvider = AuxData> {
     /// 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(&mut self, aux_data: &mut [u8]) -> Option<Event>;
+    fn receive(&mut self) -> Option<(Event, Option<AuxDataProvider>)>;
 }
 
 /// Generic event manager implementation.
-pub struct EventManager<E, Event: GenericEvent> {
-    aux_data_buf: Vec<u8>,
-    listeners: HashMap<ListenerType, Vec<Listener<E, Event>>>,
-    event_receiver: Box<dyn EventReceiver<Event>>,
+///
+/// # Generics
+///
+///  * `SendProviderError`: [SendEventProvider] error type
+///  * `Event`: Concrete event provider, currently either [EventU32] or [EventU16]
+///  * `AuxDataProvider`: Concrete auxiliary data provder, currently either [AuxData] or
+///     [AuxDataHeapless]
+pub struct EventManager<
+    SendProviderError,
+    Event: GenericEvent = EventU32,
+    AuxDataProvider = AuxData,
+> {
+    listeners: HashMap<ListenerType, Vec<Listener<SendProviderError, Event, AuxDataProvider>>>,
+    event_receiver: Box<dyn EventReceiver<Event, AuxDataProvider>>,
 }
 
-pub enum HandlerResult<Provider: GenericEvent> {
+pub enum HandlerResult<Provider: GenericEvent, AuxDataProvider> {
     Empty,
-    Handled(u32, Provider),
+    Handled(u32, Provider, Option<AuxDataProvider>),
 }
 
 impl<E, Event: GenericEvent + Copy> EventManager<E, Event> {
-    pub fn new(event_receiver: Box<dyn EventReceiver<Event>>, buf_len_aux_data: usize) -> Self {
+    pub fn new(event_receiver: Box<dyn EventReceiver<Event>>) -> Self {
         EventManager {
-            aux_data_buf: vec![0; buf_len_aux_data],
             listeners: HashMap::new(),
             event_receiver,
         }
@@ -105,6 +127,10 @@ impl<E, Event: GenericEvent + Copy> EventManager<E, Event> {
         self.update_listeners(ListenerType::Group(group_id), dest);
     }
 
+    /// 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, dest: impl SendEventProvider<Event, Error = E> + 'static) {
         self.update_listeners(ListenerType::All, dest);
     }
@@ -126,11 +152,13 @@ impl<E, Event: GenericEvent + Copy> EventManager<E, Event> {
     }
 }
 
-impl<E, Provider: GenericEvent + Copy> EventManager<E, Provider> {
+impl<E, Event: GenericEvent + Copy, AuxDataProvider: Clone>
+    EventManager<E, Event, AuxDataProvider>
+{
     fn update_listeners(
         &mut self,
         key: ListenerType,
-        dest: impl SendEventProvider<Provider, Error = E> + 'static,
+        dest: impl SendEventProvider<Event, AuxDataProvider, Error = E> + 'static,
     ) {
         if !self.listeners.contains_key(&key) {
             self.listeners.insert(
@@ -155,28 +183,27 @@ impl<E, Provider: GenericEvent + Copy> EventManager<E, Provider> {
         }
     }
 
-    pub fn try_event_handling(&mut self) -> Result<HandlerResult<Provider>, E> {
+    pub fn try_event_handling(&mut self) -> Result<HandlerResult<Event, AuxDataProvider>, E> {
         let mut err_status = None;
         let mut num_recipients = 0;
         let mut send_handler =
-            |event: Provider, aux_data: Option<&[u8]>, llist: &mut Vec<Listener<E, Provider>>| {
+            |event: Event,
+             aux_data: Option<AuxDataProvider>,
+             llist: &mut Vec<Listener<E, Event, AuxDataProvider>>| {
                 for listener in llist.iter_mut() {
-                    if let Err(e) = listener.send_provider.send(event, aux_data) {
+                    if let Err(e) = listener.send_provider.send(event, aux_data.clone()) {
                         err_status = Some(Err(e));
                     } else {
                         num_recipients += 1;
                     }
                 }
             };
-        if let Some(event) = self
-            .event_receiver
-            .receive(self.aux_data_buf.as_mut_slice())
-        {
+        if let Some((event, aux_data)) = self.event_receiver.receive() {
             let single_key = ListenerType::Single(event.raw_as_largest_type());
             if self.listeners.contains_key(&single_key) {
                 send_handler(
                     event,
-                    Some(self.aux_data_buf.as_slice()),
+                    aux_data.clone(),
                     self.listeners.get_mut(&single_key).unwrap(),
                 );
             }
@@ -184,17 +211,17 @@ impl<E, Provider: GenericEvent + Copy> EventManager<E, Provider> {
             if self.listeners.contains_key(&group_key) {
                 send_handler(
                     event,
-                    Some(self.aux_data_buf.as_slice()),
+                    aux_data.clone(),
                     self.listeners.get_mut(&group_key).unwrap(),
                 );
             }
             if let Some(all_receivers) = self.listeners.get_mut(&ListenerType::All) {
-                send_handler(event, Some(self.aux_data_buf.as_slice()), all_receivers);
+                send_handler(event, aux_data.clone(), all_receivers);
             }
             if let Some(err) = err_status {
                 return err;
             }
-            return Ok(HandlerResult::Handled(num_recipients, event));
+            return Ok(HandlerResult::Handled(num_recipients, event, aux_data));
         }
         Ok(HandlerResult::Empty)
     }
@@ -202,31 +229,26 @@ impl<E, Provider: GenericEvent + Copy> EventManager<E, Provider> {
 
 #[cfg(feature = "std")]
 pub mod stdmod {
-    use crate::event_man::EventReceiver;
+    use crate::event_man::{EventReceiver, EventWithAuxData};
     use crate::events::{EventU16, EventU32, GenericEvent};
+    use crate::util::AuxData;
     use std::sync::mpsc::Receiver;
-    use std::vec::Vec;
 
     pub struct MpscEventReceiver<Event: GenericEvent = EventU32> {
-        mpsc_receiver: Receiver<(Event, Option<Vec<u8>>)>,
+        mpsc_receiver: Receiver<(Event, Option<AuxData>)>,
     }
 
     impl<Event: GenericEvent> MpscEventReceiver<Event> {
-        pub fn new(receiver: Receiver<(Event, Option<Vec<u8>>)>) -> Self {
+        pub fn new(receiver: Receiver<(Event, Option<AuxData>)>) -> Self {
             Self {
                 mpsc_receiver: receiver,
             }
         }
     }
     impl<Event: GenericEvent> EventReceiver<Event> for MpscEventReceiver<Event> {
-        fn receive(&mut self, aux_data: &mut [u8]) -> Option<Event> {
-            if let Some((event, params)) = self.mpsc_receiver.try_recv().ok() {
-                if let Some(params) = params {
-                    if params.len() < aux_data.len() {
-                        aux_data[0..params.len()].copy_from_slice(params.as_slice())
-                    }
-                }
-                return Some(event);
+        fn receive(&mut self) -> Option<EventWithAuxData<Event>> {
+            if let Ok(event_and_data) = self.mpsc_receiver.try_recv() {
+                return Some(event_and_data);
             }
             None
         }
@@ -241,62 +263,76 @@ mod tests {
     use super::*;
     use crate::event_man::EventManager;
     use crate::events::{EventU32, GenericEvent, Severity};
+    use crate::util::AuxDataRaw;
     use alloc::boxed::Box;
+    use std::format;
     use std::sync::mpsc::{channel, Receiver, SendError, Sender};
 
-    type EventAndParams<'a> = (EventU32, Option<&'a [u8]>);
-
     #[derive(Clone)]
-    struct MpscEventSenderQueue<'a> {
+    struct MpscEventSenderQueue {
         id: u32,
-        mpsc_sender: Sender<EventAndParams<'a>>,
+        mpsc_sender: Sender<EventU32WithAuxData>,
     }
 
-    impl<'a> SendEventProvider<EventU32> for MpscEventSenderQueue<'a> {
-        type Error = SendError<EventAndParams<'a>>;
+    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(&mut self, event: EventU32, aux_data: Option<&'a [u8]>) -> Result<(), Self::Error> {
+        fn send(&mut self, event: EventU32, aux_data: Option<AuxData>) -> Result<(), Self::Error> {
             self.mpsc_sender.send((event, aux_data))
         }
     }
 
-    fn check_next_event(expected: EventU32, receiver: &Receiver<EventAndParams>) {
-        for _ in 0..5 {
-            if let Ok(event) = receiver.try_recv() {
-                assert_eq!(event.0, expected);
-                break;
-            }
+    fn check_next_event(
+        expected: EventU32,
+        receiver: &Receiver<EventU32WithAuxData>,
+    ) -> Option<AuxData> {
+        if let Ok(event) = receiver.try_recv() {
+            assert_eq!(event.0, expected);
+            return event.1;
         }
+        None
     }
 
     fn check_handled_event(
-        res: HandlerResult<EventU32>,
+        res: HandlerResult<EventU32, AuxData>,
         expected: EventU32,
         expected_num_sent: u32,
     ) {
         assert!(matches!(res, HandlerResult::Handled { .. }));
-        if let HandlerResult::Handled(num_recipients, event) = res {
+        if let HandlerResult::Handled(num_recipients, event, _aux_data) = res {
             assert_eq!(event, expected);
             assert_eq!(num_recipients, expected_num_sent);
         }
     }
 
-    #[test]
-    fn test_basic() {
+    fn generic_event_man() -> (
+        Sender<EventU32WithAuxData>,
+        EventManager<SendError<EventU32WithAuxData>>,
+    ) {
         let (event_sender, manager_queue) = channel();
         let event_man_receiver = MpscEventReceiver::new(manager_queue);
-        let mut event_man: EventManager<SendError<EventAndParams>, EventU32> =
-            EventManager::new(Box::new(event_man_receiver), 128);
+        (
+            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 {
-            id: 0,
-            mpsc_sender: single_event_sender,
-        };
+        let single_event_listener = MpscEventSenderQueue::new(0, 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 {
@@ -324,13 +360,34 @@ mod tests {
         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);
+        event_sender
+            .send((event_grp_0, Some(AuxData::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 AuxData::Heapless(AuxDataHeapless::Raw(AuxDataRaw::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, manager_queue) = channel();
-        let event_man_receiver = MpscEventReceiver::new(manager_queue);
-        let mut event_man: EventManager<SendError<EventAndParams>, EventU32> =
-            EventManager::new(Box::new(event_man_receiver), 128);
+        let (event_sender, mut event_man) = generic_event_man();
         let res = event_man.try_event_handling();
         assert!(res.is_ok());
         let hres = res.unwrap();
@@ -367,10 +424,7 @@ mod tests {
     /// 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 = MpscEventReceiver::new(manager_queue);
-        let mut event_man: EventManager<SendError<EventAndParams>, EventU32> =
-            EventManager::new(Box::new(event_man_receiver), 128);
+        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();
@@ -426,8 +480,8 @@ mod tests {
     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<EventAndParams>, EventU32> =
-            EventManager::new(Box::new(event_man_receiver), 128);
+        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();
diff --git a/fsrc-core/src/lib.rs b/fsrc-core/src/lib.rs
index e8349da..c5178d4 100644
--- a/fsrc-core/src/lib.rs
+++ b/fsrc-core/src/lib.rs
@@ -28,5 +28,6 @@ pub mod objects;
 pub mod pool;
 pub mod pus;
 pub mod tmtc;
+pub mod util;
 
 extern crate downcast_rs;
diff --git a/fsrc-core/src/util.rs b/fsrc-core/src/util.rs
new file mode 100644
index 0000000..ef8033c
--- /dev/null
+++ b/fsrc-core/src/util.rs
@@ -0,0 +1,97 @@
+use crate::pool::StoreAddr;
+#[cfg(feature = "alloc")]
+use alloc::string::String;
+#[cfg(feature = "alloc")]
+use alloc::string::ToString;
+#[cfg(feature = "alloc")]
+use alloc::vec::Vec;
+
+#[derive(Debug, Copy, Clone)]
+pub enum AuxDataRaw {
+    U8(u8),
+    U8Pair((u8, u8)),
+    U8Triplet((u8, u8, u8)),
+    I8(i8),
+    I8Pair((i8, i8)),
+    I8Triplet((i8, i8, i8)),
+    U16(u16),
+    U16Pair((u16, u16)),
+    U16Triplet((u16, u16, u16)),
+    I16(i16),
+    I16Pair((i16, i16)),
+    I16Triplet((i16, i16, i16)),
+    U32(u32),
+    U32Pair((u32, u32)),
+    U32Triplet((u32, u32, u32)),
+    I32(i32),
+    I32Tuple((i32, i32)),
+    I32Triplet((i32, i32, i32)),
+    F32(f32),
+    F32Pair((f32, f32)),
+    F32Triplet((f32, f32, f32)),
+    U64(u64),
+    F64(f64),
+}
+
+#[derive(Debug, Copy, Clone)]
+pub enum AuxDataHeapless {
+    Raw(AuxDataRaw),
+    Store(StoreAddr),
+}
+
+impl From<StoreAddr> for AuxDataHeapless {
+    fn from(x: StoreAddr) -> Self {
+        Self::Store(x)
+    }
+}
+
+impl From<(u32, u32)> for AuxDataRaw {
+    fn from(val: (u32, u32)) -> Self {
+        Self::U32Pair(val)
+    }
+}
+
+impl From<(u32, u32)> for AuxDataHeapless {
+    fn from(val: (u32, u32)) -> Self {
+        AuxDataHeapless::Raw(val.into())
+    }
+}
+
+#[cfg(feature = "alloc")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "alloc")))]
+#[derive(Debug, Clone)]
+pub enum AuxData {
+    Heapless(AuxDataHeapless),
+    Vec(Vec<u8>),
+    String(String),
+}
+
+impl From<AuxDataHeapless> for AuxData {
+    fn from(x: AuxDataHeapless) -> Self {
+        Self::Heapless(x)
+    }
+}
+
+impl From<Vec<u8>> for AuxData {
+    fn from(val: Vec<u8>) -> Self {
+        Self::Vec(val)
+    }
+}
+
+impl From<&[u8]> for AuxData {
+    fn from(val: &[u8]) -> Self {
+        Self::Vec(val.to_vec())
+    }
+}
+
+impl From<String> for AuxData {
+    fn from(val: String) -> Self {
+        Self::String(val)
+    }
+}
+
+impl From<&str> for AuxData {
+    fn from(val: &str) -> Self {
+        Self::String(val.to_string())
+    }
+}

From 70fb9c8cd69a395e09884de0538cb8789856862c Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sat, 29 Oct 2022 13:23:07 +0200
Subject: [PATCH 16/40] all value to value conversions as declarative macros

---
 fsrc-core/src/util.rs | 52 ++++++++++++++++++++++++++++++++++---------
 1 file changed, 42 insertions(+), 10 deletions(-)

diff --git a/fsrc-core/src/util.rs b/fsrc-core/src/util.rs
index ef8033c..33d506c 100644
--- a/fsrc-core/src/util.rs
+++ b/fsrc-core/src/util.rs
@@ -24,7 +24,7 @@ pub enum AuxDataRaw {
     U32Pair((u32, u32)),
     U32Triplet((u32, u32, u32)),
     I32(i32),
-    I32Tuple((i32, i32)),
+    I32Pair((i32, i32)),
     I32Triplet((i32, i32, i32)),
     F32(f32),
     F32Pair((f32, f32)),
@@ -45,17 +45,49 @@ impl From<StoreAddr> for AuxDataHeapless {
     }
 }
 
-impl From<(u32, u32)> for AuxDataRaw {
-    fn from(val: (u32, u32)) -> Self {
-        Self::U32Pair(val)
-    }
+macro_rules! from_conversions_for_raw {
+    ($(($raw_ty: ty, $TargetPath: path),)+) => {
+        $(
+            impl From<$raw_ty> for AuxDataRaw {
+                fn from(val: $raw_ty) -> Self {
+                    $TargetPath(val)
+                }
+            }
+
+            impl From<$raw_ty> for AuxDataHeapless {
+                fn from(val: $raw_ty) -> Self {
+                    AuxDataHeapless::Raw(val.into())
+                }
+            }
+        )+
+    };
 }
 
-impl From<(u32, u32)> for AuxDataHeapless {
-    fn from(val: (u32, u32)) -> Self {
-        AuxDataHeapless::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")]
 #[cfg_attr(doc_cfg, doc(cfg(feature = "alloc")))]

From 15ad96a8435e65480b9710ee4b1ad894da0a5a4a Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sun, 30 Oct 2022 21:27:36 +0100
Subject: [PATCH 17/40] cargo fmt, start basic docs

---
 Cargo.lock            |   7 ++
 fsrc-core/Cargo.toml  |   1 +
 fsrc-core/src/util.rs | 240 +++++++++++++++++++++++++++++++++++++-----
 3 files changed, 224 insertions(+), 24 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 9314533..b83d042 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -300,6 +300,7 @@ dependencies = [
  "heapless",
  "num-traits",
  "once_cell",
+ "paste",
  "postcard",
  "serde",
  "spacepackets",
@@ -511,6 +512,12 @@ dependencies = [
  "windows-sys",
 ]
 
+[[package]]
+name = "paste"
+version = "1.0.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b1de2e551fb905ac83f73f7aedf2f0cb4a0da7e35efa24a202a936269f1f18e1"
+
 [[package]]
 name = "postcard"
 version = "1.0.2"
diff --git a/fsrc-core/Cargo.toml b/fsrc-core/Cargo.toml
index 35072fe..0db0e44 100644
--- a/fsrc-core/Cargo.toml
+++ b/fsrc-core/Cargo.toml
@@ -9,6 +9,7 @@ edition = "2021"
 delegate = "0.8"
 hashbrown = "0.12"
 heapless = "0.7"
+paste = "1.0"
 
 [dependencies.num-traits]
 version = "0.2"
diff --git a/fsrc-core/src/util.rs b/fsrc-core/src/util.rs
index 33d506c..bb9439e 100644
--- a/fsrc-core/src/util.rs
+++ b/fsrc-core/src/util.rs
@@ -1,3 +1,6 @@
+//! Utility types and enums
+//!
+//! This module contains helper types.
 use crate::pool::StoreAddr;
 #[cfg(feature = "alloc")]
 use alloc::string::String;
@@ -5,32 +8,177 @@ use alloc::string::String;
 use alloc::string::ToString;
 #[cfg(feature = "alloc")]
 use alloc::vec::Vec;
+use core::mem::size_of;
+use paste::paste;
+use spacepackets::ecss::ToBeBytes;
+
+macro_rules! primitive_newtypes {
+    ($($ty: ty,)+) => {
+        $(
+            paste! {
+                #[derive(Debug, Copy, Clone)]
+                pub struct [<$ty:upper>](pub $ty);
+                #[derive(Debug, Copy, Clone)]
+                pub struct [<$ty:upper Pair>](pub $ty, pub $ty);
+                #[derive(Debug, Copy, Clone)]
+                pub struct [<$ty:upper Triplet>](pub $ty, pub $ty, pub $ty);
+
+                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!(u8, u16, u32, u64, i8, i16, i32, i64, f32, f64,);
+
+macro_rules! scalar_to_be_bytes_impl {
+    ($($ty: ty,)+) => {
+        $(
+            paste! {
+                impl ToBeBytes for [<$ty:upper>] {
+                    type ByteArray = [u8; size_of::<$ty>()];
+                    fn to_be_bytes(&self) -> Self::ByteArray {
+                        self.0.to_be_bytes()
+                    }
+                }
+            }
+        )+
+    }
+}
+
+macro_rules! pair_to_be_bytes_impl {
+    ($($ty: ty,)+) => {
+        $(
+            paste! {
+                impl ToBeBytes for [<$ty:upper Pair>] {
+                    type ByteArray = [u8; size_of::<$ty>() * 2];
+                    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
+                    }
+                }
+            }
+        )+
+    }
+}
+
+macro_rules! triplet_to_be_bytes_impl {
+    ($($ty: ty,)+) => {
+        $(
+            paste! {
+                impl ToBeBytes for [<$ty:upper Triplet>] {
+                    type ByteArray = [u8; size_of::<$ty>() * 3];
+                    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
+                    }
+                }
+            }
+        )+
+    }
+}
+
+scalar_to_be_bytes_impl!(u8, u16, u32, u64, i8, i16, i32, i64, f32, f64,);
+
+impl ToBeBytes for U8Pair {
+    type ByteArray = [u8; 2];
+
+    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 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 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 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_to_be_bytes_impl!(u16, u32, u64, i16, i32, i64, f32, f64,);
+triplet_to_be_bytes_impl!(u16, u32, u64, i16, i32, i64, f32, f64,);
 
 #[derive(Debug, Copy, Clone)]
 pub enum AuxDataRaw {
-    U8(u8),
-    U8Pair((u8, u8)),
-    U8Triplet((u8, u8, u8)),
-    I8(i8),
-    I8Pair((i8, i8)),
-    I8Triplet((i8, i8, i8)),
-    U16(u16),
-    U16Pair((u16, u16)),
-    U16Triplet((u16, u16, u16)),
-    I16(i16),
-    I16Pair((i16, i16)),
-    I16Triplet((i16, i16, i16)),
-    U32(u32),
-    U32Pair((u32, u32)),
-    U32Triplet((u32, u32, u32)),
-    I32(i32),
-    I32Pair((i32, i32)),
-    I32Triplet((i32, i32, i32)),
-    F32(f32),
-    F32Pair((f32, f32)),
-    F32Triplet((f32, f32, f32)),
-    U64(u64),
-    F64(f64),
+    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),
+    F64(F64),
 }
 
 #[derive(Debug, Copy, Clone)]
@@ -50,7 +198,7 @@ macro_rules! from_conversions_for_raw {
         $(
             impl From<$raw_ty> for AuxDataRaw {
                 fn from(val: $raw_ty) -> Self {
-                    $TargetPath(val)
+                    $TargetPath(val.into())
                 }
             }
 
@@ -127,3 +275,47 @@ impl From<&str> for AuxData {
         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);
+    }
+}

From 6d90da15c8c0209e7a378f089e25353628b88061 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Mon, 31 Oct 2022 00:23:24 +0100
Subject: [PATCH 18/40] continued util module

---
 fsrc-core/src/event_man.rs |  41 +++++-----
 fsrc-core/src/events.rs    |  11 +--
 fsrc-core/src/util.rs      | 156 +++++++++++++++++++++++++++++++------
 spacepackets               |   2 +-
 4 files changed, 158 insertions(+), 52 deletions(-)

diff --git a/fsrc-core/src/event_man.rs b/fsrc-core/src/event_man.rs
index 381ccd7..98fe9a8 100644
--- a/fsrc-core/src/event_man.rs
+++ b/fsrc-core/src/event_man.rs
@@ -28,7 +28,7 @@
 //! 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.
 use crate::events::{EventU16, EventU32, GenericEvent, LargestEventRaw, LargestGroupIdRaw};
-use crate::util::{AuxData, AuxDataHeapless};
+use crate::util::{Params, ParamsHeapless};
 use alloc::boxed::Box;
 use alloc::vec;
 use alloc::vec::Vec;
@@ -44,15 +44,15 @@ enum ListenerType {
     All,
 }
 
-pub type EventWithHeaplessAuxData<Event> = (Event, Option<AuxDataHeapless>);
+pub type EventWithHeaplessAuxData<Event> = (Event, Option<ParamsHeapless>);
 pub type EventU32WithHeaplessAuxData = EventWithHeaplessAuxData<EventU32>;
 pub type EventU16WithHeaplessAuxData = EventWithHeaplessAuxData<EventU16>;
 
-pub type EventWithAuxData<Event> = (Event, Option<AuxData>);
+pub type EventWithAuxData<Event> = (Event, Option<Params>);
 pub type EventU32WithAuxData = EventWithAuxData<EventU32>;
 pub type EventU16WithAuxData = EventWithAuxData<EventU16>;
 
-pub trait SendEventProvider<Provider: GenericEvent, AuxDataProvider = AuxData> {
+pub trait SendEventProvider<Provider: GenericEvent, AuxDataProvider = Params> {
     type Error;
 
     fn id(&self) -> u32;
@@ -66,13 +66,13 @@ pub trait SendEventProvider<Provider: GenericEvent, AuxDataProvider = AuxData> {
     ) -> Result<(), Self::Error>;
 }
 
-struct Listener<E, Event: GenericEvent, AuxDataProvider = AuxData> {
+struct Listener<E, Event: GenericEvent, AuxDataProvider = Params> {
     ltype: ListenerType,
     send_provider: Box<dyn SendEventProvider<Event, AuxDataProvider, Error = E>>,
 }
 
 /// Generic abstraction for an event receiver.
-pub trait EventReceiver<Event: GenericEvent, AuxDataProvider = AuxData> {
+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.
     ///
@@ -88,13 +88,10 @@ pub trait EventReceiver<Event: GenericEvent, AuxDataProvider = AuxData> {
 ///
 ///  * `SendProviderError`: [SendEventProvider] error type
 ///  * `Event`: Concrete event provider, currently either [EventU32] or [EventU16]
-///  * `AuxDataProvider`: Concrete auxiliary data provder, currently either [AuxData] or
-///     [AuxDataHeapless]
-pub struct EventManager<
-    SendProviderError,
-    Event: GenericEvent = EventU32,
-    AuxDataProvider = AuxData,
-> {
+///  * `AuxDataProvider`: Concrete auxiliary data provder, currently either [Params] or
+///     [ParamsHeapless]
+pub struct EventManager<SendProviderError, Event: GenericEvent = EventU32, AuxDataProvider = Params>
+{
     listeners: HashMap<ListenerType, Vec<Listener<SendProviderError, Event, AuxDataProvider>>>,
     event_receiver: Box<dyn EventReceiver<Event, AuxDataProvider>>,
 }
@@ -231,15 +228,15 @@ impl<E, Event: GenericEvent + Copy, AuxDataProvider: Clone>
 pub mod stdmod {
     use crate::event_man::{EventReceiver, EventWithAuxData};
     use crate::events::{EventU16, EventU32, GenericEvent};
-    use crate::util::AuxData;
+    use crate::util::Params;
     use std::sync::mpsc::Receiver;
 
     pub struct MpscEventReceiver<Event: GenericEvent = EventU32> {
-        mpsc_receiver: Receiver<(Event, Option<AuxData>)>,
+        mpsc_receiver: Receiver<(Event, Option<Params>)>,
     }
 
     impl<Event: GenericEvent> MpscEventReceiver<Event> {
-        pub fn new(receiver: Receiver<(Event, Option<AuxData>)>) -> Self {
+        pub fn new(receiver: Receiver<(Event, Option<Params>)>) -> Self {
             Self {
                 mpsc_receiver: receiver,
             }
@@ -263,7 +260,7 @@ mod tests {
     use super::*;
     use crate::event_man::EventManager;
     use crate::events::{EventU32, GenericEvent, Severity};
-    use crate::util::AuxDataRaw;
+    use crate::util::ParamsRaw;
     use alloc::boxed::Box;
     use std::format;
     use std::sync::mpsc::{channel, Receiver, SendError, Sender};
@@ -286,7 +283,7 @@ mod tests {
         fn id(&self) -> u32 {
             self.id
         }
-        fn send(&mut self, event: EventU32, aux_data: Option<AuxData>) -> Result<(), Self::Error> {
+        fn send(&mut self, event: EventU32, aux_data: Option<Params>) -> Result<(), Self::Error> {
             self.mpsc_sender.send((event, aux_data))
         }
     }
@@ -294,7 +291,7 @@ mod tests {
     fn check_next_event(
         expected: EventU32,
         receiver: &Receiver<EventU32WithAuxData>,
-    ) -> Option<AuxData> {
+    ) -> Option<Params> {
         if let Ok(event) = receiver.try_recv() {
             assert_eq!(event.0, expected);
             return event.1;
@@ -303,7 +300,7 @@ mod tests {
     }
 
     fn check_handled_event(
-        res: HandlerResult<EventU32, AuxData>,
+        res: HandlerResult<EventU32, Params>,
         expected: EventU32,
         expected_num_sent: u32,
     ) {
@@ -368,7 +365,7 @@ mod tests {
         let single_event_listener = MpscEventSenderQueue::new(0, single_event_sender);
         event_man.subscribe_single(event_grp_0, single_event_listener);
         event_sender
-            .send((event_grp_0, Some(AuxData::Heapless((2_u32, 3_u32).into()))))
+            .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());
@@ -376,7 +373,7 @@ mod tests {
         let aux = check_next_event(event_grp_0, &single_event_receiver);
         assert!(aux.is_some());
         let aux = aux.unwrap();
-        if let AuxData::Heapless(AuxDataHeapless::Raw(AuxDataRaw::U32Pair(pair))) = aux {
+        if let Params::Heapless(ParamsHeapless::Raw(ParamsRaw::U32Pair(pair))) = aux {
             assert_eq!(pair.0, 2);
             assert_eq!(pair.1, 3);
         } else {
diff --git a/fsrc-core/src/events.rs b/fsrc-core/src/events.rs
index 02f4dfd..8920a12 100644
--- a/fsrc-core/src/events.rs
+++ b/fsrc-core/src/events.rs
@@ -27,6 +27,7 @@
 //!
 //! let small_event = EventU16::new(Severity::INFO, 3, 0);
 //! ```
+use core::fmt::Debug;
 use core::hash::Hash;
 use delegate::delegate;
 use spacepackets::ecss::{EcssEnumeration, ToBeBytes};
@@ -46,33 +47,33 @@ pub enum Severity {
     HIGH = 3,
 }
 
-pub trait HasSeverity {
+pub trait HasSeverity: Debug + PartialEq + Eq + Copy + Clone {
     const SEVERITY: Severity;
 }
 
 /// Type level support struct
-#[derive(Debug, PartialEq, Eq)]
+#[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)]
+#[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)]
+#[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)]
+#[derive(Debug, PartialEq, Eq, Copy, Clone)]
 pub struct SeverityHigh {}
 impl HasSeverity for SeverityHigh {
     const SEVERITY: Severity = Severity::HIGH;
diff --git a/fsrc-core/src/util.rs b/fsrc-core/src/util.rs
index bb9439e..5041306 100644
--- a/fsrc-core/src/util.rs
+++ b/fsrc-core/src/util.rs
@@ -1,6 +1,27 @@
 //! Utility types and enums
 //!
-//! This module contains helper types.
+//! This module contains various helper types. This includes wrapper for primitive rust types
+//! using the newtype pattern. This was also done for pairs and triplets of these primtive types.
+//!
+//! The [ToBeBytes] was implemented for those types as well, which allows to easily convert them
+//! into a network friendly raw byte format.
+//!
+//! The module also contains generic parameter enumerations.
+//!
+//! # Example for primitive type wrapper
+//!
+//! ```
+//! use fsrc_core::util::{ParamsRaw, ToBeBytes, U32Pair};
+//!
+//! let u32_pair = U32Pair(0x1010, 25);
+//! assert_eq!(u32_pair.0, 0x1010);
+//! assert_eq!(u32_pair.1, 25);
+//! let raw_buf = u32_pair.to_be_bytes();
+//! assert_eq!(raw_buf, [0, 0, 0x10, 0x10, 0, 0, 0, 25]);
+//!
+//! let params_raw: ParamsRaw = u32_pair.into();
+//! assert_eq!(params_raw, (0x1010_u32, 25_u32).into());
+//! ```
 use crate::pool::StoreAddr;
 #[cfg(feature = "alloc")]
 use alloc::string::String;
@@ -8,19 +29,21 @@ use alloc::string::String;
 use alloc::string::ToString;
 #[cfg(feature = "alloc")]
 use alloc::vec::Vec;
+use core::fmt::Debug;
 use core::mem::size_of;
 use paste::paste;
-use spacepackets::ecss::ToBeBytes;
+pub use spacepackets::ecss::ToBeBytes;
+use spacepackets::ecss::{EcssEnumU16, EcssEnumU32, EcssEnumU64, EcssEnumU8};
 
-macro_rules! primitive_newtypes {
+macro_rules! primitive_newtypes_with_eq {
     ($($ty: ty,)+) => {
         $(
             paste! {
-                #[derive(Debug, Copy, Clone)]
+                #[derive(Debug, Copy, Clone, PartialEq, Eq)]
                 pub struct [<$ty:upper>](pub $ty);
-                #[derive(Debug, Copy, Clone)]
+                #[derive(Debug, Copy, Clone, PartialEq, Eq)]
                 pub struct [<$ty:upper Pair>](pub $ty, pub $ty);
-                #[derive(Debug, Copy, Clone)]
+                #[derive(Debug, Copy, Clone, PartialEq, Eq)]
                 pub struct [<$ty:upper Triplet>](pub $ty, pub $ty, pub $ty);
 
                 impl From<$ty> for [<$ty:upper>] {
@@ -43,7 +66,39 @@ macro_rules! primitive_newtypes {
     }
 }
 
-primitive_newtypes!(u8, u16, u32, u64, i8, i16, i32, i64, f32, f64,);
+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);
+
+                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_to_be_bytes_impl {
     ($($ty: ty,)+) => {
@@ -154,8 +209,9 @@ impl ToBeBytes for I8Triplet {
 pair_to_be_bytes_impl!(u16, u32, u64, i16, i32, i64, f32, f64,);
 triplet_to_be_bytes_impl!(u16, u32, u64, i16, i32, i64, f32, f64,);
 
-#[derive(Debug, Copy, Clone)]
-pub enum AuxDataRaw {
+/// Generic enumeration for additonal parameters only consisting of primitive data types.
+#[derive(Debug, Copy, Clone, PartialEq)]
+pub enum ParamsRaw {
     U8(U8),
     U8Pair(U8Pair),
     U8Triplet(U8Triplet),
@@ -178,16 +234,45 @@ pub enum AuxDataRaw {
     F32Pair(F32Pair),
     F32Triplet(F32Triplet),
     U64(U64),
+    I64(I64),
     F64(F64),
 }
 
-#[derive(Debug, Copy, Clone)]
-pub enum AuxDataHeapless {
-    Raw(AuxDataRaw),
+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),
+}
+
+/// Generic enumeration for parameters which do not rely on heap allocations.
+#[derive(Debug, Copy, Clone, PartialEq)]
+pub enum ParamsHeapless {
+    Raw(ParamsRaw),
+    EcssEnum(EcssEnumParams),
     Store(StoreAddr),
 }
 
-impl From<StoreAddr> for AuxDataHeapless {
+impl From<StoreAddr> for ParamsHeapless {
     fn from(x: StoreAddr) -> Self {
         Self::Store(x)
     }
@@ -196,15 +281,15 @@ impl From<StoreAddr> for AuxDataHeapless {
 macro_rules! from_conversions_for_raw {
     ($(($raw_ty: ty, $TargetPath: path),)+) => {
         $(
-            impl From<$raw_ty> for AuxDataRaw {
+            impl From<$raw_ty> for ParamsRaw {
                 fn from(val: $raw_ty) -> Self {
                     $TargetPath(val.into())
                 }
             }
 
-            impl From<$raw_ty> for AuxDataHeapless {
+            impl From<$raw_ty> for ParamsHeapless {
                 fn from(val: $raw_ty) -> Self {
-                    AuxDataHeapless::Raw(val.into())
+                    ParamsHeapless::Raw(val.into())
                 }
             }
         )+
@@ -237,40 +322,42 @@ from_conversions_for_raw!(
     (f64, Self::F64),
 );
 
+/// Generic enumeration for additional parameters, including parameters which rely on heap
+/// allocations.
 #[cfg(feature = "alloc")]
 #[cfg_attr(doc_cfg, doc(cfg(feature = "alloc")))]
 #[derive(Debug, Clone)]
-pub enum AuxData {
-    Heapless(AuxDataHeapless),
+pub enum Params {
+    Heapless(ParamsHeapless),
     Vec(Vec<u8>),
     String(String),
 }
 
-impl From<AuxDataHeapless> for AuxData {
-    fn from(x: AuxDataHeapless) -> Self {
+impl From<ParamsHeapless> for Params {
+    fn from(x: ParamsHeapless) -> Self {
         Self::Heapless(x)
     }
 }
 
-impl From<Vec<u8>> for AuxData {
+impl From<Vec<u8>> for Params {
     fn from(val: Vec<u8>) -> Self {
         Self::Vec(val)
     }
 }
 
-impl From<&[u8]> for AuxData {
+impl From<&[u8]> for Params {
     fn from(val: &[u8]) -> Self {
         Self::Vec(val.to_vec())
     }
 }
 
-impl From<String> for AuxData {
+impl From<String> for Params {
     fn from(val: String) -> Self {
         Self::String(val)
     }
 }
 
-impl From<&str> for AuxData {
+impl From<&str> for Params {
     fn from(val: &str) -> Self {
         Self::String(val.to_string())
     }
@@ -318,4 +405,25 @@ mod tests {
         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/spacepackets b/spacepackets
index 65e85f2..38b789c 160000
--- a/spacepackets
+++ b/spacepackets
@@ -1 +1 @@
-Subproject commit 65e85f20e03507f19a0d5086ee19360ff7596c27
+Subproject commit 38b789ca6d061239e6cecc76f0843d6ba8b9bd01

From 7c34802ae0714aa4c25ec2f89ed89ba688c5985e Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Mon, 31 Oct 2022 00:34:11 +0100
Subject: [PATCH 19/40] run cargo update

---
 Cargo.lock                            | 16 ++---
 fsrc-core/src/lib.rs                  |  3 +-
 fsrc-core/src/util.rs                 |  7 +-
 fsrc-core/tests/pus_autogen_events.rs | 94 +++++++++++++++++++++++++++
 fsrc-core/tests/pus_events.rs         | 92 +-------------------------
 5 files changed, 109 insertions(+), 103 deletions(-)
 create mode 100644 fsrc-core/tests/pus_autogen_events.rs

diff --git a/Cargo.lock b/Cargo.lock
index b83d042..0ae6d25 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -104,9 +104,9 @@ checksum = "14c189c53d098945499cdfa7ecc63567cf3886b3332b312a5b4585d8d3a6a610"
 
 [[package]]
 name = "cc"
-version = "1.0.73"
+version = "1.0.74"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2fff2a6927b3bb87f9595d67196a70493f627687a71d87a0d692242c33f58c11"
+checksum = "581f5dba903aac52ea3feb5ec4810848460ee833876f1f9b0fdeab1f19091574"
 
 [[package]]
 name = "cfg-if"
@@ -372,9 +372,9 @@ dependencies = [
 
 [[package]]
 name = "iana-time-zone"
-version = "0.1.51"
+version = "0.1.53"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f5a6ef98976b22b3b7f2f3a806f858cb862044cfa66805aa3ad84cb3d3b785ed"
+checksum = "64c122667b287044802d6ce17ee2ddf13207ed924c712de9a66a5814d5b64765"
 dependencies = [
  "android_system_properties",
  "core-foundation-sys",
@@ -411,9 +411,9 @@ checksum = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646"
 
 [[package]]
 name = "libc"
-version = "0.2.135"
+version = "0.2.137"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "68783febc7782c6c5cb401fbda4de5a9898be1762314da0bb2c10ced61f18b0c"
+checksum = "fc7fcc620a3bff7cdd7a365be3376c97191aeaccc2a603e600951e452615bf89"
 
 [[package]]
 name = "link-cplusplus"
@@ -495,9 +495,9 @@ dependencies = [
 
 [[package]]
 name = "once_cell"
-version = "1.15.0"
+version = "1.16.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e82dad04139b71a90c080c8463fe0dc7902db5192d939bd0950f074d014339e1"
+checksum = "86f0b0d4bf799edbc74508c1e8bf170ff5f41238e5f8225603ca7caaae2b7860"
 
 [[package]]
 name = "parking_lot_core"
diff --git a/fsrc-core/src/lib.rs b/fsrc-core/src/lib.rs
index c5178d4..789dc36 100644
--- a/fsrc-core/src/lib.rs
+++ b/fsrc-core/src/lib.rs
@@ -12,6 +12,7 @@
 extern crate alloc;
 #[cfg(any(feature = "std", test))]
 extern crate std;
+extern crate downcast_rs;
 
 pub mod error;
 #[cfg(feature = "alloc")]
@@ -29,5 +30,3 @@ pub mod pool;
 pub mod pus;
 pub mod tmtc;
 pub mod util;
-
-extern crate downcast_rs;
diff --git a/fsrc-core/src/util.rs b/fsrc-core/src/util.rs
index 5041306..27afd18 100644
--- a/fsrc-core/src/util.rs
+++ b/fsrc-core/src/util.rs
@@ -1,8 +1,7 @@
-//! Utility types and enums
+//! Utility types and enums.
 //!
 //! This module contains various helper types. This includes wrapper for primitive rust types
-//! using the newtype pattern. This was also done for pairs and triplets of these primtive types.
-//!
+//! using the newtype pattern. This was also done for pairs and triplets of these primitive types.
 //! The [ToBeBytes] was implemented for those types as well, which allows to easily convert them
 //! into a network friendly raw byte format.
 //!
@@ -345,6 +344,7 @@ impl From<Vec<u8>> for Params {
     }
 }
 
+/// Converts a byte slice into the [Params::Vec] variant
 impl From<&[u8]> for Params {
     fn from(val: &[u8]) -> Self {
         Self::Vec(val.to_vec())
@@ -357,6 +357,7 @@ impl From<String> for Params {
     }
 }
 
+/// Converts a string slice into the [Params::String] variant
 impl From<&str> for Params {
     fn from(val: &str) -> Self {
         Self::String(val.to_string())
diff --git a/fsrc-core/tests/pus_autogen_events.rs b/fsrc-core/tests/pus_autogen_events.rs
new file mode 100644
index 0000000..03b4006
--- /dev/null
+++ b/fsrc-core/tests/pus_autogen_events.rs
@@ -0,0 +1,94 @@
+#![allow(dead_code, unused_imports)]
+
+use fsrc_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/fsrc-core/tests/pus_events.rs b/fsrc-core/tests/pus_events.rs
index b304939..99c13c5 100644
--- a/fsrc-core/tests/pus_events.rs
+++ b/fsrc-core/tests/pus_events.rs
@@ -1,94 +1,6 @@
-#![allow(dead_code, unused_imports)]
-
-use fsrc_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 =
+
+    //let event_man;
 }

From 01766464ebe568ff2cece4aaefcade6c5cf57faf Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Mon, 31 Oct 2022 01:25:02 +0100
Subject: [PATCH 20/40] created basic integration test

---
 fsrc-core/src/lib.rs              |  2 +-
 fsrc-core/src/pus/event.rs        | 22 +++----
 fsrc-core/src/pus/event_man.rs    | 96 ++++++++++++++++++++-----------
 fsrc-core/src/pus/mod.rs          | 14 ++++-
 fsrc-core/src/pus/verification.rs | 56 ++++++++++--------
 fsrc-core/tests/pus_events.rs     | 35 ++++++++++-
 6 files changed, 150 insertions(+), 75 deletions(-)

diff --git a/fsrc-core/src/lib.rs b/fsrc-core/src/lib.rs
index 789dc36..5ac3541 100644
--- a/fsrc-core/src/lib.rs
+++ b/fsrc-core/src/lib.rs
@@ -10,9 +10,9 @@
 #![no_std]
 #[cfg(feature = "alloc")]
 extern crate alloc;
+extern crate downcast_rs;
 #[cfg(any(feature = "std", test))]
 extern crate std;
-extern crate downcast_rs;
 
 pub mod error;
 #[cfg(feature = "alloc")]
diff --git a/fsrc-core/src/pus/event.rs b/fsrc-core/src/pus/event.rs
index bfc3fa0..f7b7e36 100644
--- a/fsrc-core/src/pus/event.rs
+++ b/fsrc-core/src/pus/event.rs
@@ -46,7 +46,7 @@ impl EventReporterBase {
     pub fn event_info<E>(
         &mut self,
         buf: &mut [u8],
-        sender: &mut (impl EcssTmSender<E> + ?Sized),
+        sender: &mut (impl EcssTmSender<Error = E> + ?Sized),
         time_stamp: &[u8],
         event_id: impl EcssEnumeration,
         aux_data: Option<&[u8]>,
@@ -64,7 +64,7 @@ impl EventReporterBase {
     pub fn event_low_severity<E>(
         &mut self,
         buf: &mut [u8],
-        sender: &mut (impl EcssTmSender<E> + ?Sized),
+        sender: &mut (impl EcssTmSender<Error = E> + ?Sized),
         time_stamp: &[u8],
         event_id: impl EcssEnumeration,
         aux_data: Option<&[u8]>,
@@ -82,7 +82,7 @@ impl EventReporterBase {
     pub fn event_medium_severity<E>(
         &mut self,
         buf: &mut [u8],
-        sender: &mut (impl EcssTmSender<E> + ?Sized),
+        sender: &mut (impl EcssTmSender<Error = E> + ?Sized),
         time_stamp: &[u8],
         event_id: impl EcssEnumeration,
         aux_data: Option<&[u8]>,
@@ -100,7 +100,7 @@ impl EventReporterBase {
     pub fn event_high_severity<E>(
         &mut self,
         buf: &mut [u8],
-        sender: &mut (impl EcssTmSender<E> + ?Sized),
+        sender: &mut (impl EcssTmSender<Error = E> + ?Sized),
         time_stamp: &[u8],
         event_id: impl EcssEnumeration,
         aux_data: Option<&[u8]>,
@@ -119,7 +119,7 @@ impl EventReporterBase {
         &mut self,
         buf: &mut [u8],
         subservice: Subservices,
-        sender: &mut (impl EcssTmSender<E> + ?Sized),
+        sender: &mut (impl EcssTmSender<Error = E> + ?Sized),
         time_stamp: &[u8],
         event_id: impl EcssEnumeration,
         aux_data: Option<&[u8]>,
@@ -188,7 +188,7 @@ mod allocvec {
         }
         pub fn event_info<E>(
             &mut self,
-            sender: &mut (impl EcssTmSender<E> + ?Sized),
+            sender: &mut (impl EcssTmSender<Error = E> + ?Sized),
             time_stamp: &[u8],
             event_id: impl EcssEnumeration,
             aux_data: Option<&[u8]>,
@@ -204,7 +204,7 @@ mod allocvec {
 
         pub fn event_low_severity<E>(
             &mut self,
-            sender: &mut (impl EcssTmSender<E> + ?Sized),
+            sender: &mut (impl EcssTmSender<Error = E> + ?Sized),
             time_stamp: &[u8],
             event_id: impl EcssEnumeration,
             aux_data: Option<&[u8]>,
@@ -220,7 +220,7 @@ mod allocvec {
 
         pub fn event_medium_severity<E>(
             &mut self,
-            sender: &mut (impl EcssTmSender<E> + ?Sized),
+            sender: &mut (impl EcssTmSender<Error = E> + ?Sized),
             time_stamp: &[u8],
             event_id: impl EcssEnumeration,
             aux_data: Option<&[u8]>,
@@ -236,7 +236,7 @@ mod allocvec {
 
         pub fn event_high_severity<E>(
             &mut self,
-            sender: &mut (impl EcssTmSender<E> + ?Sized),
+            sender: &mut (impl EcssTmSender<Error = E> + ?Sized),
             time_stamp: &[u8],
             event_id: impl EcssEnumeration,
             aux_data: Option<&[u8]>,
@@ -279,7 +279,9 @@ mod tests {
         pub service_queue: VecDeque<TmInfo>,
     }
 
-    impl EcssTmSender<()> for TestSender {
+    impl EcssTmSender for TestSender {
+        type Error = ();
+
         fn send_tm(&mut self, tm: PusTm) -> Result<(), EcssTmError<()>> {
             assert!(tm.source_data().is_some());
             let src_data = tm.source_data().unwrap();
diff --git a/fsrc-core/src/pus/event_man.rs b/fsrc-core/src/pus/event_man.rs
index 5b48143..33d860f 100644
--- a/fsrc-core/src/pus/event_man.rs
+++ b/fsrc-core/src/pus/event_man.rs
@@ -1,9 +1,10 @@
-use crate::events::{EventU16TypedSev, EventU32TypedSev, GenericEvent, HasSeverity, Severity};
+use crate::events::{EventU32, EventU32TypedSev, GenericEvent, HasSeverity, Severity};
 use alloc::boxed::Box;
 use core::hash::Hash;
 use hashbrown::HashSet;
 
-use crate::pus::event::EventReporter;
+#[cfg(feature = "alloc")]
+pub use crate::pus::event::EventReporter;
 use crate::pus::{EcssTmError, EcssTmSender};
 #[cfg(feature = "heapless")]
 #[cfg_attr(doc_cfg, doc(cfg(feature = "heapless")))]
@@ -33,9 +34,16 @@ pub trait PusEventMgmtBackendProvider<Provider: GenericEvent> {
 ///
 /// 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.
-#[derive(Default)]
-pub struct DefaultPusMgmtBackendProvider<Provider: GenericEvent> {
-    disabled: HashSet<Provider>,
+pub struct DefaultPusMgmtBackendProvider<Event: GenericEvent = EventU32> {
+    disabled: HashSet<Event>,
+}
+
+impl<Event: GenericEvent> Default for DefaultPusMgmtBackendProvider<Event> {
+    fn default() -> Self {
+        Self {
+            disabled: HashSet::default(),
+        }
+    }
 }
 
 impl<Provider: GenericEvent + PartialEq + Eq + Hash + Copy + Clone>
@@ -91,12 +99,33 @@ pub mod heapless_mod {
     }
 }
 
-pub struct PusEventManager<BackendError, Provider: GenericEvent> {
+#[derive(Debug)]
+pub enum EventManError<SenderE> {
+    EcssTmError(EcssTmError<SenderE>),
+    SeverityMissmatch(Severity, Severity),
+}
+
+impl<SenderE> From<EcssTmError<SenderE>> for EventManError<SenderE> {
+    fn from(v: EcssTmError<SenderE>) -> Self {
+        Self::EcssTmError(v)
+    }
+}
+
+pub struct PusEventTmManager<BackendError, Provider: GenericEvent> {
     reporter: EventReporter,
     backend: Box<dyn PusEventMgmtBackendProvider<Provider, Error = BackendError>>,
 }
 
-impl<BackendError, Event: GenericEvent> PusEventManager<BackendError, Event> {
+impl<BackendError, Provider: GenericEvent> PusEventTmManager<BackendError, Provider> {
+    pub fn new(
+        reporter: EventReporter,
+        backend: Box<dyn PusEventMgmtBackendProvider<Provider, Error = BackendError>>,
+    ) -> Self {
+        Self { reporter, backend }
+    }
+}
+
+impl<BackendError, Event: GenericEvent> PusEventTmManager<BackendError, Event> {
     pub fn enable_tm_for_event(&mut self, event: &Event) -> Result<bool, BackendError> {
         self.backend.enable_event_reporting(event)
     }
@@ -108,59 +137,56 @@ impl<BackendError, Event: GenericEvent> PusEventManager<BackendError, Event> {
     pub fn generate_pus_event_tm_generic<E>(
         &mut self,
         severity: Severity,
-        sender: &mut (impl EcssTmSender<E> + ?Sized),
+        sender: &mut (impl EcssTmSender<Error = E> + ?Sized),
         time_stamp: &[u8],
         event: Event,
         aux_data: Option<&[u8]>,
-    ) -> Result<bool, EcssTmError<E>> {
+    ) -> Result<bool, EventManError<E>> {
         if !self.backend.event_enabled(&event) {
             return Ok(false);
         }
+        if event.severity() != severity {
+            return Err(EventManError::SeverityMissmatch(severity, event.severity()));
+        }
         match severity {
             Severity::INFO => self
                 .reporter
                 .event_info(sender, time_stamp, event, aux_data)
-                .map(|_| true),
+                .map(|_| true)
+                .map_err(|e| e.into()),
             Severity::LOW => self
                 .reporter
                 .event_low_severity(sender, time_stamp, event, aux_data)
-                .map(|_| true),
+                .map(|_| true)
+                .map_err(|e| e.into()),
             Severity::MEDIUM => self
                 .reporter
                 .event_medium_severity(sender, time_stamp, event, aux_data)
-                .map(|_| true),
+                .map(|_| true)
+                .map_err(|e| e.into()),
             Severity::HIGH => self
                 .reporter
                 .event_high_severity(sender, time_stamp, event, aux_data)
-                .map(|_| true),
+                .map(|_| true)
+                .map_err(|e| e.into()),
         }
     }
 }
 
-impl<BackendError, SEVERITY: HasSeverity>
-    PusEventManager<BackendError, EventU32TypedSev<SEVERITY>>
-{
-    pub fn generate_pus_event_tm<E>(
+impl<BackendError> PusEventTmManager<BackendError, EventU32> {
+    pub fn generate_pus_event_tm<E, Severity: HasSeverity>(
         &mut self,
-        sender: &mut (impl EcssTmSender<E> + ?Sized),
+        sender: &mut (impl EcssTmSender<Error = E> + ?Sized),
         time_stamp: &[u8],
-        event: EventU32TypedSev<SEVERITY>,
+        event: EventU32TypedSev<Severity>,
         aux_data: Option<&[u8]>,
-    ) -> Result<bool, EcssTmError<E>> {
-        self.generate_pus_event_tm_generic(SEVERITY::SEVERITY, sender, time_stamp, event, aux_data)
-    }
-}
-
-impl<BackendError, SEVERITY: HasSeverity>
-    PusEventManager<BackendError, EventU16TypedSev<SEVERITY>>
-{
-    pub fn generate_pus_event_tm<E>(
-        &mut self,
-        sender: &mut (impl EcssTmSender<E> + ?Sized),
-        time_stamp: &[u8],
-        event: EventU16TypedSev<SEVERITY>,
-        aux_data: Option<&[u8]>,
-    ) -> Result<bool, EcssTmError<E>> {
-        self.generate_pus_event_tm_generic(SEVERITY::SEVERITY, sender, time_stamp, event, aux_data)
+    ) -> Result<bool, EventManError<E>> {
+        self.generate_pus_event_tm_generic(
+            Severity::SEVERITY,
+            sender,
+            time_stamp,
+            event.into(),
+            aux_data,
+        )
     }
 }
diff --git a/fsrc-core/src/pus/mod.rs b/fsrc-core/src/pus/mod.rs
index 82e49f9..0703a8e 100644
--- a/fsrc-core/src/pus/mod.rs
+++ b/fsrc-core/src/pus/mod.rs
@@ -26,6 +26,12 @@ pub enum EcssTmError<E> {
     PusError(PusError),
 }
 
+impl<E> From<PusError> for EcssTmError<E> {
+    fn from(e: PusError) -> Self {
+        EcssTmError::PusError(e)
+    }
+}
+
 impl<E> From<ByteConversionError> for EcssTmError<E> {
     fn from(e: ByteConversionError) -> Self {
         EcssTmError::ByteConversionError(e)
@@ -37,11 +43,13 @@ impl<E> From<ByteConversionError> for EcssTmError<E> {
 /// This sender object is responsible for sending telemetry to a TM sink. 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 EcssTmSender<E>: Downcast + Send {
-    fn send_tm(&mut self, tm: PusTm) -> Result<(), EcssTmError<E>>;
+pub trait EcssTmSender: Downcast + Send {
+    type Error;
+
+    fn send_tm(&mut self, tm: PusTm) -> Result<(), EcssTmError<Self::Error>>;
 }
 
-impl_downcast!(EcssTmSender<E>);
+impl_downcast!(EcssTmSender assoc Error);
 
 pub(crate) fn source_buffer_large_enough<E>(cap: usize, len: usize) -> Result<(), EcssTmError<E>> {
     if len > cap {
diff --git a/fsrc-core/src/pus/verification.rs b/fsrc-core/src/pus/verification.rs
index 41b74e1..996d558 100644
--- a/fsrc-core/src/pus/verification.rs
+++ b/fsrc-core/src/pus/verification.rs
@@ -312,7 +312,7 @@ impl VerificationReporterBasic {
         &mut self,
         buf: &mut [u8],
         token: VerificationToken<StateNone>,
-        sender: &mut (impl EcssTmSender<E> + ?Sized),
+        sender: &mut (impl EcssTmSender<Error = E> + ?Sized),
         time_stamp: &[u8],
     ) -> Result<VerificationToken<StateAccepted>, VerificationErrorWithToken<E, StateNone>> {
         let tm = self
@@ -339,7 +339,7 @@ impl VerificationReporterBasic {
         &mut self,
         buf: &mut [u8],
         token: VerificationToken<StateNone>,
-        sender: &mut (impl EcssTmSender<E> + ?Sized),
+        sender: &mut (impl EcssTmSender<Error = E> + ?Sized),
         params: FailParams,
     ) -> Result<(), VerificationErrorWithToken<E, StateNone>> {
         let tm = self
@@ -365,7 +365,7 @@ impl VerificationReporterBasic {
         &mut self,
         buf: &mut [u8],
         token: VerificationToken<StateAccepted>,
-        sender: &mut (impl EcssTmSender<E> + ?Sized),
+        sender: &mut (impl EcssTmSender<Error = E> + ?Sized),
         time_stamp: &[u8],
     ) -> Result<VerificationToken<StateStarted>, VerificationErrorWithToken<E, StateAccepted>> {
         let tm = self
@@ -395,7 +395,7 @@ impl VerificationReporterBasic {
         &mut self,
         buf: &mut [u8],
         token: VerificationToken<StateAccepted>,
-        sender: &mut (impl EcssTmSender<E> + ?Sized),
+        sender: &mut (impl EcssTmSender<Error = E> + ?Sized),
         params: FailParams,
     ) -> Result<(), VerificationErrorWithToken<E, StateAccepted>> {
         let tm = self
@@ -421,7 +421,7 @@ impl VerificationReporterBasic {
         &mut self,
         buf: &mut [u8],
         token: &VerificationToken<StateStarted>,
-        sender: &mut (impl EcssTmSender<E> + ?Sized),
+        sender: &mut (impl EcssTmSender<Error = E> + ?Sized),
         time_stamp: &[u8],
         step: impl EcssEnumeration,
     ) -> Result<(), EcssTmError<E>> {
@@ -445,7 +445,7 @@ impl VerificationReporterBasic {
         &mut self,
         buf: &mut [u8],
         token: VerificationToken<StateStarted>,
-        sender: &mut (impl EcssTmSender<E> + ?Sized),
+        sender: &mut (impl EcssTmSender<Error = E> + ?Sized),
         params: FailParamsWithStep,
     ) -> Result<(), VerificationErrorWithToken<E, StateStarted>> {
         let tm = self
@@ -472,7 +472,7 @@ impl VerificationReporterBasic {
         &mut self,
         buf: &mut [u8],
         token: VerificationToken<StateStarted>,
-        sender: &mut (impl EcssTmSender<E> + ?Sized),
+        sender: &mut (impl EcssTmSender<Error = E> + ?Sized),
         time_stamp: &[u8],
     ) -> Result<(), VerificationErrorWithToken<E, StateStarted>> {
         let tm = self
@@ -499,7 +499,7 @@ impl VerificationReporterBasic {
         &mut self,
         buf: &mut [u8],
         token: VerificationToken<StateStarted>,
-        sender: &mut (impl EcssTmSender<E> + ?Sized),
+        sender: &mut (impl EcssTmSender<Error = E> + ?Sized),
         params: FailParams,
     ) -> Result<(), VerificationErrorWithToken<E, StateStarted>> {
         let tm = self
@@ -685,7 +685,7 @@ mod allocmod {
         pub fn acceptance_success<E>(
             &mut self,
             token: VerificationToken<StateNone>,
-            sender: &mut (impl EcssTmSender<E> + ?Sized),
+            sender: &mut (impl EcssTmSender<Error = E> + ?Sized),
             time_stamp: &[u8],
         ) -> Result<VerificationToken<StateAccepted>, VerificationErrorWithToken<E, StateNone>>
         {
@@ -701,7 +701,7 @@ mod allocmod {
         pub fn acceptance_failure<E>(
             &mut self,
             token: VerificationToken<StateNone>,
-            sender: &mut (impl EcssTmSender<E> + ?Sized),
+            sender: &mut (impl EcssTmSender<Error = E> + ?Sized),
             params: FailParams,
         ) -> Result<(), VerificationErrorWithToken<E, StateNone>> {
             self.reporter.acceptance_failure(
@@ -718,7 +718,7 @@ mod allocmod {
         pub fn start_success<E>(
             &mut self,
             token: VerificationToken<StateAccepted>,
-            sender: &mut (impl EcssTmSender<E> + ?Sized),
+            sender: &mut (impl EcssTmSender<Error = E> + ?Sized),
             time_stamp: &[u8],
         ) -> Result<VerificationToken<StateStarted>, VerificationErrorWithToken<E, StateAccepted>>
         {
@@ -737,7 +737,7 @@ mod allocmod {
         pub fn start_failure<E>(
             &mut self,
             token: VerificationToken<StateAccepted>,
-            sender: &mut (impl EcssTmSender<E> + ?Sized),
+            sender: &mut (impl EcssTmSender<Error = E> + ?Sized),
             params: FailParams,
         ) -> Result<(), VerificationErrorWithToken<E, StateAccepted>> {
             self.reporter
@@ -750,7 +750,7 @@ mod allocmod {
         pub fn step_success<E>(
             &mut self,
             token: &VerificationToken<StateStarted>,
-            sender: &mut (impl EcssTmSender<E> + ?Sized),
+            sender: &mut (impl EcssTmSender<Error = E> + ?Sized),
             time_stamp: &[u8],
             step: impl EcssEnumeration,
         ) -> Result<(), EcssTmError<E>> {
@@ -770,7 +770,7 @@ mod allocmod {
         pub fn step_failure<E>(
             &mut self,
             token: VerificationToken<StateStarted>,
-            sender: &mut (impl EcssTmSender<E> + ?Sized),
+            sender: &mut (impl EcssTmSender<Error = E> + ?Sized),
             params: FailParamsWithStep,
         ) -> Result<(), VerificationErrorWithToken<E, StateStarted>> {
             self.reporter
@@ -784,7 +784,7 @@ mod allocmod {
         pub fn completion_success<E>(
             &mut self,
             token: VerificationToken<StateStarted>,
-            sender: &mut (impl EcssTmSender<E> + ?Sized),
+            sender: &mut (impl EcssTmSender<Error = E> + ?Sized),
             time_stamp: &[u8],
         ) -> Result<(), VerificationErrorWithToken<E, StateStarted>> {
             self.reporter.completion_success(
@@ -802,7 +802,7 @@ mod allocmod {
         pub fn completion_failure<E>(
             &mut self,
             token: VerificationToken<StateStarted>,
-            sender: &mut (impl EcssTmSender<E> + ?Sized),
+            sender: &mut (impl EcssTmSender<Error = E> + ?Sized),
             params: FailParams,
         ) -> Result<(), VerificationErrorWithToken<E, StateStarted>> {
             self.reporter.completion_failure(
@@ -818,18 +818,18 @@ mod allocmod {
     /// API as [VerificationReporter] but without the explicit sender arguments.
     pub struct VerificationReporterWithSender<E> {
         pub reporter: VerificationReporter,
-        pub sender: Box<dyn EcssTmSender<E>>,
+        pub sender: Box<dyn EcssTmSender<Error = E>>,
     }
 
     impl<E: 'static> VerificationReporterWithSender<E> {
-        pub fn new(cfg: VerificationReporterCfg, sender: Box<dyn EcssTmSender<E>>) -> Self {
+        pub fn new(cfg: VerificationReporterCfg, sender: Box<dyn EcssTmSender<Error = E>>) -> Self {
             let reporter = VerificationReporter::new(cfg);
             Self::new_from_reporter(reporter, sender)
         }
 
         pub fn new_from_reporter(
             reporter: VerificationReporter,
-            sender: Box<dyn EcssTmSender<E>>,
+            sender: Box<dyn EcssTmSender<Error = E>>,
         ) -> Self {
             Self { reporter, sender }
         }
@@ -997,7 +997,9 @@ mod stdmod {
     }
 
     //noinspection RsTraitImplementation
-    impl EcssTmSender<StdVerifSenderError> for MpscVerifSender {
+    impl EcssTmSender for MpscVerifSender {
+        type Error = StdVerifSenderError;
+
         delegate!(
             to self.base {
                 fn send_tm(&mut self, tm: PusTm) -> Result<(), EcssTmError<StdVerifSenderError>>;
@@ -1028,7 +1030,9 @@ mod stdmod {
     }
 
     //noinspection RsTraitImplementation
-    impl EcssTmSender<StdVerifSenderError> for CrossbeamVerifSender {
+    impl EcssTmSender for CrossbeamVerifSender {
+        type Error = StdVerifSenderError;
+
         delegate!(
             to self.base {
                 fn send_tm(&mut self, tm: PusTm) -> Result<(), EcssTmError<StdVerifSenderError>>;
@@ -1039,8 +1043,9 @@ mod stdmod {
     unsafe impl Sync for CrossbeamVerifSender {}
     unsafe impl Send for CrossbeamVerifSender {}
 
-    impl<S: SendBackend + 'static> EcssTmSender<StdVerifSenderError> for StdSenderBase<S> {
-        fn send_tm(&mut self, tm: PusTm) -> Result<(), EcssTmError<StdVerifSenderError>> {
+    impl<S: SendBackend + 'static> EcssTmSender for StdSenderBase<S> {
+        type Error = StdVerifSenderError;
+        fn send_tm(&mut self, tm: PusTm) -> Result<(), EcssTmError<Self::Error>> {
             let operation = |mut mg: RwLockWriteGuard<ShareablePoolProvider>| {
                 let (addr, buf) = mg.free_element(tm.len_packed())?;
                 tm.write_to_bytes(buf).map_err(EcssTmError::PusError)?;
@@ -1096,8 +1101,9 @@ mod tests {
         pub service_queue: VecDeque<TmInfo>,
     }
 
-    impl EcssTmSender<()> for TestSender {
-        fn send_tm(&mut self, tm: PusTm) -> Result<(), EcssTmError<()>> {
+    impl EcssTmSender for TestSender {
+        type Error = ();
+        fn send_tm(&mut self, tm: PusTm) -> Result<(), EcssTmError<Self::Error>> {
             assert_eq!(PusPacket::service(&tm), 1);
             assert!(tm.source_data().is_some());
             let mut time_stamp = [0; 7];
diff --git a/fsrc-core/tests/pus_events.rs b/fsrc-core/tests/pus_events.rs
index 99c13c5..85b8a29 100644
--- a/fsrc-core/tests/pus_events.rs
+++ b/fsrc-core/tests/pus_events.rs
@@ -1,6 +1,39 @@
+use fsrc_core::events::{EventU32, EventU32TypedSev, Severity, SeverityInfo};
+use fsrc_core::pus::event_man::{DefaultPusMgmtBackendProvider, EventReporter, PusEventTmManager};
+use fsrc_core::pus::{EcssTmError, EcssTmSender};
+use spacepackets::tm::PusTm;
+use std::sync::mpsc::{channel, SendError};
+
+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];
+
+struct EventTmSender {
+    sender: std::sync::mpsc::Sender<Vec<u8>>,
+}
+
+impl EcssTmSender for EventTmSender {
+    type Error = SendError<Vec<u8>>;
+    fn send_tm(&mut self, tm: PusTm) -> Result<(), EcssTmError<Self::Error>> {
+        let mut vec = Vec::new();
+        tm.append_to_vec(&mut vec)?;
+        self.sender.send(vec).map_err(EcssTmError::SendError)?;
+        Ok(())
+    }
+}
 
 #[test]
 fn main() {
-
+    let reporter = EventReporter::new(0x02, 128).expect("Creating event repoter failed");
+    let backend = DefaultPusMgmtBackendProvider::<EventU32>::default();
+    let mut event_man = PusEventTmManager::new(reporter, Box::new(backend));
+    let (event_tx, event_rx) = channel();
+    let mut sender = EventTmSender { sender: event_tx };
+    event_man
+        .generate_pus_event_tm(&mut sender, &EMPTY_STAMP, INFO_EVENT, None)
+        .expect("Sending info event failed");
+    let packet = event_rx.recv().expect("Receiving event TM failed");
+    println!("{:?}", packet);
     //let event_man;
 }

From 0ac9f888b2af8d72ca30bb3e5727ef9d0758a717 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Mon, 31 Oct 2022 01:25:55 +0100
Subject: [PATCH 21/40] check retval

---
 fsrc-core/tests/pus_events.rs | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/fsrc-core/tests/pus_events.rs b/fsrc-core/tests/pus_events.rs
index 85b8a29..e4faf35 100644
--- a/fsrc-core/tests/pus_events.rs
+++ b/fsrc-core/tests/pus_events.rs
@@ -30,9 +30,11 @@ fn main() {
     let mut event_man = PusEventTmManager::new(reporter, Box::new(backend));
     let (event_tx, event_rx) = channel();
     let mut sender = EventTmSender { sender: event_tx };
-    event_man
+    let event_sent = event_man
         .generate_pus_event_tm(&mut sender, &EMPTY_STAMP, INFO_EVENT, None)
         .expect("Sending info event failed");
+
+    assert!(event_sent);
     let packet = event_rx.recv().expect("Receiving event TM failed");
     println!("{:?}", packet);
     //let event_man;

From cc1f3ed091fe7c5042e7e91ef4d4c569b1612281 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 1 Nov 2022 18:03:01 +0100
Subject: [PATCH 22/40] basic unittests for PUS event man

---
 fsrc-core/src/events.rs           |  24 +++++++
 fsrc-core/src/pus/event_man.rs    | 109 ++++++++++++++++++++++++++++++
 fsrc-core/src/pus/verification.rs |   3 +-
 fsrc-core/tests/pus_events.rs     |  21 ++++--
 4 files changed, 150 insertions(+), 7 deletions(-)

diff --git a/fsrc-core/src/events.rs b/fsrc-core/src/events.rs
index 8920a12..d0ea2f2 100644
--- a/fsrc-core/src/events.rs
+++ b/fsrc-core/src/events.rs
@@ -285,6 +285,18 @@ impl<SEVERITY: HasSeverity> From<EventU32TypedSev<SEVERITY>> for EventU32 {
     }
 }
 
+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 {
@@ -423,6 +435,18 @@ pub struct EventU16TypedSev<SEVERITY> {
     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
diff --git a/fsrc-core/src/pus/event_man.rs b/fsrc-core/src/pus/event_man.rs
index 33d860f..11075d9 100644
--- a/fsrc-core/src/pus/event_man.rs
+++ b/fsrc-core/src/pus/event_man.rs
@@ -174,6 +174,20 @@ impl<BackendError, Event: GenericEvent> PusEventTmManager<BackendError, Event> {
 }
 
 impl<BackendError> PusEventTmManager<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<E, Severity: HasSeverity>(
         &mut self,
         sender: &mut (impl EcssTmSender<Error = E> + ?Sized),
@@ -190,3 +204,98 @@ impl<BackendError> PusEventTmManager<BackendError, EventU32> {
         )
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::events::SeverityInfo;
+    use spacepackets::tm::PusTm;
+    use std::sync::mpsc::{channel, SendError, TryRecvError};
+    use std::vec::Vec;
+
+    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];
+
+    struct EventTmSender {
+        sender: std::sync::mpsc::Sender<Vec<u8>>,
+    }
+
+    impl EcssTmSender for EventTmSender {
+        type Error = SendError<Vec<u8>>;
+        fn send_tm(&mut self, tm: PusTm) -> Result<(), EcssTmError<Self::Error>> {
+            let mut vec = Vec::new();
+            tm.append_to_vec(&mut vec)?;
+            self.sender.send(vec).map_err(EcssTmError::SendError)?;
+            Ok(())
+        }
+    }
+
+    fn create_basic_man() -> PusEventTmManager<(), EventU32> {
+        let reporter = EventReporter::new(0x02, 128).expect("Creating event repoter failed");
+        let backend = DefaultPusMgmtBackendProvider::<EventU32>::default();
+        PusEventTmManager::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 = EventTmSender { 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 = EventTmSender { sender: 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(
+                Severity::LOW,
+                &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 = EventTmSender { sender: 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/fsrc-core/src/pus/verification.rs b/fsrc-core/src/pus/verification.rs
index 996d558..0908b01 100644
--- a/fsrc-core/src/pus/verification.rs
+++ b/fsrc-core/src/pus/verification.rs
@@ -1131,7 +1131,8 @@ mod tests {
     #[derive(Default)]
     struct FallibleSender {}
 
-    impl EcssTmSender<DummyError> for FallibleSender {
+    impl EcssTmSender for FallibleSender {
+        type Error = DummyError;
         fn send_tm(&mut self, _: PusTm) -> Result<(), EcssTmError<DummyError>> {
             Err(EcssTmError::SendError(DummyError {}))
         }
diff --git a/fsrc-core/tests/pus_events.rs b/fsrc-core/tests/pus_events.rs
index e4faf35..0534e96 100644
--- a/fsrc-core/tests/pus_events.rs
+++ b/fsrc-core/tests/pus_events.rs
@@ -2,7 +2,7 @@ use fsrc_core::events::{EventU32, EventU32TypedSev, Severity, SeverityInfo};
 use fsrc_core::pus::event_man::{DefaultPusMgmtBackendProvider, EventReporter, PusEventTmManager};
 use fsrc_core::pus::{EcssTmError, EcssTmSender};
 use spacepackets::tm::PusTm;
-use std::sync::mpsc::{channel, SendError};
+use std::sync::mpsc::{channel, SendError, TryRecvError};
 
 const INFO_EVENT: EventU32TypedSev<SeverityInfo> =
     EventU32TypedSev::<SeverityInfo>::const_new(1, 0);
@@ -24,18 +24,27 @@ impl EcssTmSender for EventTmSender {
 }
 
 #[test]
-fn main() {
+fn test_basic() {
     let reporter = EventReporter::new(0x02, 128).expect("Creating event repoter failed");
     let backend = DefaultPusMgmtBackendProvider::<EventU32>::default();
     let mut event_man = PusEventTmManager::new(reporter, Box::new(backend));
     let (event_tx, event_rx) = channel();
     let mut sender = EventTmSender { sender: event_tx };
-    let event_sent = event_man
+    let mut event_sent = event_man
         .generate_pus_event_tm(&mut sender, &EMPTY_STAMP, INFO_EVENT, None)
         .expect("Sending info event failed");
 
     assert!(event_sent);
-    let packet = event_rx.recv().expect("Receiving event TM failed");
-    println!("{:?}", packet);
-    //let event_man;
+    // Will not check packet here, correctness of packet was tested somewhere else
+    event_rx.recv().expect("Receiving event TM failed");
+    let res = event_man.disable_tm_for_event_with_sev(&INFO_EVENT);
+    assert!(res.is_ok());
+    assert!(res.unwrap());
+    event_sent = event_man
+        .generate_pus_event_tm(&mut sender, &EMPTY_STAMP, INFO_EVENT, None)
+        .expect("Sending info event failed");
+    assert!(!event_sent);
+    let res = event_rx.try_recv();
+    assert!(res.is_err());
+    assert!(matches!(res.unwrap_err(), TryRecvError::Empty));
 }

From 74f65243e4f587734eab14ff605fecdbb968a4fd Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 1 Nov 2022 19:24:09 +0100
Subject: [PATCH 23/40] basic test framework done

---
 fsrc-core/src/event_man.rs     |  55 ++++++++++++++---
 fsrc-core/src/pus/event_man.rs |  38 ++++++------
 fsrc-core/tests/pus_events.rs  | 107 ++++++++++++++++++++++++++-------
 3 files changed, 150 insertions(+), 50 deletions(-)

diff --git a/fsrc-core/src/event_man.rs b/fsrc-core/src/event_man.rs
index 98fe9a8..fb43184 100644
--- a/fsrc-core/src/event_man.rs
+++ b/fsrc-core/src/event_man.rs
@@ -35,7 +35,7 @@ use alloc::vec::Vec;
 use hashbrown::HashMap;
 
 #[cfg(feature = "std")]
-pub use stdmod::MpscEventReceiver;
+pub use stdmod::*;
 
 #[derive(PartialEq, Eq, Hash, Copy, Clone)]
 enum ListenerType {
@@ -96,6 +96,14 @@ pub struct EventManager<SendProviderError, Event: GenericEvent = EventU32, AuxDa
     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>
+{
+}
+
 pub enum HandlerResult<Provider: GenericEvent, AuxDataProvider> {
     Empty,
     Handled(u32, Provider, Option<AuxDataProvider>),
@@ -128,8 +136,11 @@ impl<E, Event: GenericEvent + Copy> EventManager<E, Event> {
     ///
     /// For example, this can be useful for a handler component which sends every event as
     /// a telemetry packet.
-    pub fn subscribe_all(&mut self, dest: impl SendEventProvider<Event, Error = E> + 'static) {
-        self.update_listeners(ListenerType::All, dest);
+    pub fn subscribe_all(
+        &mut self,
+        send_provider: impl SendEventProvider<Event, Error = E> + 'static,
+    ) {
+        self.update_listeners(ListenerType::All, send_provider);
     }
 
     /// Helper function which removes single subscriptions for which a group subscription already
@@ -226,23 +237,24 @@ impl<E, Event: GenericEvent + Copy, AuxDataProvider: Clone>
 
 #[cfg(feature = "std")]
 pub mod stdmod {
+    use super::*;
     use crate::event_man::{EventReceiver, EventWithAuxData};
     use crate::events::{EventU16, EventU32, GenericEvent};
     use crate::util::Params;
-    use std::sync::mpsc::Receiver;
+    use std::sync::mpsc::{Receiver, SendError, Sender};
 
-    pub struct MpscEventReceiver<Event: GenericEvent = EventU32> {
+    pub struct MpscEventReceiver<Event: GenericEvent + Send = EventU32> {
         mpsc_receiver: Receiver<(Event, Option<Params>)>,
     }
 
-    impl<Event: GenericEvent> MpscEventReceiver<Event> {
+    impl<Event: GenericEvent + Send> MpscEventReceiver<Event> {
         pub fn new(receiver: Receiver<(Event, Option<Params>)>) -> Self {
             Self {
                 mpsc_receiver: receiver,
             }
         }
     }
-    impl<Event: GenericEvent> EventReceiver<Event> for MpscEventReceiver<Event> {
+    impl<Event: GenericEvent + Send> EventReceiver<Event> for MpscEventReceiver<Event> {
         fn receive(&mut self) -> Option<EventWithAuxData<Event>> {
             if let Ok(event_and_data) = self.mpsc_receiver.try_recv() {
                 return Some(event_and_data);
@@ -253,6 +265,35 @@ pub mod stdmod {
 
     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>)>,
+    }
+
+    /// Safety: Send is safe to implement because both the ID and the MPSC sender are Send
+    //unsafe impl<Event: GenericEvent> Send for MpscEventSendProvider<Event> {}
+
+    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(&mut 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)]
diff --git a/fsrc-core/src/pus/event_man.rs b/fsrc-core/src/pus/event_man.rs
index 11075d9..feef852 100644
--- a/fsrc-core/src/pus/event_man.rs
+++ b/fsrc-core/src/pus/event_man.rs
@@ -38,6 +38,9 @@ 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 {
@@ -73,13 +76,19 @@ pub mod heapless_mod {
     // 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 HeaplessPusMgmtBckendProvider<const N: usize, Provider: GenericEvent> {
+    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 HeaplessPusMgmtBckendProvider<N, Provider>
+        for HeaplessPusMgmtBackendProvider<N, Provider>
     {
         type Error = ();
 
@@ -116,6 +125,9 @@ pub struct PusEventTmManager<BackendError, Provider: GenericEvent> {
     backend: Box<dyn PusEventMgmtBackendProvider<Provider, Error = BackendError>>,
 }
 
+/// Safety: All contained fields are send as well.
+unsafe impl<E: Send, Event: GenericEvent + Send> Send for PusEventTmManager<E, Event> {}
+
 impl<BackendError, Provider: GenericEvent> PusEventTmManager<BackendError, Provider> {
     pub fn new(
         reporter: EventReporter,
@@ -136,7 +148,6 @@ impl<BackendError, Event: GenericEvent> PusEventTmManager<BackendError, Event> {
 
     pub fn generate_pus_event_tm_generic<E>(
         &mut self,
-        severity: Severity,
         sender: &mut (impl EcssTmSender<Error = E> + ?Sized),
         time_stamp: &[u8],
         event: Event,
@@ -145,10 +156,7 @@ impl<BackendError, Event: GenericEvent> PusEventTmManager<BackendError, Event> {
         if !self.backend.event_enabled(&event) {
             return Ok(false);
         }
-        if event.severity() != severity {
-            return Err(EventManError::SeverityMissmatch(severity, event.severity()));
-        }
-        match severity {
+        match event.severity() {
             Severity::INFO => self
                 .reporter
                 .event_info(sender, time_stamp, event, aux_data)
@@ -195,13 +203,7 @@ impl<BackendError> PusEventTmManager<BackendError, EventU32> {
         event: EventU32TypedSev<Severity>,
         aux_data: Option<&[u8]>,
     ) -> Result<bool, EventManError<E>> {
-        self.generate_pus_event_tm_generic(
-            Severity::SEVERITY,
-            sender,
-            time_stamp,
-            event.into(),
-            aux_data,
-        )
+        self.generate_pus_event_tm_generic(sender, time_stamp, event.into(), aux_data)
     }
 }
 
@@ -261,13 +263,7 @@ mod tests {
         assert!(res.is_ok());
         assert!(res.unwrap());
         let mut event_sent = event_man
-            .generate_pus_event_tm_generic(
-                Severity::LOW,
-                &mut sender,
-                &EMPTY_STAMP,
-                LOW_SEV_EVENT,
-                None,
-            )
+            .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();
diff --git a/fsrc-core/tests/pus_events.rs b/fsrc-core/tests/pus_events.rs
index 0534e96..058b0f6 100644
--- a/fsrc-core/tests/pus_events.rs
+++ b/fsrc-core/tests/pus_events.rs
@@ -1,8 +1,11 @@
+use fsrc_core::event_man::{EventManager, MpscEventReceiver, MpscEventU32SendProvider};
 use fsrc_core::events::{EventU32, EventU32TypedSev, Severity, SeverityInfo};
 use fsrc_core::pus::event_man::{DefaultPusMgmtBackendProvider, EventReporter, PusEventTmManager};
 use fsrc_core::pus::{EcssTmError, EcssTmSender};
+use fsrc_core::util::Params;
 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);
@@ -24,27 +27,87 @@ impl EcssTmSender for EventTmSender {
 }
 
 #[test]
-fn test_basic() {
-    let reporter = EventReporter::new(0x02, 128).expect("Creating event repoter failed");
-    let backend = DefaultPusMgmtBackendProvider::<EventU32>::default();
-    let mut event_man = PusEventTmManager::new(reporter, Box::new(backend));
-    let (event_tx, event_rx) = channel();
-    let mut sender = EventTmSender { sender: event_tx };
-    let mut event_sent = event_man
-        .generate_pus_event_tm(&mut sender, &EMPTY_STAMP, INFO_EVENT, None)
-        .expect("Sending info event failed");
+fn test_threaded_usage() {
+    let (event_sender, event_man_receiver) = channel();
+    let event_receiver = MpscEventReceiver::new(event_man_receiver);
+    let mut event_man = EventManager::new(Box::new(event_receiver));
 
-    assert!(event_sent);
-    // Will not check packet here, correctness of packet was tested somewhere else
-    event_rx.recv().expect("Receiving event TM failed");
-    let res = event_man.disable_tm_for_event_with_sev(&INFO_EVENT);
-    assert!(res.is_ok());
-    assert!(res.unwrap());
-    event_sent = event_man
-        .generate_pus_event_tm(&mut sender, &EMPTY_STAMP, INFO_EVENT, None)
-        .expect("Sending info event failed");
-    assert!(!event_sent);
-    let res = event_rx.try_recv();
-    assert!(res.is_err());
-    assert!(matches!(res.unwrap_err(), TryRecvError::Empty));
+    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);
+    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 = PusEventTmManager::new(reporter, Box::new(backend));
+    // PUS + Generic event manager thread
+    let jh0 = thread::spawn(move || {
+        let mut sender = EventTmSender { sender: event_tx };
+        loop {
+            let res = event_man.try_event_handling();
+            assert!(res.is_ok());
+            match pus_event_man_rx.try_recv() {
+                Ok((event, aux_data)) => {
+                    // TODO: Convert auxiliary data into raw byte format
+                    if let Some(aux_data) = aux_data {
+                        match aux_data {
+                            Params::Heapless(_) => {}
+                            Params::Vec(_) => {}
+                            Params::String(_) => {}
+                        }
+                    }
+                    let res = pus_event_man.generate_pus_event_tm_generic(
+                        &mut sender,
+                        &EMPTY_STAMP,
+                        event,
+                        None,
+                    );
+                    assert!(res.is_ok());
+                    assert!(res.unwrap());
+                    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(_) => 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(_) => 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");
 }

From ffb6fe83ada5d48c969d4983fd926fca4564e226 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 1 Nov 2022 20:07:02 +0100
Subject: [PATCH 24/40] test works

---
 fsrc-core/tests/pus_events.rs | 16 +++++++++++++---
 1 file changed, 13 insertions(+), 3 deletions(-)

diff --git a/fsrc-core/tests/pus_events.rs b/fsrc-core/tests/pus_events.rs
index 058b0f6..251f585 100644
--- a/fsrc-core/tests/pus_events.rs
+++ b/fsrc-core/tests/pus_events.rs
@@ -42,6 +42,7 @@ fn test_threaded_usage() {
     // PUS + Generic event manager thread
     let jh0 = thread::spawn(move || {
         let mut sender = EventTmSender { sender: event_tx };
+        let mut event_cnt = 0;
         loop {
             let res = event_man.try_event_handling();
             assert!(res.is_ok());
@@ -61,9 +62,12 @@ fn test_threaded_usage() {
                         event,
                         None,
                     );
+                    event_cnt += 1;
                     assert!(res.is_ok());
                     assert!(res.unwrap());
-                    break;
+                    if event_cnt == 2 {
+                        break;
+                    }
                 }
                 Err(e) => {
                     if let TryRecvError::Disconnected = e {
@@ -82,7 +86,10 @@ fn test_threaded_usage() {
         loop {
             match event_rx.try_recv() {
                 // Event TM received successfully
-                Ok(_) => break,
+                Ok(event) => {
+                    println!("{:x?}", event);
+                    break;
+                }
                 Err(e) => {
                     if let TryRecvError::Disconnected = e {
                         panic!("Event sender disconnected!")
@@ -99,7 +106,10 @@ fn test_threaded_usage() {
         loop {
             match event_rx.try_recv() {
                 // Event TM received successfully
-                Ok(_) => break,
+                Ok(event) => {
+                    println!("{:x?}", event);
+                    break;
+                }
                 Err(e) => {
                     if let TryRecvError::Disconnected = e {
                         panic!("Event sender disconnected!")

From e5a912c6369a8456954ea7f77b35c69d179f2812 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 1 Nov 2022 22:01:27 +0100
Subject: [PATCH 25/40] this works

---
 fsrc-core/src/util.rs         | 97 +++++++++++++++++++++++++++++++++++
 fsrc-core/tests/pus_events.rs | 34 +++++++++++-
 2 files changed, 129 insertions(+), 2 deletions(-)

diff --git a/fsrc-core/src/util.rs b/fsrc-core/src/util.rs
index 27afd18..6622eb9 100644
--- a/fsrc-core/src/util.rs
+++ b/fsrc-core/src/util.rs
@@ -33,6 +33,36 @@ use core::mem::size_of;
 use paste::paste;
 pub use spacepackets::ecss::ToBeBytes;
 use spacepackets::ecss::{EcssEnumU16, EcssEnumU32, EcssEnumU64, EcssEnumU8};
+use spacepackets::ByteConversionError;
+use spacepackets::SizeMissmatch;
+
+pub trait WritableAsBeBytes {
+    fn raw_len(&self) -> usize;
+    fn write_be(&self, buf: &mut [u8]) -> Result<usize, ByteConversionError>;
+}
+
+macro_rules! param_to_be_bytes_impl {
+    ($Newtype: ident) => {
+        impl WritableAsBeBytes for $Newtype {
+            #[inline]
+            fn raw_len(&self) -> usize {
+                size_of::<<Self as ToBeBytes>::ByteArray>()
+            }
+
+            fn write_be(&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,)+) => {
@@ -45,6 +75,10 @@ macro_rules! primitive_newtypes_with_eq {
                 #[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)
@@ -76,6 +110,10 @@ macro_rules! primitive_newtypes {
                 #[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)
@@ -237,6 +275,65 @@ pub enum ParamsRaw {
     F64(F64),
 }
 
+impl WritableAsBeBytes 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_be(&self, buf: &mut [u8]) -> Result<usize, ByteConversionError> {
+        match self {
+            ParamsRaw::U8(v) => v.write_be(buf),
+            ParamsRaw::U8Pair(v) => v.write_be(buf),
+            ParamsRaw::U8Triplet(v) => v.write_be(buf),
+            ParamsRaw::I8(v) => v.write_be(buf),
+            ParamsRaw::I8Pair(v) => v.write_be(buf),
+            ParamsRaw::I8Triplet(v) => v.write_be(buf),
+            ParamsRaw::U16(v) => v.write_be(buf),
+            ParamsRaw::U16Pair(v) => v.write_be(buf),
+            ParamsRaw::U16Triplet(v) => v.write_be(buf),
+            ParamsRaw::I16(v) => v.write_be(buf),
+            ParamsRaw::I16Pair(v) => v.write_be(buf),
+            ParamsRaw::I16Triplet(v) => v.write_be(buf),
+            ParamsRaw::U32(v) => v.write_be(buf),
+            ParamsRaw::U32Pair(v) => v.write_be(buf),
+            ParamsRaw::U32Triplet(v) => v.write_be(buf),
+            ParamsRaw::I32(v) => v.write_be(buf),
+            ParamsRaw::I32Pair(v) => v.write_be(buf),
+            ParamsRaw::I32Triplet(v) => v.write_be(buf),
+            ParamsRaw::F32(v) => v.write_be(buf),
+            ParamsRaw::F32Pair(v) => v.write_be(buf),
+            ParamsRaw::F32Triplet(v) => v.write_be(buf),
+            ParamsRaw::U64(v) => v.write_be(buf),
+            ParamsRaw::I64(v) => v.write_be(buf),
+            ParamsRaw::F64(v) => v.write_be(buf),
+        }
+    }
+}
 macro_rules! params_raw_from_newtype {
     ($($newtype: ident,)+) => {
         $(
diff --git a/fsrc-core/tests/pus_events.rs b/fsrc-core/tests/pus_events.rs
index 251f585..5d4f1c8 100644
--- a/fsrc-core/tests/pus_events.rs
+++ b/fsrc-core/tests/pus_events.rs
@@ -2,7 +2,7 @@ use fsrc_core::event_man::{EventManager, MpscEventReceiver, MpscEventU32SendProv
 use fsrc_core::events::{EventU32, EventU32TypedSev, Severity, SeverityInfo};
 use fsrc_core::pus::event_man::{DefaultPusMgmtBackendProvider, EventReporter, PusEventTmManager};
 use fsrc_core::pus::{EcssTmError, EcssTmSender};
-use fsrc_core::util::Params;
+use fsrc_core::util::{Params, ParamsHeapless, ParamsRaw};
 use spacepackets::tm::PusTm;
 use std::sync::mpsc::{channel, SendError, TryRecvError};
 use std::thread;
@@ -43,6 +43,7 @@ fn test_threaded_usage() {
     let jh0 = thread::spawn(move || {
         let mut sender = EventTmSender { sender: event_tx };
         let mut event_cnt = 0;
+        let _params_array: [u8; 256] = [0; 256];
         loop {
             let res = event_man.try_event_handling();
             assert!(res.is_ok());
@@ -51,7 +52,36 @@ fn test_threaded_usage() {
                     // TODO: Convert auxiliary data into raw byte format
                     if let Some(aux_data) = aux_data {
                         match aux_data {
-                            Params::Heapless(_) => {}
+                            Params::Heapless(heapless) => match heapless {
+                                ParamsHeapless::Raw(raw) => match raw {
+                                    ParamsRaw::U8(_) => {}
+                                    ParamsRaw::U8Pair(_) => {}
+                                    ParamsRaw::U8Triplet(_) => {}
+                                    ParamsRaw::I8(_) => {}
+                                    ParamsRaw::I8Pair(_) => {}
+                                    ParamsRaw::I8Triplet(_) => {}
+                                    ParamsRaw::U16(_) => {}
+                                    ParamsRaw::U16Pair(_) => {}
+                                    ParamsRaw::U16Triplet(_) => {}
+                                    ParamsRaw::I16(_) => {}
+                                    ParamsRaw::I16Pair(_) => {}
+                                    ParamsRaw::I16Triplet(_) => {}
+                                    ParamsRaw::U32(_) => {}
+                                    ParamsRaw::U32Pair(_) => {}
+                                    ParamsRaw::U32Triplet(_) => {}
+                                    ParamsRaw::I32(_) => {}
+                                    ParamsRaw::I32Pair(_) => {}
+                                    ParamsRaw::I32Triplet(_) => {}
+                                    ParamsRaw::F32(_) => {}
+                                    ParamsRaw::F32Pair(_) => {}
+                                    ParamsRaw::F32Triplet(_) => {}
+                                    ParamsRaw::U64(_) => {}
+                                    ParamsRaw::I64(_) => {}
+                                    ParamsRaw::F64(_) => {}
+                                },
+                                ParamsHeapless::EcssEnum(_) => {}
+                                ParamsHeapless::Store(_) => {}
+                            },
                             Params::Vec(_) => {}
                             Params::String(_) => {}
                         }

From 0fd9d9c9b6dba9219301223827b7aafc41b9c3c1 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Wed, 2 Nov 2022 00:36:49 +0100
Subject: [PATCH 26/40] all working

---
 fsrc-core/src/events.rs           |  45 +++++++--
 fsrc-core/src/pus/event.rs        |   2 +-
 fsrc-core/src/pus/verification.rs |   8 +-
 fsrc-core/src/util.rs             | 159 +++++++++++++++++++++++-------
 fsrc-core/tests/pus_events.rs     | 102 ++++++++++---------
 spacepackets                      |   2 +-
 6 files changed, 225 insertions(+), 93 deletions(-)

diff --git a/fsrc-core/src/events.rs b/fsrc-core/src/events.rs
index d0ea2f2..eded68e 100644
--- a/fsrc-core/src/events.rs
+++ b/fsrc-core/src/events.rs
@@ -411,7 +411,7 @@ impl EcssEnumeration for EventU32 {
         32
     }
 
-    fn write_to_bytes(&self, buf: &mut [u8]) -> Result<(), ByteConversionError> {
+    fn write_to_be_bytes(&self, buf: &mut [u8]) -> Result<(), ByteConversionError> {
         self.base.write_to_bytes(self.raw(), buf, self.byte_width())
     }
 }
@@ -420,7 +420,7 @@ impl EcssEnumeration for EventU32 {
 impl<SEVERITY: HasSeverity> EcssEnumeration for EventU32TypedSev<SEVERITY> {
     delegate!(to self.event {
         fn pfc(&self) -> u8;
-        fn write_to_bytes(&self, buf: &mut [u8]) -> Result<(), ByteConversionError>;
+        fn write_to_be_bytes(&self, buf: &mut [u8]) -> Result<(), ByteConversionError>;
     });
 }
 
@@ -542,11 +542,12 @@ impl<SEVERITY: HasSeverity> EventU16TypedSev<SEVERITY> {
 impl_event_provider!(EventU16, EventU16TypedSev, u16, u8, u8);
 
 impl EcssEnumeration for EventU16 {
+    #[inline]
     fn pfc(&self) -> u8 {
         16
     }
 
-    fn write_to_bytes(&self, buf: &mut [u8]) -> Result<(), ByteConversionError> {
+    fn write_to_be_bytes(&self, buf: &mut [u8]) -> Result<(), ByteConversionError> {
         self.base.write_to_bytes(self.raw(), buf, self.byte_width())
     }
 }
@@ -555,7 +556,7 @@ impl EcssEnumeration for EventU16 {
 impl<SEVERITY: HasSeverity> EcssEnumeration for EventU16TypedSev<SEVERITY> {
     delegate!(to self.event {
         fn pfc(&self) -> u8;
-        fn write_to_bytes(&self, buf: &mut [u8]) -> Result<(), ByteConversionError>;
+        fn write_to_be_bytes(&self, buf: &mut [u8]) -> Result<(), ByteConversionError>;
     });
 }
 
@@ -574,6 +575,34 @@ 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;
@@ -713,7 +742,7 @@ mod tests {
     #[test]
     fn write_to_buf() {
         let mut buf: [u8; 4] = [0; 4];
-        assert!(HIGH_SEV_EVENT.write_to_bytes(&mut buf).is_ok());
+        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);
     }
@@ -721,7 +750,7 @@ mod tests {
     #[test]
     fn write_to_buf_small() {
         let mut buf: [u8; 2] = [0; 2];
-        assert!(HIGH_SEV_EVENT_SMALL.write_to_bytes(&mut buf).is_ok());
+        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);
     }
@@ -729,7 +758,7 @@ mod tests {
     #[test]
     fn write_to_buf_insufficient_buf() {
         let mut buf: [u8; 3] = [0; 3];
-        let err = HIGH_SEV_EVENT.write_to_bytes(&mut buf);
+        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 {
@@ -741,7 +770,7 @@ mod tests {
     #[test]
     fn write_to_buf_small_insufficient_buf() {
         let mut buf: [u8; 1] = [0; 1];
-        let err = HIGH_SEV_EVENT_SMALL.write_to_bytes(&mut buf);
+        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 {
diff --git a/fsrc-core/src/pus/event.rs b/fsrc-core/src/pus/event.rs
index f7b7e36..a4867e6 100644
--- a/fsrc-core/src/pus/event.rs
+++ b/fsrc-core/src/pus/event.rs
@@ -152,7 +152,7 @@ impl EventReporterBase {
             time_stamp,
         );
         let mut current_idx = 0;
-        event_id.write_to_bytes(&mut buf[0..event_id.byte_width()])?;
+        event_id.write_to_be_bytes(&mut buf[0..event_id.byte_width()])?;
         current_idx += event_id.byte_width();
         if let Some(aux_data) = aux_data {
             buf[current_idx..current_idx + aux_data.len()].copy_from_slice(aux_data);
diff --git a/fsrc-core/src/pus/verification.rs b/fsrc-core/src/pus/verification.rs
index 0908b01..da56f69 100644
--- a/fsrc-core/src/pus/verification.rs
+++ b/fsrc-core/src/pus/verification.rs
@@ -536,7 +536,7 @@ impl VerificationReporterBasic {
         idx += RequestId::SIZE_AS_BYTES;
         if let Some(step) = step {
             // Size check was done beforehand
-            step.write_to_bytes(&mut buf[idx..idx + step.byte_width() as usize])
+            step.write_to_be_bytes(&mut buf[idx..idx + step.byte_width() as usize])
                 .unwrap();
         }
         let mut sp_header = SpHeader::tm(self.apid(), 0, 0).unwrap();
@@ -571,13 +571,13 @@ impl VerificationReporterBasic {
         idx += RequestId::SIZE_AS_BYTES;
         if let Some(step) = step {
             // Size check done beforehand
-            step.write_to_bytes(&mut buf[idx..idx + step.byte_width() as usize])
+            step.write_to_be_bytes(&mut buf[idx..idx + step.byte_width() as usize])
                 .unwrap();
             idx += step.byte_width() as usize;
         }
         params
             .failure_code
-            .write_to_bytes(&mut buf[idx..idx + params.failure_code.byte_width() as usize])?;
+            .write_to_be_bytes(&mut 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 {
             buf[idx..idx + failure_data.len()].copy_from_slice(failure_data);
@@ -1344,7 +1344,7 @@ mod tests {
         let fail_code = EcssEnumU8::new(10);
         let fail_data = EcssEnumU32::new(12);
         let mut fail_data_raw = [0; 4];
-        fail_data.write_to_bytes(&mut fail_data_raw).unwrap();
+        fail_data.write_to_be_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");
diff --git a/fsrc-core/src/util.rs b/fsrc-core/src/util.rs
index 6622eb9..3967fee 100644
--- a/fsrc-core/src/util.rs
+++ b/fsrc-core/src/util.rs
@@ -32,13 +32,16 @@ use core::fmt::Debug;
 use core::mem::size_of;
 use paste::paste;
 pub use spacepackets::ecss::ToBeBytes;
-use spacepackets::ecss::{EcssEnumU16, EcssEnumU32, EcssEnumU64, EcssEnumU8};
+use spacepackets::ecss::{EcssEnumU16, EcssEnumU32, EcssEnumU64, EcssEnumU8, EcssEnumeration};
 use spacepackets::ByteConversionError;
 use spacepackets::SizeMissmatch;
 
+/// Generic trait which is used for objects which can be converted into a raw network (big) endian
+/// byte format.
 pub trait WritableAsBeBytes {
     fn raw_len(&self) -> usize;
-    fn write_be(&self, buf: &mut [u8]) -> Result<usize, ByteConversionError>;
+    /// 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 {
@@ -49,7 +52,7 @@ macro_rules! param_to_be_bytes_impl {
                 size_of::<<Self as ToBeBytes>::ByteArray>()
             }
 
-            fn write_be(&self, buf: &mut [u8]) -> Result<usize, ByteConversionError> {
+            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 {
@@ -137,7 +140,7 @@ macro_rules! primitive_newtypes {
 primitive_newtypes_with_eq!(u8, u16, u32, u64, i8, i16, i32, i64,);
 primitive_newtypes!(f32, f64,);
 
-macro_rules! scalar_to_be_bytes_impl {
+macro_rules! scalar_byte_conversions_impl {
     ($($ty: ty,)+) => {
         $(
             paste! {
@@ -147,12 +150,26 @@ macro_rules! scalar_to_be_bytes_impl {
                         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_to_be_bytes_impl {
+macro_rules! pair_byte_conversions_impl {
     ($($ty: ty,)+) => {
         $(
             paste! {
@@ -167,6 +184,23 @@ macro_rules! pair_to_be_bytes_impl {
                         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())
+                        ))
+                    }
+                }
             }
         )+
     }
@@ -182,20 +216,37 @@ macro_rules! triplet_to_be_bytes_impl {
                         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>()
+                            size_of::<$ty>()..2 * size_of::<$ty>()
                         ].copy_from_slice(&self.1.to_be_bytes());
                         array[
-                            2 * size_of::<$ty>()..3*  size_of::<$ty>()
+                            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_to_be_bytes_impl!(u8, u16, u32, u64, i8, i16, i32, i64, f32, f64,);
+scalar_byte_conversions_impl!(u8, u16, u32, u64, i8, i16, i32, i64, f32, f64,);
 
 impl ToBeBytes for U8Pair {
     type ByteArray = [u8; 2];
@@ -243,7 +294,7 @@ impl ToBeBytes for I8Triplet {
     }
 }
 
-pair_to_be_bytes_impl!(u16, u32, u64, i16, i32, i64, f32, f64,);
+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.
@@ -305,35 +356,36 @@ impl WritableAsBeBytes for ParamsRaw {
         }
     }
 
-    fn write_be(&self, buf: &mut [u8]) -> Result<usize, ByteConversionError> {
+    fn write_to_be_bytes(&self, buf: &mut [u8]) -> Result<usize, ByteConversionError> {
         match self {
-            ParamsRaw::U8(v) => v.write_be(buf),
-            ParamsRaw::U8Pair(v) => v.write_be(buf),
-            ParamsRaw::U8Triplet(v) => v.write_be(buf),
-            ParamsRaw::I8(v) => v.write_be(buf),
-            ParamsRaw::I8Pair(v) => v.write_be(buf),
-            ParamsRaw::I8Triplet(v) => v.write_be(buf),
-            ParamsRaw::U16(v) => v.write_be(buf),
-            ParamsRaw::U16Pair(v) => v.write_be(buf),
-            ParamsRaw::U16Triplet(v) => v.write_be(buf),
-            ParamsRaw::I16(v) => v.write_be(buf),
-            ParamsRaw::I16Pair(v) => v.write_be(buf),
-            ParamsRaw::I16Triplet(v) => v.write_be(buf),
-            ParamsRaw::U32(v) => v.write_be(buf),
-            ParamsRaw::U32Pair(v) => v.write_be(buf),
-            ParamsRaw::U32Triplet(v) => v.write_be(buf),
-            ParamsRaw::I32(v) => v.write_be(buf),
-            ParamsRaw::I32Pair(v) => v.write_be(buf),
-            ParamsRaw::I32Triplet(v) => v.write_be(buf),
-            ParamsRaw::F32(v) => v.write_be(buf),
-            ParamsRaw::F32Pair(v) => v.write_be(buf),
-            ParamsRaw::F32Triplet(v) => v.write_be(buf),
-            ParamsRaw::U64(v) => v.write_be(buf),
-            ParamsRaw::I64(v) => v.write_be(buf),
-            ParamsRaw::F64(v) => v.write_be(buf),
+            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,)+) => {
         $(
@@ -360,6 +412,45 @@ pub enum EcssEnumParams {
     U64(EcssEnumU64),
 }
 
+macro_rules! writable_as_be_bytes_ecss_enum_impl {
+    ($EnumIdent: ident) => {
+        impl WritableAsBeBytes for $EnumIdent {
+            fn raw_len(&self) -> usize {
+                self.byte_width()
+            }
+
+            fn write_to_be_bytes(&self, buf: &mut [u8]) -> Result<usize, ByteConversionError> {
+                EcssEnumeration::write_to_be_bytes(self, buf).map(|_| self.byte_width())
+            }
+        }
+    };
+}
+
+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 WritableAsBeBytes for EcssEnumParams {
+    fn raw_len(&self) -> usize {
+        match self {
+            EcssEnumParams::U8(e) => e.byte_width(),
+            EcssEnumParams::U16(e) => e.byte_width(),
+            EcssEnumParams::U32(e) => e.byte_width(),
+            EcssEnumParams::U64(e) => e.byte_width(),
+        }
+    }
+
+    fn write_to_be_bytes(&self, buf: &mut [u8]) -> Result<usize, ByteConversionError> {
+        match self {
+            EcssEnumParams::U8(e) => WritableAsBeBytes::write_to_be_bytes(e, buf),
+            EcssEnumParams::U16(e) => WritableAsBeBytes::write_to_be_bytes(e, buf),
+            EcssEnumParams::U32(e) => WritableAsBeBytes::write_to_be_bytes(e, buf),
+            EcssEnumParams::U64(e) => WritableAsBeBytes::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 {
diff --git a/fsrc-core/tests/pus_events.rs b/fsrc-core/tests/pus_events.rs
index 5d4f1c8..9d402e7 100644
--- a/fsrc-core/tests/pus_events.rs
+++ b/fsrc-core/tests/pus_events.rs
@@ -2,7 +2,9 @@ use fsrc_core::event_man::{EventManager, MpscEventReceiver, MpscEventU32SendProv
 use fsrc_core::events::{EventU32, EventU32TypedSev, Severity, SeverityInfo};
 use fsrc_core::pus::event_man::{DefaultPusMgmtBackendProvider, EventReporter, PusEventTmManager};
 use fsrc_core::pus::{EcssTmError, EcssTmSender};
-use fsrc_core::util::{Params, ParamsHeapless, ParamsRaw};
+use fsrc_core::util::U32Pair;
+use fsrc_core::util::{Params, ParamsHeapless, WritableAsBeBytes};
+use spacepackets::ecss::PusPacket;
 use spacepackets::tm::PusTm;
 use std::sync::mpsc::{channel, SendError, TryRecvError};
 use std::thread;
@@ -43,55 +45,41 @@ fn test_threaded_usage() {
     let jh0 = thread::spawn(move || {
         let mut sender = EventTmSender { sender: event_tx };
         let mut event_cnt = 0;
-        let _params_array: [u8; 256] = [0; 256];
+        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)) => {
-                    // TODO: Convert auxiliary data into raw byte format
-                    if let Some(aux_data) = 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) => match raw {
-                                    ParamsRaw::U8(_) => {}
-                                    ParamsRaw::U8Pair(_) => {}
-                                    ParamsRaw::U8Triplet(_) => {}
-                                    ParamsRaw::I8(_) => {}
-                                    ParamsRaw::I8Pair(_) => {}
-                                    ParamsRaw::I8Triplet(_) => {}
-                                    ParamsRaw::U16(_) => {}
-                                    ParamsRaw::U16Pair(_) => {}
-                                    ParamsRaw::U16Triplet(_) => {}
-                                    ParamsRaw::I16(_) => {}
-                                    ParamsRaw::I16Pair(_) => {}
-                                    ParamsRaw::I16Triplet(_) => {}
-                                    ParamsRaw::U32(_) => {}
-                                    ParamsRaw::U32Pair(_) => {}
-                                    ParamsRaw::U32Triplet(_) => {}
-                                    ParamsRaw::I32(_) => {}
-                                    ParamsRaw::I32Pair(_) => {}
-                                    ParamsRaw::I32Triplet(_) => {}
-                                    ParamsRaw::F32(_) => {}
-                                    ParamsRaw::F32Pair(_) => {}
-                                    ParamsRaw::F32Triplet(_) => {}
-                                    ParamsRaw::U64(_) => {}
-                                    ParamsRaw::I64(_) => {}
-                                    ParamsRaw::F64(_) => {}
-                                },
-                                ParamsHeapless::EcssEnum(_) => {}
-                                ParamsHeapless::Store(_) => {}
+                                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()]))
+                                }
+                                ParamsHeapless::Store(_) => gen_event(None),
                             },
-                            Params::Vec(_) => {}
-                            Params::String(_) => {}
+                            Params::Vec(vec) => gen_event(Some(vec.as_slice())),
+                            Params::String(str) => gen_event(Some(str.as_bytes())),
                         }
-                    }
-                    let res = pus_event_man.generate_pus_event_tm_generic(
-                        &mut sender,
-                        &EMPTY_STAMP,
-                        event,
-                        None,
-                    );
+                    } else {
+                        gen_event(None)
+                    };
                     event_cnt += 1;
                     assert!(res.is_ok());
                     assert!(res.unwrap());
@@ -116,8 +104,18 @@ fn test_threaded_usage() {
         loop {
             match event_rx.try_recv() {
                 // Event TM received successfully
-                Ok(event) => {
-                    println!("{:x?}", event);
+                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) => {
@@ -136,8 +134,22 @@ fn test_threaded_usage() {
         loop {
             match event_rx.try_recv() {
                 // Event TM received successfully
-                Ok(event) => {
-                    println!("{:x?}", event);
+                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) => {
diff --git a/spacepackets b/spacepackets
index 38b789c..4c1101f 160000
--- a/spacepackets
+++ b/spacepackets
@@ -1 +1 @@
-Subproject commit 38b789ca6d061239e6cecc76f0843d6ba8b9bd01
+Subproject commit 4c1101f65f20419606932c4ee40fb2768e8cc736

From b0e58e9f8d26ed4d38a622e4a891d94297fb4bfb Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Wed, 2 Nov 2022 00:39:09 +0100
Subject: [PATCH 27/40] bump spacepackets

---
 spacepackets | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/spacepackets b/spacepackets
index 4c1101f..f8199ca 160000
--- a/spacepackets
+++ b/spacepackets
@@ -1 +1 @@
-Subproject commit 4c1101f65f20419606932c4ee40fb2768e8cc736
+Subproject commit f8199ca87a8fc97a51d09bf8bfa57627cd54f74d

From cc3740c676165d95f775775331fba51580719fee Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Wed, 2 Nov 2022 11:07:56 +0100
Subject: [PATCH 28/40] add empty changelog

---
 fsrc-core/CHANGELOG.md | 9 +++++++++
 1 file changed, 9 insertions(+)
 create mode 100644 fsrc-core/CHANGELOG.md

diff --git a/fsrc-core/CHANGELOG.md b/fsrc-core/CHANGELOG.md
new file mode 100644
index 0000000..68e54a2
--- /dev/null
+++ b/fsrc-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]

From 6768af8f17322da17401af007aec307aa6aaff89 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Wed, 2 Nov 2022 11:10:56 +0100
Subject: [PATCH 29/40] bump spacepackets

---
 spacepackets | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/spacepackets b/spacepackets
index f8199ca..1d6cf3a 160000
--- a/spacepackets
+++ b/spacepackets
@@ -1 +1 @@
-Subproject commit f8199ca87a8fc97a51d09bf8bfa57627cd54f74d
+Subproject commit 1d6cf3a75d4082b3d962700038c21dc7dacb156f

From 575fb0e64b0000415501a70d0d5e541ab3af52e8 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Wed, 2 Nov 2022 11:33:59 +0100
Subject: [PATCH 30/40] rename module

---
 fsrc-core/src/event_man.rs           |  6 +--
 fsrc-core/src/lib.rs                 |  2 +-
 fsrc-core/src/{util.rs => params.rs} | 59 ++++++++++++++++++++--------
 fsrc-core/tests/pus_events.rs        |  4 +-
 4 files changed, 48 insertions(+), 23 deletions(-)
 rename fsrc-core/src/{util.rs => params.rs} (90%)

diff --git a/fsrc-core/src/event_man.rs b/fsrc-core/src/event_man.rs
index fb43184..c5a6c9f 100644
--- a/fsrc-core/src/event_man.rs
+++ b/fsrc-core/src/event_man.rs
@@ -28,7 +28,7 @@
 //! 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.
 use crate::events::{EventU16, EventU32, GenericEvent, LargestEventRaw, LargestGroupIdRaw};
-use crate::util::{Params, ParamsHeapless};
+use crate::params::{Params, ParamsHeapless};
 use alloc::boxed::Box;
 use alloc::vec;
 use alloc::vec::Vec;
@@ -240,7 +240,7 @@ pub mod stdmod {
     use super::*;
     use crate::event_man::{EventReceiver, EventWithAuxData};
     use crate::events::{EventU16, EventU32, GenericEvent};
-    use crate::util::Params;
+    use crate::params::Params;
     use std::sync::mpsc::{Receiver, SendError, Sender};
 
     pub struct MpscEventReceiver<Event: GenericEvent + Send = EventU32> {
@@ -301,7 +301,7 @@ mod tests {
     use super::*;
     use crate::event_man::EventManager;
     use crate::events::{EventU32, GenericEvent, Severity};
-    use crate::util::ParamsRaw;
+    use crate::params::ParamsRaw;
     use alloc::boxed::Box;
     use std::format;
     use std::sync::mpsc::{channel, Receiver, SendError, Sender};
diff --git a/fsrc-core/src/lib.rs b/fsrc-core/src/lib.rs
index 5ac3541..2ad940b 100644
--- a/fsrc-core/src/lib.rs
+++ b/fsrc-core/src/lib.rs
@@ -29,4 +29,4 @@ pub mod objects;
 pub mod pool;
 pub mod pus;
 pub mod tmtc;
-pub mod util;
+pub mod params;
diff --git a/fsrc-core/src/util.rs b/fsrc-core/src/params.rs
similarity index 90%
rename from fsrc-core/src/util.rs
rename to fsrc-core/src/params.rs
index 3967fee..3117b65 100644
--- a/fsrc-core/src/util.rs
+++ b/fsrc-core/src/params.rs
@@ -1,26 +1,48 @@
-//! Utility types and enums.
+//! Parameter types and enums.
 //!
-//! This module contains various helper types. This includes wrapper for primitive rust types
-//! using the newtype pattern. This was also done for pairs and triplets of these primitive types.
-//! The [ToBeBytes] was implemented for those types as well, which allows to easily convert them
-//! into a network friendly raw byte format.
+//! This module contains various helper types.
 //!
-//! The module also contains generic parameter enumerations.
+//! # Primtive Parameter Wrappers and Enumeration
 //!
-//! # Example for primitive type wrapper
+//! 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 fsrc_core::util::{ParamsRaw, ToBeBytes, U32Pair};
+//! use fsrc_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.
 use crate::pool::StoreAddr;
 #[cfg(feature = "alloc")]
 use alloc::string::String;
@@ -38,7 +60,7 @@ use spacepackets::SizeMissmatch;
 
 /// Generic trait which is used for objects which can be converted into a raw network (big) endian
 /// byte format.
-pub trait WritableAsBeBytes {
+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>;
@@ -46,7 +68,7 @@ pub trait WritableAsBeBytes {
 
 macro_rules! param_to_be_bytes_impl {
     ($Newtype: ident) => {
-        impl WritableAsBeBytes for $Newtype {
+        impl WritableToBeBytes for $Newtype {
             #[inline]
             fn raw_len(&self) -> usize {
                 size_of::<<Self as ToBeBytes>::ByteArray>()
@@ -298,6 +320,9 @@ 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),
@@ -326,7 +351,7 @@ pub enum ParamsRaw {
     F64(F64),
 }
 
-impl WritableAsBeBytes for ParamsRaw {
+impl WritableToBeBytes for ParamsRaw {
     fn raw_len(&self) -> usize {
         match self {
             ParamsRaw::U8(v) => v.raw_len(),
@@ -414,7 +439,7 @@ pub enum EcssEnumParams {
 
 macro_rules! writable_as_be_bytes_ecss_enum_impl {
     ($EnumIdent: ident) => {
-        impl WritableAsBeBytes for $EnumIdent {
+        impl WritableToBeBytes for $EnumIdent {
             fn raw_len(&self) -> usize {
                 self.byte_width()
             }
@@ -431,7 +456,7 @@ 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 WritableAsBeBytes for EcssEnumParams {
+impl WritableToBeBytes for EcssEnumParams {
     fn raw_len(&self) -> usize {
         match self {
             EcssEnumParams::U8(e) => e.byte_width(),
@@ -443,10 +468,10 @@ impl WritableAsBeBytes for EcssEnumParams {
 
     fn write_to_be_bytes(&self, buf: &mut [u8]) -> Result<usize, ByteConversionError> {
         match self {
-            EcssEnumParams::U8(e) => WritableAsBeBytes::write_to_be_bytes(e, buf),
-            EcssEnumParams::U16(e) => WritableAsBeBytes::write_to_be_bytes(e, buf),
-            EcssEnumParams::U32(e) => WritableAsBeBytes::write_to_be_bytes(e, buf),
-            EcssEnumParams::U64(e) => WritableAsBeBytes::write_to_be_bytes(e, buf),
+            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),
         }
     }
 }
diff --git a/fsrc-core/tests/pus_events.rs b/fsrc-core/tests/pus_events.rs
index 9d402e7..62c5dae 100644
--- a/fsrc-core/tests/pus_events.rs
+++ b/fsrc-core/tests/pus_events.rs
@@ -2,8 +2,8 @@ use fsrc_core::event_man::{EventManager, MpscEventReceiver, MpscEventU32SendProv
 use fsrc_core::events::{EventU32, EventU32TypedSev, Severity, SeverityInfo};
 use fsrc_core::pus::event_man::{DefaultPusMgmtBackendProvider, EventReporter, PusEventTmManager};
 use fsrc_core::pus::{EcssTmError, EcssTmSender};
-use fsrc_core::util::U32Pair;
-use fsrc_core::util::{Params, ParamsHeapless, WritableAsBeBytes};
+use fsrc_core::params::U32Pair;
+use fsrc_core::params::{Params, ParamsHeapless, WritableToBeBytes};
 use spacepackets::ecss::PusPacket;
 use spacepackets::tm::PusTm;
 use std::sync::mpsc::{channel, SendError, TryRecvError};

From 140e6737064246d9a6d165933a1b8480c509db4c Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Thu, 3 Nov 2022 12:55:03 +0100
Subject: [PATCH 31/40] add graphml and png

---
 fsrc-core/img/event_man_arch.graphml | 277 +++++++++++++++++++++++++++
 fsrc-core/img/event_man_arch.png     | Bin 0 -> 71833 bytes
 2 files changed, 277 insertions(+)
 create mode 100644 fsrc-core/img/event_man_arch.graphml
 create mode 100644 fsrc-core/img/event_man_arch.png

diff --git a/fsrc-core/img/event_man_arch.graphml b/fsrc-core/img/event_man_arch.graphml
new file mode 100644
index 0000000..2ff6c97
--- /dev/null
+++ b/fsrc-core/img/event_man_arch.graphml
@@ -0,0 +1,277 @@
+<?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"/>
+    <node id="n0">
+      <data key="d5"/>
+      <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="d5"/>
+      <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="d5"/>
+      <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="d5"/>
+      <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="d5"/>
+      <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="d5"/>
+      <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="d5"/>
+      <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="d5"/>
+      <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="d5"/>
+      <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="d9"/>
+      <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="d9"/>
+      <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="d9"/>
+      <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="d9"/>
+      <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="d9"/>
+      <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="d9"/>
+      <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="d9"/>
+      <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="d9"/>
+      <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="d9"/>
+      <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/fsrc-core/img/event_man_arch.png b/fsrc-core/img/event_man_arch.png
new file mode 100644
index 0000000000000000000000000000000000000000..24f7063efca9bf68b13bbe4d32883d6a04076919
GIT binary patch
literal 71833
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%0DX9`w9Dl`-#o@5(M(*y-Cs~FQ&DnQ%v-=(_
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
QWrA$+boFyt=akR{06B0bivR!s

literal 0
HcmV?d00001


From 9421465ffe3494b8f525848325ab3f02aea9ef18 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Thu, 3 Nov 2022 13:22:41 +0100
Subject: [PATCH 32/40] images in docs.rs now work

---
 .idea/runConfigurations/Docs.xml              |   3 +-
 Cargo.lock                                    |  19 +++++++++++++
 fsrc-core/Cargo.toml                          |   2 ++
 .../{img => images}/event_man_arch.graphml    |  26 +++---------------
 fsrc-core/images/event_man_arch.png           | Bin 0 -> 71832 bytes
 fsrc-core/img/event_man_arch.png              | Bin 71833 -> 0 bytes
 fsrc-core/src/event_man.rs                    |  18 ++++++++++--
 fsrc-core/src/lib.rs                          |   2 +-
 fsrc-core/tests/pus_events.rs                 |   4 +--
 9 files changed, 46 insertions(+), 28 deletions(-)
 rename fsrc-core/{img => images}/event_man_arch.graphml (98%)
 create mode 100644 fsrc-core/images/event_man_arch.png
 delete mode 100644 fsrc-core/img/event_man_arch.png

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/Cargo.lock b/Cargo.lock
index 0ae6d25..5cb0795 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -61,6 +61,12 @@ version = "1.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f8fe8f5a8a398345e52358e18ff07cc17a568fbca5c6f73873d3a62056309603"
 
+[[package]]
+name = "base64"
+version = "0.13.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9e1b586273c5702936fe7b7d6896644d8be71e6314cfe09d3167c95f712589e8"
+
 [[package]]
 name = "bit_field"
 version = "0.10.1"
@@ -278,6 +284,18 @@ version = "1.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9ea835d29036a4087793836fa931b08837ad5e957da9e23886b29586fb9b6650"
 
+[[package]]
+name = "embed-doc-image"
+version = "0.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "af36f591236d9d822425cb6896595658fa558fcebf5ee8accac1d4b92c47166e"
+dependencies = [
+ "base64",
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
 [[package]]
 name = "embedded-hal"
 version = "0.2.7"
@@ -296,6 +314,7 @@ dependencies = [
  "crossbeam-channel",
  "delegate 0.8.0",
  "downcast-rs",
+ "embed-doc-image",
  "hashbrown",
  "heapless",
  "num-traits",
diff --git a/fsrc-core/Cargo.toml b/fsrc-core/Cargo.toml
index 0db0e44..cd98fd9 100644
--- a/fsrc-core/Cargo.toml
+++ b/fsrc-core/Cargo.toml
@@ -10,6 +10,7 @@ delegate = "0.8"
 hashbrown = "0.12"
 heapless = "0.7"
 paste = "1.0"
+embed-doc-image = "0.1"
 
 [dependencies.num-traits]
 version = "0.2"
@@ -43,6 +44,7 @@ default = ["std"]
 std = ["downcast-rs/std", "alloc", "bus", "postcard/use-std", "crossbeam-channel/std"]
 alloc = []
 heapless = []
+doc-images = []
 
 [package.metadata.docs.rs]
 all-features = true
diff --git a/fsrc-core/img/event_man_arch.graphml b/fsrc-core/images/event_man_arch.graphml
similarity index 98%
rename from fsrc-core/img/event_man_arch.graphml
rename to fsrc-core/images/event_man_arch.graphml
index 2ff6c97..1336793 100644
--- a/fsrc-core/img/event_man_arch.graphml
+++ b/fsrc-core/images/event_man_arch.graphml
@@ -13,9 +13,8 @@
   <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"/>
+    <data key="d0" xml:space="preserve"/>
     <node id="n0">
-      <data key="d5"/>
       <data key="d6">
         <y:ShapeNode>
           <y:Geometry height="509.9999999999999" width="768.7000000000003" x="579.3105418719211" y="304.7"/>
@@ -27,7 +26,6 @@
       </data>
     </node>
     <node id="n1">
-      <data key="d5"/>
       <data key="d6">
         <y:ShapeNode>
           <y:Geometry height="60.0" width="203.0" x="814.0" y="506.6799999999999"/>
@@ -39,7 +37,6 @@
       </data>
     </node>
     <node id="n2">
-      <data key="d5"/>
       <data key="d6">
         <y:ShapeNode>
           <y:Geometry height="60.0" width="82.0" x="617.6" y="413.23"/>
@@ -52,7 +49,6 @@ Creator 0<y:LabelModel><y:SmartNodeLabelModel distance="4.0"/></y:LabelModel><y:
       </data>
     </node>
     <node id="n3">
-      <data key="d5"/>
       <data key="d6">
         <y:ShapeNode>
           <y:Geometry height="60.0" width="76.55999999999995" x="988.5" y="335.62999999999994"/>
@@ -65,7 +61,6 @@ Creator 2<y:LabelModel><y:SmartNodeLabelModel distance="4.0"/></y:LabelModel><y:
       </data>
     </node>
     <node id="n4">
-      <data key="d5"/>
       <data key="d6">
         <y:ShapeNode>
           <y:Geometry height="60.0" width="72.55999999999983" x="860.6610837438426" y="335.62999999999994"/>
@@ -78,7 +73,6 @@ Creator 1<y:LabelModel><y:SmartNodeLabelModel distance="4.0"/></y:LabelModel><y:
       </data>
     </node>
     <node id="n5">
-      <data key="d5"/>
       <data key="d6">
         <y:ShapeNode>
           <y:Geometry height="60.0" width="87.27999999999997" x="1112.52" y="335.62999999999994"/>
@@ -91,7 +85,6 @@ Creator 3<y:LabelModel><y:SmartNodeLabelModel distance="4.0"/></y:LabelModel><y:
       </data>
     </node>
     <node id="n6">
-      <data key="d5"/>
       <data key="d6">
         <y:ShapeNode>
           <y:Geometry height="60.0" width="126.0" x="781.0" y="620.26"/>
@@ -105,7 +98,6 @@ Event Reporting
       </data>
     </node>
     <node id="n7">
-      <data key="d5"/>
       <data key="d6">
         <y:ShapeNode>
           <y:Geometry height="60.0" width="118.63999999999987" x="928.2" y="620.26"/>
@@ -118,7 +110,6 @@ Event Action<y:LabelModel><y:SmartNodeLabelModel distance="4.0"/></y:LabelModel>
       </data>
     </node>
     <node id="n8">
-      <data key="d5"/>
       <data key="d6">
         <y:ShapeNode>
           <y:Geometry height="60.0" width="87.27999999999997" x="792.1260377358491" y="733.8400000000001"/>
@@ -139,11 +130,11 @@ Sink<y:LabelModel><y:SmartNodeLabelModel distance="4.0"/></y:LabelModel><y:Model
           <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
+    for event 0
 2. Event Creator 1 subscribes
-   for event group 2
+    for event group 2
 3. PUS Service 5 handler
-   subscribes for all events
+    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"/>
@@ -151,7 +142,6 @@ Sink<y:LabelModel><y:SmartNodeLabelModel distance="4.0"/></y:LabelModel><y:Model
       </data>
     </node>
     <edge id="e0" source="n4" target="n1">
-      <data key="d9"/>
       <data key="d10">
         <y:PolyLineEdge>
           <y:Path sx="8.058916256157545" sy="0.0" tx="-10.5" ty="0.0"/>
@@ -164,7 +154,6 @@ Sink<y:LabelModel><y:SmartNodeLabelModel distance="4.0"/></y:LabelModel><y:Model
       </data>
     </edge>
     <edge id="e1" source="n2" target="n1">
-      <data key="d9"/>
       <data key="d10">
         <y:PolyLineEdge>
           <y:Path sx="0.0" sy="11.93999999999994" tx="-83.5" ty="0.0">
@@ -179,7 +168,6 @@ Sink<y:LabelModel><y:SmartNodeLabelModel distance="4.0"/></y:LabelModel><y:Model
       </data>
     </edge>
     <edge id="e2" source="n3" target="n1">
-      <data key="d9"/>
       <data key="d10">
         <y:PolyLineEdge>
           <y:Path sx="-23.719999999999914" sy="5.5" tx="87.56000000000006" ty="0.0"/>
@@ -192,7 +180,6 @@ Sink<y:LabelModel><y:SmartNodeLabelModel distance="4.0"/></y:LabelModel><y:Model
       </data>
     </edge>
     <edge id="e3" source="n5" target="n1">
-      <data key="d9"/>
       <data key="d10">
         <y:PolyLineEdge>
           <y:Path sx="-6.275467980295616" sy="0.0" tx="57.5" ty="8.5">
@@ -207,7 +194,6 @@ event 4 (group 2)<y:LabelModel><y:SmartEdgeLabelModel autoRotationEnabled="false
       </data>
     </edge>
     <edge id="e4" source="n1" target="n6">
-      <data key="d9"/>
       <data key="d10">
         <y:PolyLineEdge>
           <y:Path sx="-65.0" sy="0.0" tx="6.5" ty="0.0"/>
@@ -219,7 +205,6 @@ event 4 (group 2)<y:LabelModel><y:SmartEdgeLabelModel autoRotationEnabled="false
       </data>
     </edge>
     <edge id="e5" source="n1" target="n7">
-      <data key="d9"/>
       <data key="d10">
         <y:PolyLineEdge>
           <y:Path sx="42.660000000000196" sy="0.0" tx="-29.359999999999786" ty="0.0"/>
@@ -231,7 +216,6 @@ event 4 (group 2)<y:LabelModel><y:SmartEdgeLabelModel autoRotationEnabled="false
       </data>
     </edge>
     <edge id="e6" source="n1" target="n2">
-      <data key="d9"/>
       <data key="d10">
         <y:PolyLineEdge>
           <y:Path sx="0.0" sy="0.0" tx="0.0" ty="0.0">
@@ -246,7 +230,6 @@ event 2<y:LabelModel><y:SmartEdgeLabelModel autoRotationEnabled="false" defaultA
       </data>
     </edge>
     <edge id="e7" source="n1" target="n4">
-      <data key="d9"/>
       <data key="d10">
         <y:PolyLineEdge>
           <y:Path sx="-35.69940886699487" sy="0.0" tx="-17.140492610837327" ty="1.5"/>
@@ -258,7 +241,6 @@ event 2<y:LabelModel><y:SmartEdgeLabelModel autoRotationEnabled="false" defaultA
       </data>
     </edge>
     <edge id="e8" source="n6" target="n8">
-      <data key="d9"/>
       <data key="d10">
         <y:PolyLineEdge>
           <y:Path sx="0.0" sy="0.0" tx="8.233962264150945" ty="-21.42352238805968"/>
diff --git a/fsrc-core/images/event_man_arch.png b/fsrc-core/images/event_man_arch.png
new file mode 100644
index 0000000000000000000000000000000000000000..61c8d7255dfe663247b6d21db6f368570fd5105c
GIT binary patch
literal 71832
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
Y_NLHOi$+i4r^p<a{~vQ%=akR{0C{5FhX4Qo

literal 0
HcmV?d00001

diff --git a/fsrc-core/img/event_man_arch.png b/fsrc-core/img/event_man_arch.png
deleted file mode 100644
index 24f7063efca9bf68b13bbe4d32883d6a04076919..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 71833
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%0DX9`w9Dl`-#o@5(M(*y-Cs~FQ&DnQ%v-=(_
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
QWrA$+boFyt=akR{06B0bivR!s

diff --git a/fsrc-core/src/event_man.rs b/fsrc-core/src/event_man.rs
index c5a6c9f..344195a 100644
--- a/fsrc-core/src/event_man.rs
+++ b/fsrc-core/src/event_man.rs
@@ -3,10 +3,24 @@
 //! This module provides components to perform event routing. The most important component for this
 //! task is the [EventManager]. It uses a map of event listeners and uses a dynamic [EventReceiver]
 //! instance to receive all events and then route 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 or can
-//! trigger a system response. This can be done with the [EventManager] like this:
+//! trigger a system response.
+//!
+//! The following graph shows how the event flow for such a setup could look like:
+//!
+//! ![Event flow][event_man_arch]
+//!
+//! This can be done with the [EventManager] like this:
 //!
 //!  1. Provide a concrete [SendEventProvider] implementation and a concrete [EventReceiver]
 //!     implementation. These abstraction allow to use different message queue backends.
diff --git a/fsrc-core/src/lib.rs b/fsrc-core/src/lib.rs
index 2ad940b..8655fe6 100644
--- a/fsrc-core/src/lib.rs
+++ b/fsrc-core/src/lib.rs
@@ -24,9 +24,9 @@ pub mod events;
 pub mod executable;
 pub mod hal;
 pub mod objects;
+pub mod params;
 #[cfg(feature = "alloc")]
 #[cfg_attr(doc_cfg, doc(cfg(feature = "alloc")))]
 pub mod pool;
 pub mod pus;
 pub mod tmtc;
-pub mod params;
diff --git a/fsrc-core/tests/pus_events.rs b/fsrc-core/tests/pus_events.rs
index 62c5dae..8250afb 100644
--- a/fsrc-core/tests/pus_events.rs
+++ b/fsrc-core/tests/pus_events.rs
@@ -1,9 +1,9 @@
 use fsrc_core::event_man::{EventManager, MpscEventReceiver, MpscEventU32SendProvider};
 use fsrc_core::events::{EventU32, EventU32TypedSev, Severity, SeverityInfo};
-use fsrc_core::pus::event_man::{DefaultPusMgmtBackendProvider, EventReporter, PusEventTmManager};
-use fsrc_core::pus::{EcssTmError, EcssTmSender};
 use fsrc_core::params::U32Pair;
 use fsrc_core::params::{Params, ParamsHeapless, WritableToBeBytes};
+use fsrc_core::pus::event_man::{DefaultPusMgmtBackendProvider, EventReporter, PusEventTmManager};
+use fsrc_core::pus::{EcssTmError, EcssTmSender};
 use spacepackets::ecss::PusPacket;
 use spacepackets::tm::PusTm;
 use std::sync::mpsc::{channel, SendError, TryRecvError};

From cf556a407fbba461c807dadf4d220265db2a55d2 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sat, 12 Nov 2022 23:13:55 +0100
Subject: [PATCH 33/40] some missing From impls

---
 fsrc-core/src/pus/verification.rs | 19 +++++++++++++++++++
 fsrc-example/src/bin/obsw/pus.rs  |  2 ++
 2 files changed, 21 insertions(+)

diff --git a/fsrc-core/src/pus/verification.rs b/fsrc-core/src/pus/verification.rs
index da56f69..5a35a12 100644
--- a/fsrc-core/src/pus/verification.rs
+++ b/fsrc-core/src/pus/verification.rs
@@ -197,12 +197,31 @@ pub struct StateAccepted;
 #[derive(Copy, Clone, Debug, Eq, PartialEq)]
 pub struct StateStarted;
 
+#[derive(Debug, Eq, PartialEq)]
 pub enum StateToken {
     None(StateNone),
     Accepted(StateAccepted),
     Started(StateStarted),
 }
 
+impl From<StateNone> for StateToken {
+    fn from(t: StateNone) -> Self {
+        StateToken::None(t)
+    }
+}
+
+impl From<StateAccepted> for StateToken {
+    fn from(t: StateAccepted) -> Self {
+        StateToken::Accepted(t)
+    }
+}
+
+impl From<StateStarted> for StateToken {
+    fn from(t: StateStarted) -> Self {
+        StateToken::Started(t)
+    }
+}
+
 impl<STATE> VerificationToken<STATE> {
     fn new(req_id: RequestId) -> VerificationToken<StateNone> {
         VerificationToken {
diff --git a/fsrc-example/src/bin/obsw/pus.rs b/fsrc-example/src/bin/obsw/pus.rs
index f4c59e3..4ab47b4 100644
--- a/fsrc-example/src/bin/obsw/pus.rs
+++ b/fsrc-example/src/bin/obsw/pus.rs
@@ -63,6 +63,8 @@ impl PusServiceProvider for PusReceiver {
         drop(reporter);
         if service == 17 {
             self.handle_test_service(pus_tc, accepted_token);
+        } else if service == 5 {
+            // TODO: Send message to event manager here
         }
         Ok(())
     }

From 8b110be07a552576f936e0b9bc66b418bdf8ac01 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sat, 12 Nov 2022 23:37:19 +0100
Subject: [PATCH 34/40] start adding first event components in example

---
 fsrc-core/src/event_man.rs        |  4 ++--
 fsrc-core/src/pus/event_man.rs    | 14 +++++++-------
 fsrc-core/tests/pus_events.rs     |  4 ++--
 fsrc-example/src/bin/obsw/main.rs | 26 +++++++++++++++++++++++++-
 fsrc-example/src/bin/obsw/tmtc.rs |  6 +++++-
 5 files changed, 41 insertions(+), 13 deletions(-)

diff --git a/fsrc-core/src/event_man.rs b/fsrc-core/src/event_man.rs
index 344195a..9b2812d 100644
--- a/fsrc-core/src/event_man.rs
+++ b/fsrc-core/src/event_man.rs
@@ -118,9 +118,9 @@ unsafe impl<E, Event: GenericEvent + Send, AuxDataProvider: Send> Send
 {
 }
 
-pub enum HandlerResult<Provider: GenericEvent, AuxDataProvider> {
+pub enum HandlerResult<Event: GenericEvent, AuxDataProvider> {
     Empty,
-    Handled(u32, Provider, Option<AuxDataProvider>),
+    Handled(u32, Event, Option<AuxDataProvider>),
 }
 
 impl<E, Event: GenericEvent + Copy> EventManager<E, Event> {
diff --git a/fsrc-core/src/pus/event_man.rs b/fsrc-core/src/pus/event_man.rs
index feef852..bbfe570 100644
--- a/fsrc-core/src/pus/event_man.rs
+++ b/fsrc-core/src/pus/event_man.rs
@@ -120,15 +120,15 @@ impl<SenderE> From<EcssTmError<SenderE>> for EventManError<SenderE> {
     }
 }
 
-pub struct PusEventTmManager<BackendError, Provider: GenericEvent> {
+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 PusEventTmManager<E, Event> {}
+unsafe impl<E: Send, Event: GenericEvent + Send> Send for PusEventDispatcher<E, Event> {}
 
-impl<BackendError, Provider: GenericEvent> PusEventTmManager<BackendError, Provider> {
+impl<BackendError, Provider: GenericEvent> PusEventDispatcher<BackendError, Provider> {
     pub fn new(
         reporter: EventReporter,
         backend: Box<dyn PusEventMgmtBackendProvider<Provider, Error = BackendError>>,
@@ -137,7 +137,7 @@ impl<BackendError, Provider: GenericEvent> PusEventTmManager<BackendError, Provi
     }
 }
 
-impl<BackendError, Event: GenericEvent> PusEventTmManager<BackendError, Event> {
+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)
     }
@@ -181,7 +181,7 @@ impl<BackendError, Event: GenericEvent> PusEventTmManager<BackendError, Event> {
     }
 }
 
-impl<BackendError> PusEventTmManager<BackendError, EventU32> {
+impl<BackendError> PusEventDispatcher<BackendError, EventU32> {
     pub fn enable_tm_for_event_with_sev<Severity: HasSeverity>(
         &mut self,
         event: &EventU32TypedSev<Severity>,
@@ -234,10 +234,10 @@ mod tests {
         }
     }
 
-    fn create_basic_man() -> PusEventTmManager<(), EventU32> {
+    fn create_basic_man() -> PusEventDispatcher<(), EventU32> {
         let reporter = EventReporter::new(0x02, 128).expect("Creating event repoter failed");
         let backend = DefaultPusMgmtBackendProvider::<EventU32>::default();
-        PusEventTmManager::new(reporter, Box::new(backend))
+        PusEventDispatcher::new(reporter, Box::new(backend))
     }
 
     #[test]
diff --git a/fsrc-core/tests/pus_events.rs b/fsrc-core/tests/pus_events.rs
index 8250afb..d51a5f1 100644
--- a/fsrc-core/tests/pus_events.rs
+++ b/fsrc-core/tests/pus_events.rs
@@ -2,7 +2,7 @@ use fsrc_core::event_man::{EventManager, MpscEventReceiver, MpscEventU32SendProv
 use fsrc_core::events::{EventU32, EventU32TypedSev, Severity, SeverityInfo};
 use fsrc_core::params::U32Pair;
 use fsrc_core::params::{Params, ParamsHeapless, WritableToBeBytes};
-use fsrc_core::pus::event_man::{DefaultPusMgmtBackendProvider, EventReporter, PusEventTmManager};
+use fsrc_core::pus::event_man::{DefaultPusMgmtBackendProvider, EventReporter, PusEventDispatcher};
 use fsrc_core::pus::{EcssTmError, EcssTmSender};
 use spacepackets::ecss::PusPacket;
 use spacepackets::tm::PusTm;
@@ -40,7 +40,7 @@ fn test_threaded_usage() {
     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 = PusEventTmManager::new(reporter, Box::new(backend));
+    let mut pus_event_man = PusEventDispatcher::new(reporter, Box::new(backend));
     // PUS + Generic event manager thread
     let jh0 = thread::spawn(move || {
         let mut sender = EventTmSender { sender: event_tx };
diff --git a/fsrc-example/src/bin/obsw/main.rs b/fsrc-example/src/bin/obsw/main.rs
index a7c5de1..f276e6f 100644
--- a/fsrc-example/src/bin/obsw/main.rs
+++ b/fsrc-example/src/bin/obsw/main.rs
@@ -3,14 +3,19 @@ mod pus;
 mod tmtc;
 
 use crate::tmtc::{core_tmtc_task, TmStore, PUS_APID};
+use fsrc_core::event_man::{EventManager, MpscEventReceiver, MpscEventU32SendProvider};
+use fsrc_core::events::EventU32;
 use fsrc_core::hal::host::udp_server::UdpTcServer;
+use fsrc_core::params::Params;
 use fsrc_core::pool::{LocalPool, PoolCfg, SharedPool, StoreAddr};
+use fsrc_core::pus::event_man::{DefaultPusMgmtBackendProvider, EventReporter, PusEventDispatcher};
 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::{channel, TryRecvError};
 use std::sync::{mpsc, Arc, Mutex, RwLock};
 use std::thread;
 
@@ -44,13 +49,23 @@ fn main() {
         verif_cfg,
         Box::new(sender),
     )));
+    let (event_sender, event_man_rx) = channel();
+    let event_recv = MpscEventReceiver::<EventU32>::new(event_man_rx);
+    let mut event_man = EventManager::new(Box::new(event_recv));
+    let event_reporter = EventReporter::new(PUS_APID, 128).unwrap();
+    let pus_tm_backend = DefaultPusMgmtBackendProvider::<EventU32>::default();
+    let pus_event_man = 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);
     let jh0 = thread::spawn(move || {
         core_tmtc_task(
             tm_funnel_tx.clone(),
             tm_server_rx,
             tm_store_helper.clone(),
             addr,
-            reporter_with_sender_0,
+            reporter_with_sender_0.clone(),
+            event_sender.clone(),
         );
     });
 
@@ -68,6 +83,15 @@ fn main() {
             }
         }
     });
+
+    let jh2 = thread::spawn(move || loop {
+        match pus_event_man_rx.try_recv() {
+            Ok(_) => {}
+            Err(_) => {}
+        }
+    });
+
     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");
 }
diff --git a/fsrc-example/src/bin/obsw/tmtc.rs b/fsrc-example/src/bin/obsw/tmtc.rs
index 3b3e88e..56352b0 100644
--- a/fsrc-example/src/bin/obsw/tmtc.rs
+++ b/fsrc-example/src/bin/obsw/tmtc.rs
@@ -1,6 +1,9 @@
+use fsrc_core::events::EventU32;
 use fsrc_core::hal::host::udp_server::{ReceiveResult, UdpTcServer};
+use fsrc_core::params::Params;
 use std::net::SocketAddr;
 use std::sync::mpsc;
+use std::sync::mpsc::Sender;
 use std::thread;
 use std::time::Duration;
 
@@ -31,11 +34,12 @@ impl TmStore {
 }
 
 pub fn core_tmtc_task(
-    tm_creator_tx: mpsc::Sender<StoreAddr>,
+    tm_creator_tx: Sender<StoreAddr>,
     tm_server_rx: mpsc::Receiver<StoreAddr>,
     tm_store_helper: TmStore,
     addr: SocketAddr,
     verif_reporter: SharedStdVerifReporterWithSender,
+    _event_tx: Sender<(EventU32, Option<Params>)>,
 ) {
     let pus_receiver = PusReceiver::new(
         PUS_APID,

From 9cc58432c8cf93d30fa1c62b95cd65054b48a6b7 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sun, 13 Nov 2022 21:07:16 +0100
Subject: [PATCH 35/40] continue event service integration

---
 fsrc-core/src/pus/event_man.rs    |  13 +++
 fsrc-core/src/pus/verification.rs | 146 +++++++++++++++---------------
 fsrc-example/src/bin/obsw/main.rs | 113 +++++++++++++++++++----
 fsrc-example/src/bin/obsw/pus.rs  |   4 +-
 fsrc-example/src/bin/obsw/tmtc.rs |  18 ++--
 5 files changed, 195 insertions(+), 99 deletions(-)

diff --git a/fsrc-core/src/pus/event_man.rs b/fsrc-core/src/pus/event_man.rs
index bbfe570..4232258 100644
--- a/fsrc-core/src/pus/event_man.rs
+++ b/fsrc-core/src/pus/event_man.rs
@@ -5,6 +5,7 @@ use hashbrown::HashSet;
 
 #[cfg(feature = "alloc")]
 pub use crate::pus::event::EventReporter;
+use crate::pus::verification::{TcStateStarted, VerificationToken};
 use crate::pus::{EcssTmError, EcssTmSender};
 #[cfg(feature = "heapless")]
 #[cfg_attr(doc_cfg, doc(cfg(feature = "heapless")))]
@@ -108,6 +109,18 @@ pub mod heapless_mod {
     }
 }
 
+#[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: VerificationToken<TcStateStarted>,
+}
+
 #[derive(Debug)]
 pub enum EventManError<SenderE> {
     EcssTmError(EcssTmError<SenderE>),
diff --git a/fsrc-core/src/pus/verification.rs b/fsrc-core/src/pus/verification.rs
index 5a35a12..76cfc5c 100644
--- a/fsrc-core/src/pus/verification.rs
+++ b/fsrc-core/src/pus/verification.rs
@@ -191,39 +191,39 @@ pub struct VerificationToken<STATE> {
 }
 
 #[derive(Copy, Clone, Debug, Eq, PartialEq)]
-pub struct StateNone;
+pub struct TcStateNone;
 #[derive(Copy, Clone, Debug, Eq, PartialEq)]
-pub struct StateAccepted;
+pub struct TcStateAccepted;
 #[derive(Copy, Clone, Debug, Eq, PartialEq)]
-pub struct StateStarted;
+pub struct TcStateStarted;
 
 #[derive(Debug, Eq, PartialEq)]
-pub enum StateToken {
-    None(StateNone),
-    Accepted(StateAccepted),
-    Started(StateStarted),
+pub enum TcStateToken {
+    None(VerificationToken<TcStateNone>),
+    Accepted(VerificationToken<TcStateAccepted>),
+    Started(VerificationToken<TcStateStarted>),
 }
 
-impl From<StateNone> for StateToken {
-    fn from(t: StateNone) -> Self {
-        StateToken::None(t)
+impl From<VerificationToken<TcStateNone>> for TcStateToken {
+    fn from(t: VerificationToken<TcStateNone>) -> Self {
+        TcStateToken::None(t)
     }
 }
 
-impl From<StateAccepted> for StateToken {
-    fn from(t: StateAccepted) -> Self {
-        StateToken::Accepted(t)
+impl From<VerificationToken<TcStateAccepted>> for TcStateToken {
+    fn from(t: VerificationToken<TcStateAccepted>) -> Self {
+        TcStateToken::Accepted(t)
     }
 }
 
-impl From<StateStarted> for StateToken {
-    fn from(t: StateStarted) -> Self {
-        StateToken::Started(t)
+impl From<VerificationToken<TcStateStarted>> for TcStateToken {
+    fn from(t: VerificationToken<TcStateStarted>) -> Self {
+        TcStateToken::Started(t)
     }
 }
 
 impl<STATE> VerificationToken<STATE> {
-    fn new(req_id: RequestId) -> VerificationToken<StateNone> {
+    fn new(req_id: RequestId) -> VerificationToken<TcStateNone> {
         VerificationToken {
             state: PhantomData,
             req_id,
@@ -316,24 +316,25 @@ impl VerificationReporterBasic {
 
     /// 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> {
+    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<StateNone> {
-        VerificationToken::<StateNone>::new(req_id)
+    pub fn add_tc_with_req_id(&mut self, req_id: RequestId) -> VerificationToken<TcStateNone> {
+        VerificationToken::<TcStateNone>::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,
         buf: &mut [u8],
-        token: VerificationToken<StateNone>,
+        token: VerificationToken<TcStateNone>,
         sender: &mut (impl EcssTmSender<Error = E> + ?Sized),
         time_stamp: &[u8],
-    ) -> Result<VerificationToken<StateAccepted>, VerificationErrorWithToken<E, StateNone>> {
+    ) -> Result<VerificationToken<TcStateAccepted>, VerificationErrorWithToken<E, TcStateNone>>
+    {
         let tm = self
             .create_pus_verif_success_tm(
                 buf,
@@ -357,10 +358,10 @@ impl VerificationReporterBasic {
     pub fn acceptance_failure<E>(
         &mut self,
         buf: &mut [u8],
-        token: VerificationToken<StateNone>,
+        token: VerificationToken<TcStateNone>,
         sender: &mut (impl EcssTmSender<Error = E> + ?Sized),
         params: FailParams,
-    ) -> Result<(), VerificationErrorWithToken<E, StateNone>> {
+    ) -> Result<(), VerificationErrorWithToken<E, TcStateNone>> {
         let tm = self
             .create_pus_verif_fail_tm(
                 buf,
@@ -383,10 +384,11 @@ impl VerificationReporterBasic {
     pub fn start_success<E>(
         &mut self,
         buf: &mut [u8],
-        token: VerificationToken<StateAccepted>,
+        token: VerificationToken<TcStateAccepted>,
         sender: &mut (impl EcssTmSender<Error = E> + ?Sized),
         time_stamp: &[u8],
-    ) -> Result<VerificationToken<StateStarted>, VerificationErrorWithToken<E, StateAccepted>> {
+    ) -> Result<VerificationToken<TcStateStarted>, VerificationErrorWithToken<E, TcStateAccepted>>
+    {
         let tm = self
             .create_pus_verif_success_tm(
                 buf,
@@ -413,10 +415,10 @@ impl VerificationReporterBasic {
     pub fn start_failure<E>(
         &mut self,
         buf: &mut [u8],
-        token: VerificationToken<StateAccepted>,
+        token: VerificationToken<TcStateAccepted>,
         sender: &mut (impl EcssTmSender<Error = E> + ?Sized),
         params: FailParams,
-    ) -> Result<(), VerificationErrorWithToken<E, StateAccepted>> {
+    ) -> Result<(), VerificationErrorWithToken<E, TcStateAccepted>> {
         let tm = self
             .create_pus_verif_fail_tm(
                 buf,
@@ -439,7 +441,7 @@ impl VerificationReporterBasic {
     pub fn step_success<E>(
         &mut self,
         buf: &mut [u8],
-        token: &VerificationToken<StateStarted>,
+        token: &VerificationToken<TcStateStarted>,
         sender: &mut (impl EcssTmSender<Error = E> + ?Sized),
         time_stamp: &[u8],
         step: impl EcssEnumeration,
@@ -463,10 +465,10 @@ impl VerificationReporterBasic {
     pub fn step_failure<E>(
         &mut self,
         buf: &mut [u8],
-        token: VerificationToken<StateStarted>,
+        token: VerificationToken<TcStateStarted>,
         sender: &mut (impl EcssTmSender<Error = E> + ?Sized),
         params: FailParamsWithStep,
-    ) -> Result<(), VerificationErrorWithToken<E, StateStarted>> {
+    ) -> Result<(), VerificationErrorWithToken<E, TcStateStarted>> {
         let tm = self
             .create_pus_verif_fail_tm(
                 buf,
@@ -490,10 +492,10 @@ impl VerificationReporterBasic {
     pub fn completion_success<E>(
         &mut self,
         buf: &mut [u8],
-        token: VerificationToken<StateStarted>,
+        token: VerificationToken<TcStateStarted>,
         sender: &mut (impl EcssTmSender<Error = E> + ?Sized),
         time_stamp: &[u8],
-    ) -> Result<(), VerificationErrorWithToken<E, StateStarted>> {
+    ) -> Result<(), VerificationErrorWithToken<E, TcStateStarted>> {
         let tm = self
             .create_pus_verif_success_tm(
                 buf,
@@ -517,10 +519,10 @@ impl VerificationReporterBasic {
     pub fn completion_failure<E>(
         &mut self,
         buf: &mut [u8],
-        token: VerificationToken<StateStarted>,
+        token: VerificationToken<TcStateStarted>,
         sender: &mut (impl EcssTmSender<Error = E> + ?Sized),
         params: FailParams,
-    ) -> Result<(), VerificationErrorWithToken<E, StateStarted>> {
+    ) -> Result<(), VerificationErrorWithToken<E, TcStateStarted>> {
         let tm = self
             .create_pus_verif_fail_tm(
                 buf,
@@ -689,8 +691,8 @@ mod allocmod {
             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<StateNone>;
-                pub fn add_tc_with_req_id(&mut self, req_id: RequestId) -> VerificationToken<StateNone>;
+                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);
             }
@@ -703,10 +705,10 @@ mod allocmod {
         /// 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>,
+            token: VerificationToken<TcStateNone>,
             sender: &mut (impl EcssTmSender<Error = E> + ?Sized),
             time_stamp: &[u8],
-        ) -> Result<VerificationToken<StateAccepted>, VerificationErrorWithToken<E, StateNone>>
+        ) -> Result<VerificationToken<TcStateAccepted>, VerificationErrorWithToken<E, TcStateNone>>
         {
             self.reporter.acceptance_success(
                 self.source_data_buf.as_mut_slice(),
@@ -719,10 +721,10 @@ mod allocmod {
         /// 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>,
+            token: VerificationToken<TcStateNone>,
             sender: &mut (impl EcssTmSender<Error = E> + ?Sized),
             params: FailParams,
-        ) -> Result<(), VerificationErrorWithToken<E, StateNone>> {
+        ) -> Result<(), VerificationErrorWithToken<E, TcStateNone>> {
             self.reporter.acceptance_failure(
                 self.source_data_buf.as_mut_slice(),
                 token,
@@ -736,10 +738,10 @@ mod allocmod {
         /// Requires a token previously acquired by calling [Self::acceptance_success].
         pub fn start_success<E>(
             &mut self,
-            token: VerificationToken<StateAccepted>,
+            token: VerificationToken<TcStateAccepted>,
             sender: &mut (impl EcssTmSender<Error = E> + ?Sized),
             time_stamp: &[u8],
-        ) -> Result<VerificationToken<StateStarted>, VerificationErrorWithToken<E, StateAccepted>>
+        ) -> Result<VerificationToken<TcStateStarted>, VerificationErrorWithToken<E, TcStateAccepted>>
         {
             self.reporter.start_success(
                 self.source_data_buf.as_mut_slice(),
@@ -755,10 +757,10 @@ mod allocmod {
         /// the token because verification handling is done.
         pub fn start_failure<E>(
             &mut self,
-            token: VerificationToken<StateAccepted>,
+            token: VerificationToken<TcStateAccepted>,
             sender: &mut (impl EcssTmSender<Error = E> + ?Sized),
             params: FailParams,
-        ) -> Result<(), VerificationErrorWithToken<E, StateAccepted>> {
+        ) -> Result<(), VerificationErrorWithToken<E, TcStateAccepted>> {
             self.reporter
                 .start_failure(self.source_data_buf.as_mut_slice(), token, sender, params)
         }
@@ -768,7 +770,7 @@ mod allocmod {
         /// Requires a token previously acquired by calling [Self::start_success].
         pub fn step_success<E>(
             &mut self,
-            token: &VerificationToken<StateStarted>,
+            token: &VerificationToken<TcStateStarted>,
             sender: &mut (impl EcssTmSender<Error = E> + ?Sized),
             time_stamp: &[u8],
             step: impl EcssEnumeration,
@@ -788,10 +790,10 @@ mod allocmod {
         /// token because verification handling is done.
         pub fn step_failure<E>(
             &mut self,
-            token: VerificationToken<StateStarted>,
+            token: VerificationToken<TcStateStarted>,
             sender: &mut (impl EcssTmSender<Error = E> + ?Sized),
             params: FailParamsWithStep,
-        ) -> Result<(), VerificationErrorWithToken<E, StateStarted>> {
+        ) -> Result<(), VerificationErrorWithToken<E, TcStateStarted>> {
             self.reporter
                 .step_failure(self.source_data_buf.as_mut_slice(), token, sender, params)
         }
@@ -802,10 +804,10 @@ mod allocmod {
         /// token because verification handling is done.
         pub fn completion_success<E>(
             &mut self,
-            token: VerificationToken<StateStarted>,
+            token: VerificationToken<TcStateStarted>,
             sender: &mut (impl EcssTmSender<Error = E> + ?Sized),
             time_stamp: &[u8],
-        ) -> Result<(), VerificationErrorWithToken<E, StateStarted>> {
+        ) -> Result<(), VerificationErrorWithToken<E, TcStateStarted>> {
             self.reporter.completion_success(
                 self.source_data_buf.as_mut_slice(),
                 token,
@@ -820,10 +822,10 @@ mod allocmod {
         /// token because verification handling is done.
         pub fn completion_failure<E>(
             &mut self,
-            token: VerificationToken<StateStarted>,
+            token: VerificationToken<TcStateStarted>,
             sender: &mut (impl EcssTmSender<Error = E> + ?Sized),
             params: FailParams,
-        ) -> Result<(), VerificationErrorWithToken<E, StateStarted>> {
+        ) -> Result<(), VerificationErrorWithToken<E, TcStateStarted>> {
             self.reporter.completion_failure(
                 self.source_data_buf.as_mut_slice(),
                 token,
@@ -857,8 +859,8 @@ mod allocmod {
             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<StateNone>;
-                pub fn add_tc_with_req_id(&mut self, req_id: RequestId) -> VerificationToken<StateNone>;
+                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);
             }
@@ -866,9 +868,9 @@ mod allocmod {
 
         pub fn acceptance_success(
             &mut self,
-            token: VerificationToken<StateNone>,
+            token: VerificationToken<TcStateNone>,
             time_stamp: &[u8],
-        ) -> Result<VerificationToken<StateAccepted>, VerificationErrorWithToken<E, StateNone>>
+        ) -> Result<VerificationToken<TcStateAccepted>, VerificationErrorWithToken<E, TcStateNone>>
         {
             self.reporter
                 .acceptance_success(token, self.sender.as_mut(), time_stamp)
@@ -876,18 +878,18 @@ mod allocmod {
 
         pub fn acceptance_failure(
             &mut self,
-            token: VerificationToken<StateNone>,
+            token: VerificationToken<TcStateNone>,
             params: FailParams,
-        ) -> Result<(), VerificationErrorWithToken<E, StateNone>> {
+        ) -> Result<(), VerificationErrorWithToken<E, TcStateNone>> {
             self.reporter
                 .acceptance_failure(token, self.sender.as_mut(), params)
         }
 
         pub fn start_success(
             &mut self,
-            token: VerificationToken<StateAccepted>,
+            token: VerificationToken<TcStateAccepted>,
             time_stamp: &[u8],
-        ) -> Result<VerificationToken<StateStarted>, VerificationErrorWithToken<E, StateAccepted>>
+        ) -> Result<VerificationToken<TcStateStarted>, VerificationErrorWithToken<E, TcStateAccepted>>
         {
             self.reporter
                 .start_success(token, self.sender.as_mut(), time_stamp)
@@ -895,16 +897,16 @@ mod allocmod {
 
         pub fn start_failure(
             &mut self,
-            token: VerificationToken<StateAccepted>,
+            token: VerificationToken<TcStateAccepted>,
             params: FailParams,
-        ) -> Result<(), VerificationErrorWithToken<E, StateAccepted>> {
+        ) -> Result<(), VerificationErrorWithToken<E, TcStateAccepted>> {
             self.reporter
                 .start_failure(token, self.sender.as_mut(), params)
         }
 
         pub fn step_success(
             &mut self,
-            token: &VerificationToken<StateStarted>,
+            token: &VerificationToken<TcStateStarted>,
             time_stamp: &[u8],
             step: impl EcssEnumeration,
         ) -> Result<(), EcssTmError<E>> {
@@ -914,27 +916,27 @@ mod allocmod {
 
         pub fn step_failure(
             &mut self,
-            token: VerificationToken<StateStarted>,
+            token: VerificationToken<TcStateStarted>,
             params: FailParamsWithStep,
-        ) -> Result<(), VerificationErrorWithToken<E, StateStarted>> {
+        ) -> Result<(), VerificationErrorWithToken<E, TcStateStarted>> {
             self.reporter
                 .step_failure(token, self.sender.as_mut(), params)
         }
 
         pub fn completion_success(
             &mut self,
-            token: VerificationToken<StateStarted>,
+            token: VerificationToken<TcStateStarted>,
             time_stamp: &[u8],
-        ) -> Result<(), VerificationErrorWithToken<E, StateStarted>> {
+        ) -> Result<(), VerificationErrorWithToken<E, TcStateStarted>> {
             self.reporter
                 .completion_success(token, self.sender.as_mut(), time_stamp)
         }
 
         pub fn completion_failure(
             &mut self,
-            token: VerificationToken<StateStarted>,
+            token: VerificationToken<TcStateStarted>,
             params: FailParams,
-        ) -> Result<(), VerificationErrorWithToken<E, StateStarted>> {
+        ) -> Result<(), VerificationErrorWithToken<E, TcStateStarted>> {
             self.reporter
                 .completion_failure(token, self.sender.as_mut(), params)
         }
@@ -1092,7 +1094,7 @@ mod stdmod {
 mod tests {
     use crate::pus::tests::CommonTmInfo;
     use crate::pus::verification::{
-        EcssTmError, EcssTmSender, FailParams, FailParamsWithStep, RequestId, StateNone,
+        EcssTmError, EcssTmSender, FailParams, FailParamsWithStep, RequestId, TcStateNone,
         VerificationReporter, VerificationReporterCfg, VerificationReporterWithSender,
         VerificationToken,
     };
@@ -1193,7 +1195,7 @@ mod tests {
         (pus_tc, req_id)
     }
 
-    fn base_init(api_sel: bool) -> (TestBase<'static>, VerificationToken<StateNone>) {
+    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;
@@ -1207,7 +1209,7 @@ mod tests {
 
     fn base_with_helper_init() -> (
         TestBaseWithHelper<'static, ()>,
-        VerificationToken<StateNone>,
+        VerificationToken<TcStateNone>,
     ) {
         let mut reporter = base_reporter();
         let (tc, _) = base_tc_init(None);
diff --git a/fsrc-example/src/bin/obsw/main.rs b/fsrc-example/src/bin/obsw/main.rs
index f276e6f..638f3f9 100644
--- a/fsrc-example/src/bin/obsw/main.rs
+++ b/fsrc-example/src/bin/obsw/main.rs
@@ -2,20 +2,25 @@ mod ccsds;
 mod pus;
 mod tmtc;
 
-use crate::tmtc::{core_tmtc_task, TmStore, PUS_APID};
+use crate::tmtc::{core_tmtc_task, CoreTmtcArgs, TmStore, PUS_APID};
 use fsrc_core::event_man::{EventManager, MpscEventReceiver, MpscEventU32SendProvider};
 use fsrc_core::events::EventU32;
 use fsrc_core::hal::host::udp_server::UdpTcServer;
-use fsrc_core::params::Params;
 use fsrc_core::pool::{LocalPool, PoolCfg, SharedPool, StoreAddr};
-use fsrc_core::pus::event_man::{DefaultPusMgmtBackendProvider, EventReporter, PusEventDispatcher};
+use fsrc_core::pus::event_man::{
+    DefaultPusMgmtBackendProvider, EventReporter, EventRequest, EventRequestWithToken,
+    PusEventDispatcher,
+};
 use fsrc_core::pus::verification::{
     MpscVerifSender, VerificationReporterCfg, VerificationReporterWithSender,
 };
+use fsrc_core::pus::{EcssTmError, EcssTmSender};
 use fsrc_core::tmtc::CcsdsError;
 use fsrc_example::{OBSW_SERVER_ADDR, SERVER_PORT};
+use spacepackets::time::{CdsShortTimeProvider, TimeWriter};
+use spacepackets::tm::PusTm;
 use std::net::{IpAddr, SocketAddr};
-use std::sync::mpsc::{channel, TryRecvError};
+use std::sync::mpsc::channel;
 use std::sync::{mpsc, Arc, Mutex, RwLock};
 use std::thread;
 
@@ -32,6 +37,28 @@ struct UdpTmtcServer {
 
 unsafe impl Send for UdpTmtcServer {}
 
+struct EventTmSender {
+    store_helper: TmStore,
+    sender: mpsc::Sender<StoreAddr>,
+}
+
+impl EventTmSender {
+    fn new(store_helper: TmStore, sender: mpsc::Sender<StoreAddr>) -> Self {
+        Self {
+            store_helper,
+            sender,
+        }
+    }
+}
+
+impl EcssTmSender for EventTmSender {
+    type Error = mpsc::SendError<StoreAddr>;
+
+    fn send_tm(&mut self, tm: PusTm) -> Result<(), EcssTmError<Self::Error>> {
+        let addr = self.store_helper.add_pus_tm(&tm);
+        self.sender.send(addr).map_err(EcssTmError::SendError)
+    }
+}
 fn main() {
     println!("Running OBSW example");
     let pool_cfg = PoolCfg::new(vec![(8, 32), (4, 64), (2, 128)]);
@@ -41,32 +68,38 @@ fn main() {
         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 (tm_funnel_tx, tm_funnel_rx) = channel();
+    let (tm_server_tx, tm_server_rx) = channel();
     let sender = MpscVerifSender::new(tm_store.clone(), tm_funnel_tx.clone());
     let verif_cfg = VerificationReporterCfg::new(PUS_APID, 1, 2, 8).unwrap();
     let reporter_with_sender_0 = Arc::new(Mutex::new(VerificationReporterWithSender::new(
         verif_cfg,
         Box::new(sender),
     )));
+
+    // Create event handling components
+    let (event_request_tx, event_request_rx) = channel::<EventRequestWithToken>();
     let (event_sender, event_man_rx) = channel();
     let event_recv = MpscEventReceiver::<EventU32>::new(event_man_rx);
     let mut event_man = EventManager::new(Box::new(event_recv));
     let event_reporter = EventReporter::new(PUS_APID, 128).unwrap();
     let pus_tm_backend = DefaultPusMgmtBackendProvider::<EventU32>::default();
-    let pus_event_man = PusEventDispatcher::new(event_reporter, Box::new(pus_tm_backend));
+    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);
+    let reporter1 = reporter_with_sender_0.clone();
     event_man.subscribe_all(pus_event_man_send_provider);
+
+    // Create clones here to allow move for thread 0
+    let core_args = CoreTmtcArgs {
+        tm_store: tm_store_helper.clone(),
+        tm_sender: tm_funnel_tx.clone(),
+        event_sender,
+        event_request_tx,
+    };
     let jh0 = thread::spawn(move || {
-        core_tmtc_task(
-            tm_funnel_tx.clone(),
-            tm_server_rx,
-            tm_store_helper.clone(),
-            addr,
-            reporter_with_sender_0.clone(),
-            event_sender.clone(),
-        );
+        core_tmtc_task(core_args, tm_server_rx, addr, reporter_with_sender_0);
     });
 
     let jh1 = thread::spawn(move || {
@@ -84,10 +117,43 @@ fn main() {
         }
     });
 
-    let jh2 = thread::spawn(move || loop {
-        match pus_event_man_rx.try_recv() {
-            Ok(_) => {}
-            Err(_) => {}
+    let jh2 = thread::spawn(move || {
+        let mut timestamp: [u8; 7] = [0; 7];
+        let mut sender = EventTmSender::new(tm_store_helper, tm_funnel_tx);
+        let mut time_provider = CdsShortTimeProvider::new(0, 0);
+        let report_completion = |event_req: EventRequestWithToken, timestamp: &[u8]| {
+            let mut reporter = reporter1
+                .lock()
+                .expect("Locking Verification reporter failed");
+            reporter
+                .completion_success(event_req.token, timestamp)
+                .expect("Sending completion success failed");
+        };
+        loop {
+            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);
+                    }
+                }
+            }
+            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");
+            }
         }
     });
 
@@ -95,3 +161,12 @@ fn main() {
     jh1.join().expect("Joining TM Funnel thread failed");
     jh2.join().expect("Joining Event Manager thread failed");
 }
+
+pub fn update_time(time_provider: &mut CdsShortTimeProvider, 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/fsrc-example/src/bin/obsw/pus.rs b/fsrc-example/src/bin/obsw/pus.rs
index 4ab47b4..c0a0c68 100644
--- a/fsrc-example/src/bin/obsw/pus.rs
+++ b/fsrc-example/src/bin/obsw/pus.rs
@@ -1,7 +1,7 @@
 use crate::tmtc::TmStore;
 use fsrc_core::pool::StoreAddr;
 use fsrc_core::pus::verification::{
-    SharedStdVerifReporterWithSender, StateAccepted, VerificationToken,
+    SharedStdVerifReporterWithSender, TcStateAccepted, VerificationToken,
 };
 use fsrc_core::tmtc::tm_helper::PusTmWithCdsShortHelper;
 use fsrc_core::tmtc::PusServiceProvider;
@@ -71,7 +71,7 @@ impl PusServiceProvider for PusReceiver {
 }
 
 impl PusReceiver {
-    fn handle_test_service(&mut self, pus_tc: &PusTc, token: VerificationToken<StateAccepted>) {
+    fn handle_test_service(&mut self, pus_tc: &PusTc, token: VerificationToken<TcStateAccepted>) {
         if pus_tc.subservice() == 1 {
             println!("Received PUS ping command TC[17,1]");
             println!("Sending ping reply PUS TM[17,2]");
diff --git a/fsrc-example/src/bin/obsw/tmtc.rs b/fsrc-example/src/bin/obsw/tmtc.rs
index 56352b0..3ff05f4 100644
--- a/fsrc-example/src/bin/obsw/tmtc.rs
+++ b/fsrc-example/src/bin/obsw/tmtc.rs
@@ -11,12 +11,20 @@ use crate::ccsds::CcsdsReceiver;
 use crate::pus::PusReceiver;
 use crate::UdpTmtcServer;
 use fsrc_core::pool::{SharedPool, StoreAddr};
+use fsrc_core::pus::event_man::EventRequestWithToken;
 use fsrc_core::pus::verification::SharedStdVerifReporterWithSender;
 use fsrc_core::tmtc::{CcsdsDistributor, CcsdsError, PusDistributor};
 use spacepackets::tm::PusTm;
 
 pub const PUS_APID: u16 = 0x02;
 
+pub struct CoreTmtcArgs {
+    pub tm_store: TmStore,
+    pub tm_sender: Sender<StoreAddr>,
+    pub event_sender: Sender<(EventU32, Option<Params>)>,
+    pub event_request_tx: Sender<EventRequestWithToken>,
+}
+
 #[derive(Clone)]
 pub struct TmStore {
     pub pool: SharedPool,
@@ -34,17 +42,15 @@ impl TmStore {
 }
 
 pub fn core_tmtc_task(
-    tm_creator_tx: Sender<StoreAddr>,
+    args: CoreTmtcArgs,
     tm_server_rx: mpsc::Receiver<StoreAddr>,
-    tm_store_helper: TmStore,
     addr: SocketAddr,
     verif_reporter: SharedStdVerifReporterWithSender,
-    _event_tx: Sender<(EventU32, Option<Params>)>,
 ) {
     let pus_receiver = PusReceiver::new(
         PUS_APID,
-        tm_creator_tx,
-        tm_store_helper.clone(),
+        args.tm_sender,
+        args.tm_store.clone(),
         verif_reporter,
     );
     let pus_distributor = PusDistributor::new(Box::new(pus_receiver));
@@ -58,7 +64,7 @@ pub fn core_tmtc_task(
     let mut udp_tmtc_server = UdpTmtcServer {
         udp_tc_server,
         tm_rx: tm_server_rx,
-        tm_store: tm_store_helper.pool.clone(),
+        tm_store: args.tm_store.pool.clone(),
     };
     loop {
         core_tmtc_loop(&mut udp_tmtc_server);

From 01f500a409369ccfde5657393eafba2d91d232dd Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Wed, 16 Nov 2022 10:20:44 +0100
Subject: [PATCH 36/40] add table impl

---
 fsrc-core/src/event_man.rs | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/fsrc-core/src/event_man.rs b/fsrc-core/src/event_man.rs
index 9b2812d..93df545 100644
--- a/fsrc-core/src/event_man.rs
+++ b/fsrc-core/src/event_man.rs
@@ -96,6 +96,14 @@ pub trait EventReceiver<Event: GenericEvent, AuxDataProvider = Params> {
     fn receive(&mut self) -> Option<(Event, Option<AuxDataProvider>)>;
 }
 
+pub trait ListenerTable<SendProviderError, Event: GenericEvent = EventU32, AuxDataProvider = Params>
+{
+    fn get_listeners(
+        &mut self,
+        key: ListenerType,
+    ) -> &[Listener<SendProviderError, Event, AuxDataProvider>];
+}
+
 /// Generic event manager implementation.
 ///
 /// # Generics
@@ -107,6 +115,7 @@ pub trait EventReceiver<Event: GenericEvent, AuxDataProvider = Params> {
 pub struct EventManager<SendProviderError, Event: GenericEvent = EventU32, AuxDataProvider = Params>
 {
     listeners: HashMap<ListenerType, Vec<Listener<SendProviderError, Event, AuxDataProvider>>>,
+    //listener_table: Box<dyn ListenerTable<SendProviderError, Event, AuxDataProvider>>,
     event_receiver: Box<dyn EventReceiver<Event, AuxDataProvider>>,
 }
 

From 3f84a06fd573b7210657cee40cc110ef2de61995 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Wed, 16 Nov 2022 11:03:40 +0100
Subject: [PATCH 37/40] add functions to update event manager table

---
 fsrc-core/src/event_man.rs | 101 ++++++++++++++++++++++++++++++-------
 1 file changed, 84 insertions(+), 17 deletions(-)

diff --git a/fsrc-core/src/event_man.rs b/fsrc-core/src/event_man.rs
index 93df545..3e191eb 100644
--- a/fsrc-core/src/event_man.rs
+++ b/fsrc-core/src/event_man.rs
@@ -46,13 +46,14 @@ use crate::params::{Params, ParamsHeapless};
 use alloc::boxed::Box;
 use alloc::vec;
 use alloc::vec::Vec;
+use core::slice::Iter;
 use hashbrown::HashMap;
 
 #[cfg(feature = "std")]
 pub use stdmod::*;
 
 #[derive(PartialEq, Eq, Hash, Copy, Clone)]
-enum ListenerType {
+pub enum ListenerKey {
     Single(LargestEventRaw),
     Group(LargestGroupIdRaw),
     All,
@@ -66,10 +67,12 @@ pub type EventWithAuxData<Event> = (Event, Option<Params>);
 pub type EventU32WithAuxData = EventWithAuxData<EventU32>;
 pub type EventU16WithAuxData = EventWithAuxData<EventU16>;
 
+type SenderId = u32;
+
 pub trait SendEventProvider<Provider: GenericEvent, AuxDataProvider = Params> {
     type Error;
 
-    fn id(&self) -> u32;
+    fn id(&self) -> SenderId;
     fn send_no_data(&mut self, event: Provider) -> Result<(), Self::Error> {
         self.send(event, None)
     }
@@ -80,8 +83,8 @@ pub trait SendEventProvider<Provider: GenericEvent, AuxDataProvider = Params> {
     ) -> Result<(), Self::Error>;
 }
 
-struct Listener<E, Event: GenericEvent, AuxDataProvider = Params> {
-    ltype: ListenerType,
+pub struct Listener<E, Event: GenericEvent, AuxDataProvider = Params> {
+    ltype: ListenerKey,
     send_provider: Box<dyn SendEventProvider<Event, AuxDataProvider, Error = E>>,
 }
 
@@ -98,10 +101,19 @@ pub trait EventReceiver<Event: GenericEvent, AuxDataProvider = Params> {
 
 pub trait ListenerTable<SendProviderError, Event: GenericEvent = EventU32, AuxDataProvider = Params>
 {
-    fn get_listeners(
+    fn get_listener_ids(&mut self, key: ListenerKey) -> Option<Iter<SenderId>>;
+    fn add_listener(&mut self, key: ListenerKey, sender_id: SenderId) -> bool;
+
+    fn get_send_event_provider(
         &mut self,
-        key: ListenerType,
-    ) -> &[Listener<SendProviderError, Event, AuxDataProvider>];
+        id: SenderId,
+    ) -> 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.
@@ -114,11 +126,66 @@ pub trait ListenerTable<SendProviderError, Event: GenericEvent = EventU32, AuxDa
 ///     [ParamsHeapless]
 pub struct EventManager<SendProviderError, Event: GenericEvent = EventU32, AuxDataProvider = Params>
 {
-    listeners: HashMap<ListenerType, Vec<Listener<SendProviderError, Event, AuxDataProvider>>>,
+    listeners: HashMap<ListenerKey, Vec<Listener<SendProviderError, Event, AuxDataProvider>>>,
     //listener_table: Box<dyn ListenerTable<SendProviderError, Event, AuxDataProvider>>,
     event_receiver: Box<dyn EventReceiver<Event, AuxDataProvider>>,
 }
 
+#[cfg(feature = "std")]
+#[derive(Default)]
+pub struct DefaultSenderTableProvider<
+    SendProviderError,
+    Event: GenericEvent = EventU32,
+    AuxDataProvider = Params,
+> {
+    listeners: HashMap<ListenerKey, Vec<SenderId>>,
+    senders: HashMap<
+        SenderId,
+        Box<dyn SendEventProvider<Event, AuxDataProvider, Error = SendProviderError>>,
+    >,
+}
+
+#[cfg(feature = "std")]
+impl<SendProviderError, Event: GenericEvent, AuxDataProvider>
+    ListenerTable<SendProviderError, Event, AuxDataProvider>
+    for DefaultSenderTableProvider<SendProviderError, Event, AuxDataProvider>
+{
+    fn get_listener_ids(&mut self, key: ListenerKey) -> Option<Iter<SenderId>> {
+        self.listeners.get(&key).map(|vec| vec.into_iter())
+    }
+
+    fn add_listener(&mut self, key: ListenerKey, sender_id: SenderId) -> 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 get_send_event_provider(
+        &mut self,
+        id: SenderId,
+    ) -> 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()
+    }
+}
+
 /// Safety: It is safe to implement [Send] because all fields in the [EventManager] are [Send]
 /// as well
 #[cfg(feature = "std")]
@@ -144,7 +211,7 @@ impl<E, Event: GenericEvent + Copy> EventManager<E, Event> {
         event: Event,
         dest: impl SendEventProvider<Event, Error = E> + 'static,
     ) {
-        self.update_listeners(ListenerType::Single(event.raw_as_largest_type()), dest);
+        self.update_listeners(ListenerKey::Single(event.raw_as_largest_type()), dest);
     }
 
     pub fn subscribe_group(
@@ -152,7 +219,7 @@ impl<E, Event: GenericEvent + Copy> EventManager<E, Event> {
         group_id: LargestGroupIdRaw,
         dest: impl SendEventProvider<Event, Error = E> + 'static,
     ) {
-        self.update_listeners(ListenerType::Group(group_id), dest);
+        self.update_listeners(ListenerKey::Group(group_id), dest);
     }
 
     /// Subscribe for all events received by the manager.
@@ -163,7 +230,7 @@ impl<E, Event: GenericEvent + Copy> EventManager<E, Event> {
         &mut self,
         send_provider: impl SendEventProvider<Event, Error = E> + 'static,
     ) {
-        self.update_listeners(ListenerType::All, send_provider);
+        self.update_listeners(ListenerKey::All, send_provider);
     }
 
     /// Helper function which removes single subscriptions for which a group subscription already
@@ -173,9 +240,9 @@ impl<E, Event: GenericEvent + Copy> EventManager<E, Event> {
         group_id: LargestGroupIdRaw,
         dest: impl SendEventProvider<Event, Error = E> + 'static,
     ) {
-        if self.listeners.contains_key(&ListenerType::Group(group_id)) {
+        if self.listeners.contains_key(&ListenerKey::Group(group_id)) {
             for (ltype, listeners) in &mut self.listeners {
-                if let ListenerType::Single(_) = ltype {
+                if let ListenerKey::Single(_) = ltype {
                     listeners.retain(|f| f.send_provider.id() != dest.id());
                 }
             }
@@ -188,7 +255,7 @@ impl<E, Event: GenericEvent + Copy, AuxDataProvider: Clone>
 {
     fn update_listeners(
         &mut self,
-        key: ListenerType,
+        key: ListenerKey,
         dest: impl SendEventProvider<Event, AuxDataProvider, Error = E> + 'static,
     ) {
         if !self.listeners.contains_key(&key) {
@@ -230,7 +297,7 @@ impl<E, Event: GenericEvent + Copy, AuxDataProvider: Clone>
                 }
             };
         if let Some((event, aux_data)) = self.event_receiver.receive() {
-            let single_key = ListenerType::Single(event.raw_as_largest_type());
+            let single_key = ListenerKey::Single(event.raw_as_largest_type());
             if self.listeners.contains_key(&single_key) {
                 send_handler(
                     event,
@@ -238,7 +305,7 @@ impl<E, Event: GenericEvent + Copy, AuxDataProvider: Clone>
                     self.listeners.get_mut(&single_key).unwrap(),
                 );
             }
-            let group_key = ListenerType::Group(event.group_id_as_largest_type());
+            let group_key = ListenerKey::Group(event.group_id_as_largest_type());
             if self.listeners.contains_key(&group_key) {
                 send_handler(
                     event,
@@ -246,7 +313,7 @@ impl<E, Event: GenericEvent + Copy, AuxDataProvider: Clone>
                     self.listeners.get_mut(&group_key).unwrap(),
                 );
             }
-            if let Some(all_receivers) = self.listeners.get_mut(&ListenerType::All) {
+            if let Some(all_receivers) = self.listeners.get_mut(&ListenerKey::All) {
                 send_handler(event, aux_data.clone(), all_receivers);
             }
             if let Some(err) = err_status {

From ce8babc8a1a52ab5dbdd7b0a67d79fa457f9a84c Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sat, 19 Nov 2022 02:42:11 +0100
Subject: [PATCH 38/40] allow flexible event manager table backends

---
 Cargo.lock                        |  36 +--
 fsrc-core/src/event_man.rs        | 426 +++++++++++++++++-------------
 fsrc-core/tests/pus_events.rs     |  11 +-
 fsrc-example/src/bin/obsw/main.rs |   8 +-
 spacepackets                      |   2 +-
 5 files changed, 278 insertions(+), 205 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 5cb0795..02c5da2 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -110,9 +110,9 @@ checksum = "14c189c53d098945499cdfa7ecc63567cf3886b3332b312a5b4585d8d3a6a610"
 
 [[package]]
 name = "cc"
-version = "1.0.74"
+version = "1.0.76"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "581f5dba903aac52ea3feb5ec4810848460ee833876f1f9b0fdeab1f19091574"
+checksum = "76a284da2e6fe2092f2353e51713435363112dfd60030e22add80be333fb928f"
 
 [[package]]
 name = "cfg-if"
@@ -122,9 +122,9 @@ 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",
@@ -214,9 +214,9 @@ dependencies = [
 
 [[package]]
 name = "cxx"
-version = "1.0.80"
+version = "1.0.82"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6b7d4e43b25d3c994662706a1d4fcfc32aaa6afd287502c111b237093bb23f3a"
+checksum = "d4a41a86530d0fe7f5d9ea779916b7cadd2d4f9add748b99c2c029cbbdfaf453"
 dependencies = [
  "cc",
  "cxxbridge-flags",
@@ -226,9 +226,9 @@ dependencies = [
 
 [[package]]
 name = "cxx-build"
-version = "1.0.80"
+version = "1.0.82"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "84f8829ddc213e2c1368e51a2564c552b65a8cb6a28f31e576270ac81d5e5827"
+checksum = "06416d667ff3e3ad2df1cd8cd8afae5da26cf9cec4d0825040f88b5ca659a2f0"
 dependencies = [
  "cc",
  "codespan-reporting",
@@ -241,15 +241,15 @@ dependencies = [
 
 [[package]]
 name = "cxxbridge-flags"
-version = "1.0.80"
+version = "1.0.82"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e72537424b474af1460806647c41d4b6d35d09ef7fe031c5c2fa5766047cc56a"
+checksum = "820a9a2af1669deeef27cb271f476ffd196a2c4b6731336011e0ba63e2c7cf71"
 
 [[package]]
 name = "cxxbridge-macro"
-version = "1.0.80"
+version = "1.0.82"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "309e4fb93eed90e1e14bea0da16b209f81813ba9fc7830c20ed151dd7bc0a4d7"
+checksum = "a08a6e2fcc370a089ad3b4aaf54db3b1b4cee38ddabce5896b33eb693275f470"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -504,9 +504,9 @@ dependencies = [
 
 [[package]]
 name = "num_cpus"
-version = "1.13.1"
+version = "1.14.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "19e64526ebdee182341572e50e9ad03965aa510cd94427a4549448f285e957a1"
+checksum = "f6058e64324c71e02bc2b150e4f3bc8286db6c83092132ffa3f6b1eab0f9def5"
 dependencies = [
  "hermit-abi",
  "libc",
@@ -577,9 +577,9 @@ dependencies = [
 
 [[package]]
 name = "regex"
-version = "1.6.0"
+version = "1.7.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4c4eb3267174b8c6c2f654116623910a0fef09c4753f8dd83db29c48a0df988b"
+checksum = "e076559ef8e241f2ae3479e36f97bd5741c0330689e217ad51ce2c76808b868a"
 dependencies = [
  "aho-corasick",
  "memchr",
@@ -588,9 +588,9 @@ dependencies = [
 
 [[package]]
 name = "regex-syntax"
-version = "0.6.27"
+version = "0.6.28"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a3f87b73ce11b1619a3c6332f45341e0047173771e8b8b73f87bfeefb7b56244"
+checksum = "456c603be3e8d448b072f410900c09faf164fbce2d480456f50eea6e25f9c848"
 
 [[package]]
 name = "riscv"
diff --git a/fsrc-core/src/event_man.rs b/fsrc-core/src/event_man.rs
index 3e191eb..e72c0c4 100644
--- a/fsrc-core/src/event_man.rs
+++ b/fsrc-core/src/event_man.rs
@@ -52,7 +52,7 @@ use hashbrown::HashMap;
 #[cfg(feature = "std")]
 pub use stdmod::*;
 
-#[derive(PartialEq, Eq, Hash, Copy, Clone)]
+#[derive(PartialEq, Eq, Hash, Copy, Clone, Debug)]
 pub enum ListenerKey {
     Single(LargestEventRaw),
     Group(LargestGroupIdRaw),
@@ -67,7 +67,7 @@ pub type EventWithAuxData<Event> = (Event, Option<Params>);
 pub type EventU32WithAuxData = EventWithAuxData<EventU32>;
 pub type EventU16WithAuxData = EventWithAuxData<EventU16>;
 
-type SenderId = u32;
+pub type SenderId = u32;
 
 pub trait SendEventProvider<Provider: GenericEvent, AuxDataProvider = Params> {
     type Error;
@@ -83,11 +83,6 @@ pub trait SendEventProvider<Provider: GenericEvent, AuxDataProvider = Params> {
     ) -> Result<(), Self::Error>;
 }
 
-pub struct Listener<E, Event: GenericEvent, AuxDataProvider = Params> {
-    ltype: ListenerKey,
-    send_provider: Box<dyn SendEventProvider<Event, AuxDataProvider, Error = E>>,
-}
-
 /// 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
@@ -99,14 +94,19 @@ pub trait EventReceiver<Event: GenericEvent, AuxDataProvider = Params> {
     fn receive(&mut self) -> Option<(Event, Option<AuxDataProvider>)>;
 }
 
-pub trait ListenerTable<SendProviderError, Event: GenericEvent = EventU32, AuxDataProvider = Params>
-{
-    fn get_listener_ids(&mut self, key: ListenerKey) -> Option<Iter<SenderId>>;
+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<SenderId>>;
     fn add_listener(&mut self, key: ListenerKey, sender_id: SenderId) -> bool;
+    fn remove_duplicates(&mut self, key: &ListenerKey);
+}
 
+pub trait SenderTable<SendProviderError, Event: GenericEvent = EventU32, AuxDataProvider = Params> {
+    fn contains_send_event_provider(&self, id: &SenderId) -> bool;
     fn get_send_event_provider(
         &mut self,
-        id: SenderId,
+        id: &SenderId,
     ) -> Option<&mut Box<dyn SendEventProvider<Event, AuxDataProvider, Error = SendProviderError>>>;
     fn add_send_event_provider(
         &mut self,
@@ -122,36 +122,218 @@ pub trait ListenerTable<SendProviderError, Event: GenericEvent = EventU32, AuxDa
 ///
 ///  * `SendProviderError`: [SendEventProvider] error type
 ///  * `Event`: Concrete event provider, currently either [EventU32] or [EventU16]
-///  * `AuxDataProvider`: Concrete auxiliary data provder, currently either [Params] or
+///  * `AuxDataProvider`: Concrete auxiliary data provider, currently either [Params] or
 ///     [ParamsHeapless]
 pub struct EventManager<SendProviderError, Event: GenericEvent = EventU32, AuxDataProvider = Params>
 {
-    listeners: HashMap<ListenerKey, Vec<Listener<SendProviderError, Event, AuxDataProvider>>>,
-    //listener_table: Box<dyn ListenerTable<SendProviderError, Event, AuxDataProvider>>,
+    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(SenderId),
+}
+
+#[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)
+    }
+
+    pub fn subscribe_single(&mut self, event: &Event, sender_id: SenderId) {
+        self.update_listeners(ListenerKey::Single(event.raw_as_largest_type()), sender_id);
+    }
+
+    pub fn subscribe_group(&mut self, group_id: LargestGroupIdRaw, sender_id: SenderId) {
+        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: SenderId) {
+        self.update_listeners(ListenerKey::All, sender_id);
+    }
+}
+
+impl<E: 'static, Event: GenericEvent + Copy + 'static, AuxDataProvider: Clone + 'static>
+    EventManager<E, Event, AuxDataProvider>
+{
+    pub fn new(event_receiver: Box<dyn EventReceiver<Event, AuxDataProvider>>) -> Self {
+        let listener_table = Box::new(DefaultListenerTableProvider::default());
+        let sender_table =
+            Box::new(DefaultSenderTableProvider::<E, Event, AuxDataProvider>::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: SenderId) {
+        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<SenderId>>,
+}
+
 pub struct DefaultSenderTableProvider<
     SendProviderError,
     Event: GenericEvent = EventU32,
     AuxDataProvider = Params,
 > {
-    listeners: HashMap<ListenerKey, Vec<SenderId>>,
     senders: HashMap<
         SenderId,
         Box<dyn SendEventProvider<Event, AuxDataProvider, Error = SendProviderError>>,
     >,
 }
 
-#[cfg(feature = "std")]
-impl<SendProviderError, Event: GenericEvent, AuxDataProvider>
-    ListenerTable<SendProviderError, Event, AuxDataProvider>
+impl<SendProviderError, Event: GenericEvent, AuxDataProvider> Default
     for DefaultSenderTableProvider<SendProviderError, Event, AuxDataProvider>
 {
-    fn get_listener_ids(&mut self, key: ListenerKey) -> Option<Iter<SenderId>> {
-        self.listeners.get(&key).map(|vec| vec.into_iter())
+    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<SenderId>> {
+        self.listeners.get(key).map(|vec| vec.iter())
     }
 
     fn add_listener(&mut self, key: ListenerKey, sender_id: SenderId) -> bool {
@@ -164,12 +346,30 @@ impl<SendProviderError, Event: GenericEvent, AuxDataProvider>
         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: &SenderId) -> bool {
+        self.senders.contains_key(id)
+    }
+
     fn get_send_event_provider(
         &mut self,
-        id: SenderId,
+        id: &SenderId,
     ) -> Option<&mut Box<dyn SendEventProvider<Event, AuxDataProvider, Error = SendProviderError>>>
     {
-        self.senders.get_mut(&id).filter(|sender| sender.id() == id)
+        self.senders
+            .get_mut(id)
+            .filter(|sender| sender.id() == *id)
     }
 
     fn add_send_event_provider(
@@ -186,145 +386,6 @@ impl<SendProviderError, Event: GenericEvent, 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>
-{
-}
-
-pub enum HandlerResult<Event: GenericEvent, AuxDataProvider> {
-    Empty,
-    Handled(u32, Event, Option<AuxDataProvider>),
-}
-
-impl<E, Event: GenericEvent + Copy> EventManager<E, Event> {
-    pub fn new(event_receiver: Box<dyn EventReceiver<Event>>) -> Self {
-        EventManager {
-            listeners: HashMap::new(),
-            event_receiver,
-        }
-    }
-    pub fn subscribe_single(
-        &mut self,
-        event: Event,
-        dest: impl SendEventProvider<Event, Error = E> + 'static,
-    ) {
-        self.update_listeners(ListenerKey::Single(event.raw_as_largest_type()), dest);
-    }
-
-    pub fn subscribe_group(
-        &mut self,
-        group_id: LargestGroupIdRaw,
-        dest: impl SendEventProvider<Event, Error = E> + 'static,
-    ) {
-        self.update_listeners(ListenerKey::Group(group_id), dest);
-    }
-
-    /// 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,
-        send_provider: impl SendEventProvider<Event, Error = E> + 'static,
-    ) {
-        self.update_listeners(ListenerKey::All, send_provider);
-    }
-
-    /// Helper function which removes single subscriptions for which a group subscription already
-    /// exists.
-    pub fn remove_single_subscriptions_for_group(
-        &mut self,
-        group_id: LargestGroupIdRaw,
-        dest: impl SendEventProvider<Event, Error = E> + 'static,
-    ) {
-        if self.listeners.contains_key(&ListenerKey::Group(group_id)) {
-            for (ltype, listeners) in &mut self.listeners {
-                if let ListenerKey::Single(_) = ltype {
-                    listeners.retain(|f| f.send_provider.id() != dest.id());
-                }
-            }
-        }
-    }
-}
-
-impl<E, Event: GenericEvent + Copy, AuxDataProvider: Clone>
-    EventManager<E, Event, AuxDataProvider>
-{
-    fn update_listeners(
-        &mut self,
-        key: ListenerKey,
-        dest: impl SendEventProvider<Event, AuxDataProvider, Error = E> + 'static,
-    ) {
-        if !self.listeners.contains_key(&key) {
-            self.listeners.insert(
-                key,
-                vec![Listener {
-                    ltype: key,
-                    send_provider: 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.send_provider.id() == dest.id() {
-                    return;
-                }
-            }
-            vec.push(Listener {
-                ltype: key,
-                send_provider: Box::new(dest),
-            });
-        }
-    }
-
-    pub fn try_event_handling(&mut self) -> Result<HandlerResult<Event, AuxDataProvider>, E> {
-        let mut err_status = None;
-        let mut num_recipients = 0;
-        let mut send_handler =
-            |event: Event,
-             aux_data: Option<AuxDataProvider>,
-             llist: &mut Vec<Listener<E, Event, AuxDataProvider>>| {
-                for listener in llist.iter_mut() {
-                    if let Err(e) = listener.send_provider.send(event, aux_data.clone()) {
-                        err_status = Some(Err(e));
-                    } else {
-                        num_recipients += 1;
-                    }
-                }
-            };
-        if let Some((event, aux_data)) = self.event_receiver.receive() {
-            let single_key = ListenerKey::Single(event.raw_as_largest_type());
-            if self.listeners.contains_key(&single_key) {
-                send_handler(
-                    event,
-                    aux_data.clone(),
-                    self.listeners.get_mut(&single_key).unwrap(),
-                );
-            }
-            let group_key = ListenerKey::Group(event.group_id_as_largest_type());
-            if self.listeners.contains_key(&group_key) {
-                send_handler(
-                    event,
-                    aux_data.clone(),
-                    self.listeners.get_mut(&group_key).unwrap(),
-                );
-            }
-            if let Some(all_receivers) = self.listeners.get_mut(&ListenerKey::All) {
-                send_handler(event, aux_data.clone(), all_receivers);
-            }
-            if let Some(err) = err_status {
-                return err;
-            }
-            return Ok(HandlerResult::Handled(num_recipients, event, aux_data));
-        }
-        Ok(HandlerResult::Empty)
-    }
-}
-
 #[cfg(feature = "std")]
 pub mod stdmod {
     use super::*;
@@ -362,9 +423,6 @@ pub mod stdmod {
         sender: Sender<(Event, Option<Params>)>,
     }
 
-    /// Safety: Send is safe to implement because both the ID and the MPSC sender are Send
-    //unsafe impl<Event: GenericEvent> Send for MpscEventSendProvider<Event> {}
-
     impl<Event: GenericEvent + Send> MpscEventSendProvider<Event> {
         pub fn new(id: u32, sender: Sender<(Event, Option<Params>)>) -> Self {
             Self { id, sender }
@@ -431,12 +489,12 @@ mod tests {
     }
 
     fn check_handled_event(
-        res: HandlerResult<EventU32, Params>,
+        res: EventRoutingResult<EventU32, Params>,
         expected: EventU32,
         expected_num_sent: u32,
     ) {
-        assert!(matches!(res, HandlerResult::Handled { .. }));
-        if let HandlerResult::Handled(num_recipients, event, _aux_data) = res {
+        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);
         }
@@ -461,13 +519,15 @@ mod tests {
         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);
+        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);
+        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
@@ -494,7 +554,8 @@ mod tests {
         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);
+        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");
@@ -519,7 +580,7 @@ mod tests {
         let res = event_man.try_event_handling();
         assert!(res.is_ok());
         let hres = res.unwrap();
-        assert!(matches!(hres, HandlerResult::Empty));
+        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();
@@ -528,8 +589,9 @@ mod tests {
             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_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))
@@ -565,8 +627,12 @@ mod tests {
             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);
+        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");
@@ -575,7 +641,7 @@ mod tests {
         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_man.subscribe_group(event_1.group_id(), event_listener_0_sender_id);
         event_sender
             .send((event_0, None))
             .expect("Triggering Event 0 failed");
@@ -594,8 +660,9 @@ mod tests {
         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);
+        // 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");
@@ -617,7 +684,8 @@ mod tests {
             id: 0,
             mpsc_sender: event_0_tx_0,
         };
-        event_man.subscribe_all(all_events_listener);
+        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");
diff --git a/fsrc-core/tests/pus_events.rs b/fsrc-core/tests/pus_events.rs
index d51a5f1..37b4fa3 100644
--- a/fsrc-core/tests/pus_events.rs
+++ b/fsrc-core/tests/pus_events.rs
@@ -1,4 +1,6 @@
-use fsrc_core::event_man::{EventManager, MpscEventReceiver, MpscEventU32SendProvider};
+use fsrc_core::event_man::{
+    EventManagerWithMpscQueue, MpscEventU32Receiver, MpscEventU32SendProvider, SendEventProvider,
+};
 use fsrc_core::events::{EventU32, EventU32TypedSev, Severity, SeverityInfo};
 use fsrc_core::params::U32Pair;
 use fsrc_core::params::{Params, ParamsHeapless, WritableToBeBytes};
@@ -31,12 +33,13 @@ impl EcssTmSender for EventTmSender {
 #[test]
 fn test_threaded_usage() {
     let (event_sender, event_man_receiver) = channel();
-    let event_receiver = MpscEventReceiver::new(event_man_receiver);
-    let mut event_man = EventManager::new(Box::new(event_receiver));
+    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);
+    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();
diff --git a/fsrc-example/src/bin/obsw/main.rs b/fsrc-example/src/bin/obsw/main.rs
index 638f3f9..3794d86 100644
--- a/fsrc-example/src/bin/obsw/main.rs
+++ b/fsrc-example/src/bin/obsw/main.rs
@@ -3,7 +3,9 @@ mod pus;
 mod tmtc;
 
 use crate::tmtc::{core_tmtc_task, CoreTmtcArgs, TmStore, PUS_APID};
-use fsrc_core::event_man::{EventManager, MpscEventReceiver, MpscEventU32SendProvider};
+use fsrc_core::event_man::{
+    EventManagerWithMpscQueue, MpscEventReceiver, MpscEventU32SendProvider, SendEventProvider,
+};
 use fsrc_core::events::EventU32;
 use fsrc_core::hal::host::udp_server::UdpTcServer;
 use fsrc_core::pool::{LocalPool, PoolCfg, SharedPool, StoreAddr};
@@ -81,7 +83,7 @@ fn main() {
     let (event_request_tx, event_request_rx) = channel::<EventRequestWithToken>();
     let (event_sender, event_man_rx) = channel();
     let event_recv = MpscEventReceiver::<EventU32>::new(event_man_rx);
-    let mut event_man = EventManager::new(Box::new(event_recv));
+    let mut event_man = EventManagerWithMpscQueue::new(Box::new(event_recv));
     let event_reporter = EventReporter::new(PUS_APID, 128).unwrap();
     let pus_tm_backend = DefaultPusMgmtBackendProvider::<EventU32>::default();
     let mut pus_event_dispatcher =
@@ -89,7 +91,7 @@ fn main() {
     let (pus_event_man_tx, pus_event_man_rx) = channel();
     let pus_event_man_send_provider = MpscEventU32SendProvider::new(1, pus_event_man_tx);
     let reporter1 = reporter_with_sender_0.clone();
-    event_man.subscribe_all(pus_event_man_send_provider);
+    event_man.subscribe_all(pus_event_man_send_provider.id());
 
     // Create clones here to allow move for thread 0
     let core_args = CoreTmtcArgs {
diff --git a/spacepackets b/spacepackets
index 1d6cf3a..c750f94 160000
--- a/spacepackets
+++ b/spacepackets
@@ -1 +1 @@
-Subproject commit 1d6cf3a75d4082b3d962700038c21dc7dacb156f
+Subproject commit c750f94fba31114c5ade530ea6235acb6bb8835a

From a2c1476a56c8778417feef69c78587662f2f435e Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sat, 19 Nov 2022 03:07:10 +0100
Subject: [PATCH 39/40] more and better docs

---
 fsrc-core/src/event_man.rs | 42 +++++++++++++++++++++++++-------------
 1 file changed, 28 insertions(+), 14 deletions(-)

diff --git a/fsrc-core/src/event_man.rs b/fsrc-core/src/event_man.rs
index e72c0c4..c54cc2a 100644
--- a/fsrc-core/src/event_man.rs
+++ b/fsrc-core/src/event_man.rs
@@ -20,27 +20,41 @@ doc = ::embed_doc_image::embed_image!("event_man_arch", "images/event_man_arch.p
 //!
 //! ![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][SenderId].
+//! It also contains a sender table abstracted by the [SenderTable] which maps these sender IDs
+//! to a concrete [SendEventProvider]. 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 [SendEventProvider] implementation and a concrete [EventReceiver]
-//!     implementation. These 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. It is recommended that these implementations
-//!     derive [Clone].
-//!  2. Each event creator gets a (cloned) sender component which allows it to send events to the
+//!  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 [MpscEventSendProvider].
+//!  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 so all events are routed to the
 //!     manager.
-//!  4. Additional channels are created for each event receiver and/or subscriber.
-//!     The sender component is used with the [SendEventProvider] trait and the subscription API
-//!     provided by the [EventManager] to subscribe for individual events, whole group of events or
-//!     all events. The receiver/subscribers can then receive all subscribed events via the receiver
-//!     end.
+//!  4. Create the [send event providers][SendEventProvider]s which allow routing events to
+//!     subscribers.
+//!     Use 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/fsrc-launchpad/src/branch/event_man_table_impl/fsrc-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};
 use alloc::boxed::Box;
@@ -173,10 +187,12 @@ impl<E, Event: GenericEvent + Copy> EventManager<E, Event> {
         self.listener_table.remove_duplicates(key)
     }
 
+    /// Subscribe for a unique event.
     pub fn subscribe_single(&mut self, event: &Event, sender_id: SenderId) {
         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: SenderId) {
         self.update_listeners(ListenerKey::Group(group_id), sender_id);
     }
@@ -367,9 +383,7 @@ impl<SendProviderError, Event: GenericEvent, AuxDataProvider>
         id: &SenderId,
     ) -> Option<&mut Box<dyn SendEventProvider<Event, AuxDataProvider, Error = SendProviderError>>>
     {
-        self.senders
-            .get_mut(id)
-            .filter(|sender| sender.id() == *id)
+        self.senders.get_mut(id).filter(|sender| sender.id() == *id)
     }
 
     fn add_send_event_provider(

From 46b38aa2f336c8ab994bee8a016a93870b562dc4 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sat, 19 Nov 2022 12:16:51 +0100
Subject: [PATCH 40/40] added more event support

---
 fsrc-core/src/pus/event.rs        | 31 ++++++++++
 fsrc-example/src/bin/obsw/pus.rs  | 99 ++++++++++++++++++++++++++++++-
 fsrc-example/src/bin/obsw/tmtc.rs |  1 +
 3 files changed, 128 insertions(+), 3 deletions(-)

diff --git a/fsrc-core/src/pus/event.rs b/fsrc-core/src/pus/event.rs
index a4867e6..10e0618 100644
--- a/fsrc-core/src/pus/event.rs
+++ b/fsrc-core/src/pus/event.rs
@@ -25,6 +25,37 @@ impl From<Subservices> for u8 {
     }
 }
 
+impl TryFrom<u8> for Subservices {
+    type Error = ();
+
+    fn try_from(value: u8) -> Result<Self, Self::Error> {
+        match value {
+            x if x == Subservices::TmInfoReport as u8 => Ok(Subservices::TmInfoReport),
+            x if x == Subservices::TmLowSeverityReport as u8 => {
+                Ok(Subservices::TmLowSeverityReport)
+            }
+            x if x == Subservices::TmMediumSeverityReport as u8 => {
+                Ok(Subservices::TmMediumSeverityReport)
+            }
+            x if x == Subservices::TmHighSeverityReport as u8 => {
+                Ok(Subservices::TmHighSeverityReport)
+            }
+            x if x == Subservices::TcEnableEventGeneration as u8 => {
+                Ok(Subservices::TcEnableEventGeneration)
+            }
+            x if x == Subservices::TcDisableEventGeneration as u8 => {
+                Ok(Subservices::TcDisableEventGeneration)
+            }
+            x if x == Subservices::TcReportDisabledList as u8 => {
+                Ok(Subservices::TcReportDisabledList)
+            }
+            x if x == Subservices::TmDisabledEventsReport as u8 => {
+                Ok(Subservices::TmDisabledEventsReport)
+            }
+            _ => Err(()),
+        }
+    }
+}
 pub struct EventReporterBase {
     msg_count: u16,
     apid: u16,
diff --git a/fsrc-example/src/bin/obsw/pus.rs b/fsrc-example/src/bin/obsw/pus.rs
index c0a0c68..5caaf17 100644
--- a/fsrc-example/src/bin/obsw/pus.rs
+++ b/fsrc-example/src/bin/obsw/pus.rs
@@ -1,11 +1,15 @@
 use crate::tmtc::TmStore;
+use fsrc_core::events::EventU32;
 use fsrc_core::pool::StoreAddr;
+use fsrc_core::pus::event::Subservices;
+use fsrc_core::pus::event_man::{EventRequest, EventRequestWithToken};
 use fsrc_core::pus::verification::{
-    SharedStdVerifReporterWithSender, TcStateAccepted, VerificationToken,
+    FailParams, SharedStdVerifReporterWithSender, TcStateAccepted, VerificationToken,
 };
 use fsrc_core::tmtc::tm_helper::PusTmWithCdsShortHelper;
 use fsrc_core::tmtc::PusServiceProvider;
-use spacepackets::tc::{PusTc, PusTcSecondaryHeaderT};
+use spacepackets::ecss::{EcssEnumU16, PusPacket};
+use spacepackets::tc::PusTc;
 use spacepackets::time::{CdsShortTimeProvider, TimeWriter};
 use spacepackets::SpHeader;
 use std::sync::mpsc;
@@ -15,6 +19,7 @@ pub struct PusReceiver {
     pub tm_tx: mpsc::Sender<StoreAddr>,
     pub tm_store: TmStore,
     pub verif_reporter: SharedStdVerifReporterWithSender,
+    event_request_tx: mpsc::Sender<EventRequestWithToken>,
     stamper: CdsShortTimeProvider,
     time_stamp: [u8; 7],
 }
@@ -25,12 +30,14 @@ impl PusReceiver {
         tm_tx: mpsc::Sender<StoreAddr>,
         tm_store: TmStore,
         verif_reporter: SharedStdVerifReporterWithSender,
+        event_request_tx: mpsc::Sender<EventRequestWithToken>,
     ) -> Self {
         Self {
             tm_helper: PusTmWithCdsShortHelper::new(apid),
             tm_tx,
             tm_store,
             verif_reporter,
+            event_request_tx,
             stamper: CdsShortTimeProvider::default(),
             time_stamp: [0; 7],
         }
@@ -64,7 +71,7 @@ impl PusServiceProvider for PusReceiver {
         if service == 17 {
             self.handle_test_service(pus_tc, accepted_token);
         } else if service == 5 {
-            // TODO: Send message to event manager here
+            self.handle_event_service(pus_tc, accepted_token);
         }
         Ok(())
     }
@@ -92,4 +99,90 @@ impl PusReceiver {
                 .expect("Error sending completion success");
         }
     }
+
+    fn update_time_stamp(&mut self) {
+        self.stamper
+            .update_from_now()
+            .expect("Updating timestamp failed");
+        self.stamper
+            .write_to_bytes(&mut self.time_stamp)
+            .expect("Writing timestamp failed");
+    }
+
+    fn handle_event_service(&mut self, pus_tc: &PusTc, token: VerificationToken<TcStateAccepted>) {
+        let send_start_failure = |verif_reporter: &mut SharedStdVerifReporterWithSender,
+                                  timestamp: &[u8; 7],
+                                  failure_code: EcssEnumU16,
+                                  failure_data: Option<&[u8]>| {
+            verif_reporter
+                .lock()
+                .expect("Locking verification reporter failed")
+                .start_failure(
+                    token,
+                    FailParams::new(timestamp, &failure_code, failure_data),
+                )
+                .expect("Sending start failure TM failed");
+        };
+        let send_start_acceptance = |verif_reporter: &mut SharedStdVerifReporterWithSender,
+                                     timestamp: &[u8; 7]| {
+            verif_reporter
+                .lock()
+                .expect("Locking verification reporter failed")
+                .start_success(token, timestamp)
+                .expect("Sending start success TM failed")
+        };
+        if pus_tc.user_data().is_none() {
+            self.update_time_stamp();
+            send_start_failure(
+                &mut self.verif_reporter,
+                &self.time_stamp,
+                EcssEnumU16::new(1),
+                None,
+            );
+            return;
+        }
+        let app_data = pus_tc.user_data().unwrap();
+        if app_data.len() < 4 {
+            self.update_time_stamp();
+            send_start_failure(
+                &mut self.verif_reporter,
+                &self.time_stamp,
+                EcssEnumU16::new(1),
+                None,
+            );
+            return;
+        }
+        let event_id = EventU32::from(u32::from_be_bytes(app_data.try_into().unwrap()));
+        match PusPacket::subservice(pus_tc).try_into() {
+            Ok(Subservices::TcEnableEventGeneration) => {
+                self.update_time_stamp();
+                let start_token = send_start_acceptance(&mut self.verif_reporter, &self.time_stamp);
+                self.event_request_tx
+                    .send(EventRequestWithToken {
+                        request: EventRequest::Enable(event_id),
+                        token: start_token,
+                    })
+                    .expect("Sending event request failed");
+            }
+            Ok(Subservices::TcDisableEventGeneration) => {
+                self.update_time_stamp();
+                let start_token = send_start_acceptance(&mut self.verif_reporter, &self.time_stamp);
+                self.event_request_tx
+                    .send(EventRequestWithToken {
+                        request: EventRequest::Disable(event_id),
+                        token: start_token,
+                    })
+                    .expect("Sending event request failed");
+            }
+            _ => {
+                self.update_time_stamp();
+                send_start_failure(
+                    &mut self.verif_reporter,
+                    &self.time_stamp,
+                    EcssEnumU16::new(2),
+                    None,
+                );
+            }
+        }
+    }
 }
diff --git a/fsrc-example/src/bin/obsw/tmtc.rs b/fsrc-example/src/bin/obsw/tmtc.rs
index 3ff05f4..7806347 100644
--- a/fsrc-example/src/bin/obsw/tmtc.rs
+++ b/fsrc-example/src/bin/obsw/tmtc.rs
@@ -52,6 +52,7 @@ pub fn core_tmtc_task(
         args.tm_sender,
         args.tm_store.clone(),
         verif_reporter,
+        args.event_request_tx,
     );
     let pus_distributor = PusDistributor::new(Box::new(pus_receiver));
     let ccsds_receiver = CcsdsReceiver {