now only tests are missing

satrs-example/src/events.rs

@@ -2,7 +2,6 @@ use std::sync::mpsc::{self};
 
 use crate::pus::create_verification_reporter;
 use satrs::event_man::{EventMessageU32, EventRoutingError};
-use satrs::params::WritableToBeBytes;
 use satrs::pus::event::EventTmHookProvider;
 use satrs::pus::verification::VerificationReporter;
 use satrs::pus::EcssTmSender;
@@ -42,6 +41,7 @@ pub struct PusEventHandler<TmSender: EcssTmSender> {
     tm_sender: TmSender,
     time_provider: CdsTime,
     timestamp: [u8; 7],
+    small_data_buf: [u8; 64],
     verif_handler: VerificationReporter,
 }
 
@@ -82,6 +82,7 @@ impl<TmSender: EcssTmSender> PusEventHandler<TmSender> {
             pus_event_man_rx,
             time_provider: CdsTime::new_with_u16_days(0, 0),
             timestamp: [0; 7],
+            small_data_buf: [0; 64],
             verif_handler,
             tm_sender,
         }
@@ -132,19 +133,17 @@ impl<TmSender: EcssTmSender> PusEventHandler<TmSender> {
             // Perform the generation of PUS event packets
             match self.pus_event_man_rx.try_recv() {
                 Ok(event_msg) => {
-                    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")
-                    });
                     // We use the TM modification hook to set the sender APID for each event.
                     self.pus_event_tm_creator.reporter.tm_hook.next_apid =
                         UniqueApidTargetId::from(event_msg.sender_id()).apid;
+                    update_time(&mut self.time_provider, &mut self.timestamp);
                     self.pus_event_tm_creator
-                        .generate_pus_event_tm_generic(
+                        .generate_pus_event_tm_generic_with_generic_params(
                             &self.tm_sender,
                             &self.timestamp,
                             event_msg.event(),
-                            Some(&param_vec),
+                            &mut self.small_data_buf,
+                            event_msg.params(),
                         )
                         .expect("Sending TM as event failed");
                 }

satrs-example/src/pus/action.rs

@@ -1,12 +1,12 @@
 use log::{error, warn};
 use satrs::action::{ActionRequest, ActionRequestVariant};
-use satrs::params::WritableToBeBytes;
 use satrs::pool::SharedStaticMemoryPool;
 use satrs::pus::action::{
     ActionReplyPus, ActionReplyVariant, ActivePusActionRequestStd, DefaultActiveActionRequestMap,
 };
 use satrs::pus::verification::{
-    FailParams, FailParamsWithStep, TcStateAccepted, TcStateStarted, VerificationReporter,
+    handle_completion_failure_with_error_as_params, handle_step_failure_with_error_as_params,
+    FailParams, TcStateAccepted, TcStateStarted, VerificationReporter,
     VerificationReportingProvider, VerificationToken,
 };
 use satrs::pus::{
@@ -61,7 +61,7 @@ impl PusReplyHandler<ActivePusActionRequestStd, ActionReplyPus> for ActionReplyH
         active_request: &ActivePusActionRequestStd,
         tm_sender: &(impl EcssTmSender + ?Sized),
         verification_handler: &impl VerificationReportingProvider,
-        time_stamp: &[u8],
+        timestamp: &[u8],
     ) -> Result<bool, Self::Error> {
         let verif_token: VerificationToken<TcStateStarted> = active_request
             .token()
@@ -69,15 +69,21 @@ impl PusReplyHandler<ActivePusActionRequestStd, ActionReplyPus> for ActionReplyH
             .expect("invalid token state");
         let remove_entry = match &reply.message.variant {
             ActionReplyVariant::CompletionFailed { error_code, params } => {
-                let mut fail_data_len = 0;
-                if let Some(params) = params {
-                    fail_data_len = params.write_to_be_bytes(&mut self.fail_data_buf)?;
-                }
-                verification_handler.completion_failure(
+                let error_propagated = handle_completion_failure_with_error_as_params(
                     tm_sender,
                     verif_token,
-                    FailParams::new(time_stamp, error_code, &self.fail_data_buf[..fail_data_len]),
+                    verification_handler,
+                    timestamp,
+                    error_code,
+                    &mut self.fail_data_buf,
+                    params.as_ref(),
                 )?;
+                if !error_propagated {
+                    log::warn!(
+                        "error params for completion failure were not propated: {:?}",
+                        params.as_ref()
+                    );
+                }
                 true
             }
             ActionReplyVariant::StepFailed {
@@ -85,31 +91,33 @@ impl PusReplyHandler<ActivePusActionRequestStd, ActionReplyPus> for ActionReplyH
                 step,
                 params,
             } => {
-                let mut fail_data_len = 0;
-                if let Some(params) = params {
-                    fail_data_len = params.write_to_be_bytes(&mut self.fail_data_buf)?;
-                }
-                verification_handler.step_failure(
+                let error_propagated = handle_step_failure_with_error_as_params(
                     tm_sender,
                     verif_token,
-                    FailParamsWithStep::new(
-                        time_stamp,
-                        &EcssEnumU16::new(*step),
-                        error_code,
-                        &self.fail_data_buf[..fail_data_len],
-                    ),
+                    verification_handler,
+                    timestamp,
+                    &EcssEnumU16::new(*step),
+                    error_code,
+                    &mut self.fail_data_buf,
+                    params.as_ref(),
                 )?;
+                if !error_propagated {
+                    log::warn!(
+                        "error params for completion failure were not propated: {:?}",
+                        params.as_ref()
+                    );
+                }
                 true
             }
             ActionReplyVariant::Completed => {
-                verification_handler.completion_success(tm_sender, verif_token, time_stamp)?;
+                verification_handler.completion_success(tm_sender, verif_token, timestamp)?;
                 true
             }
             ActionReplyVariant::StepSuccess { step } => {
                 verification_handler.step_success(
                     tm_sender,
                     &verif_token,
-                    time_stamp,
+                    timestamp,
                     EcssEnumU16::new(*step),
                 )?;
                 false