improve event handling module

satrs-example/src/events.rs

@@ -1,6 +1,8 @@
 use std::sync::mpsc::{self};
 
 use crate::pus::create_verification_reporter;
+use satrs::event_man::{EventMessageU32, EventRoutingError};
+use satrs::params::WritableToBeBytes;
 use satrs::pus::verification::VerificationReporter;
 use satrs::pus::EcssTmSenderCore;
 use satrs::{
@@ -8,8 +10,6 @@ use satrs::{
         EventManagerWithBoundedMpsc, EventSendProvider, EventU32SenderMpscBounded,
         MpscEventReceiver,
     },
-    events::EventU32,
-    params::Params,
     pus::{
         event_man::{
             DefaultPusEventU32Dispatcher, EventReporter, EventRequest, EventRequestWithToken,
@@ -28,7 +28,7 @@ use crate::update_time;
 pub struct PusEventHandler<TmSender: EcssTmSenderCore> {
     event_request_rx: mpsc::Receiver<EventRequestWithToken>,
     pus_event_dispatcher: DefaultPusEventU32Dispatcher<()>,
-    pus_event_man_rx: mpsc::Receiver<(EventU32, Option<Params>)>,
+    pus_event_man_rx: mpsc::Receiver<EventMessageU32>,
     tm_sender: TmSender,
     time_provider: CdsTime,
     timestamp: [u8; 7],
@@ -108,10 +108,18 @@ impl<TmSender: EcssTmSenderCore> PusEventHandler<TmSender> {
 
     pub fn generate_pus_event_tm(&mut self) {
         // Perform the generation of PUS event packets
-        if let Ok((event, _param)) = self.pus_event_man_rx.try_recv() {
+        if let Ok(event_msg) = self.pus_event_man_rx.try_recv() {
             update_time(&mut self.time_provider, &mut self.timestamp);
+            let param_vec = event_msg.params().map_or(Vec::new(), |param| {
+                param.to_vec().expect("failed to convert params to vec")
+            });
             self.pus_event_dispatcher
-                .generate_pus_event_tm_generic(&self.tm_sender, &self.timestamp, event, None)
+                .generate_pus_event_tm_generic(
+                    &self.tm_sender,
+                    &self.timestamp,
+                    event_msg.event(),
+                    Some(&param_vec),
+                )
                 .expect("Sending TM as event failed");
         }
     }
@@ -121,7 +129,7 @@ impl<TmSender: EcssTmSenderCore> PusEventHandler<TmSender> {
 /// used to send events to the event manager.
 pub struct EventManagerWrapper {
     event_manager: EventManagerWithBoundedMpsc,
-    event_sender: mpsc::Sender<(EventU32, Option<Params>)>,
+    event_sender: mpsc::Sender<EventMessageU32>,
 }
 
 impl EventManagerWrapper {
@@ -129,7 +137,7 @@ impl EventManagerWrapper {
         // The sender handle is the primary sender handle for all components which want to create events.
         // The event manager will receive the RX handle to receive all the events.
         let (event_sender, event_man_rx) = mpsc::channel();
-        let event_recv = MpscEventReceiver::<EventU32>::new(event_man_rx);
+        let event_recv = MpscEventReceiver::new(event_man_rx);
         Self {
             event_manager: EventManagerWithBoundedMpsc::new(event_recv),
             event_sender,
@@ -137,7 +145,7 @@ impl EventManagerWrapper {
     }
 
     // Returns a cached event sender to send events to the event manager for routing.
-    pub fn clone_event_sender(&self) -> mpsc::Sender<(EventU32, Option<Params>)> {
+    pub fn clone_event_sender(&self) -> mpsc::Sender<EventMessageU32> {
         self.event_sender.clone()
     }
 
@@ -146,10 +154,13 @@ impl EventManagerWrapper {
     }
 
     pub fn try_event_routing(&mut self) {
+        let error_handler = |error| self.routing_error_handler(error);
         // Perform the event routing.
-        self.event_manager
-            .try_event_handling()
-            .expect("event handling failed");
+        self.event_manager.try_event_handling(error_handler);
+    }
+
+    pub fn routing_error_handler(&self, error: EventRoutingError) {
+        log::warn!("event routing error: {error:?}");
     }
 }
 
@@ -176,7 +187,7 @@ impl<TmSender: EcssTmSenderCore> EventHandler<TmSender> {
         }
     }
 
-    pub fn clone_event_sender(&self) -> mpsc::Sender<(EventU32, Option<Params>)> {
+    pub fn clone_event_sender(&self) -> mpsc::Sender<EventMessageU32> {
         self.event_man_wrapper.clone_event_sender()
     }
 

satrs-example/src/pus/test.rs

@@ -1,9 +1,10 @@
 use crate::pus::create_verification_reporter;
 use log::{info, warn};
-use satrs::params::Params;
+use satrs::event_man::{EventMessage, EventMessageU32};
 use satrs::pool::SharedStaticMemoryPool;
 use satrs::pus::test::PusService17TestHandler;
 use satrs::pus::verification::{FailParams, VerificationReporter, VerificationReportingProvider};
+use satrs::pus::EcssTcInSharedStoreConverter;
 use satrs::pus::{
     EcssTcAndToken, EcssTcInMemConverter, EcssTcInVecConverter, EcssTmSenderCore, MpscTcReceiver,
     MpscTmAsVecSender, MpscTmInSharedPoolSenderBounded, PusPacketHandlerResult, PusServiceHelper,
@@ -13,7 +14,6 @@ use satrs::spacepackets::ecss::tc::PusTcReader;
 use satrs::spacepackets::ecss::PusPacket;
 use satrs::spacepackets::time::cds::CdsTime;
 use satrs::spacepackets::time::TimeWriter;
-use satrs::{events::EventU32, pus::EcssTcInSharedStoreConverter};
 use satrs_example::config::components::PUS_TEST_SERVICE;
 use satrs_example::config::{tmtc_err, TEST_EVENT};
 use std::sync::mpsc;
@@ -21,7 +21,7 @@ use std::sync::mpsc;
 pub fn create_test_service_static(
     tm_sender: TmInSharedPoolSender<mpsc::SyncSender<PusTmInPool>>,
     tc_pool: SharedStaticMemoryPool,
-    event_sender: mpsc::Sender<(EventU32, Option<Params>)>,
+    event_sender: mpsc::Sender<EventMessageU32>,
     pus_test_rx: mpsc::Receiver<EcssTcAndToken>,
 ) -> TestCustomServiceWrapper<MpscTmInSharedPoolSenderBounded, EcssTcInSharedStoreConverter> {
     let pus17_handler = PusService17TestHandler::new(PusServiceHelper::new(
@@ -39,7 +39,7 @@ pub fn create_test_service_static(
 
 pub fn create_test_service_dynamic(
     tm_funnel_tx: mpsc::Sender<PusTmAsVec>,
-    event_sender: mpsc::Sender<(EventU32, Option<Params>)>,
+    event_sender: mpsc::Sender<EventMessageU32>,
     pus_test_rx: mpsc::Receiver<EcssTcAndToken>,
 ) -> TestCustomServiceWrapper<MpscTmAsVecSender, EcssTcInVecConverter> {
     let pus17_handler = PusService17TestHandler::new(PusServiceHelper::new(
@@ -61,7 +61,7 @@ pub struct TestCustomServiceWrapper<
 > {
     pub handler:
         PusService17TestHandler<MpscTcReceiver, TmSender, TcInMemConverter, VerificationReporter>,
-    pub test_srv_event_sender: mpsc::Sender<(EventU32, Option<Params>)>,
+    pub test_srv_event_sender: mpsc::Sender<EventMessageU32>,
 }
 
 impl<TmSender: EcssTmSenderCore, TcInMemConverter: EcssTcInMemConverter>
@@ -101,7 +101,7 @@ impl<TmSender: EcssTmSenderCore, TcInMemConverter: EcssTcInMemConverter>
                 if subservice == 128 {
                     info!("Generating test event");
                     self.test_srv_event_sender
-                        .send((TEST_EVENT.into(), None))
+                        .send(EventMessage::new(PUS_TEST_SERVICE.id(), TEST_EVENT.into()))
                         .expect("Sending test event failed");
                     let start_token = self
                         .handler