rust/sat-rs
rust/sat-rs
5
1
Fork 0
Code Issues 9 Pull Requests Projects Releases 22 Wiki Activity

split up error type to avoid unecessary generics

Browse Source
This commit is contained in:
Robin Müller 2023-01-03 20:44:28 +01:00
parent 4effc5bbb3
commit 9b4ada9bcb
No known key found for this signature in database
GPG Key ID: 71B58F8A3CDFA9AC
6 changed files with 137 additions and 98 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

31
satrs-core/src/pus/event.rs
View File

@ -1,4 +1,4 @@
use crate::pus::{source_buffer_large_enough, EcssTmError}; use crate::pus::{source_buffer_large_enough, EcssTmError, EcssTmErrorWithSend};
use spacepackets::ecss::EcssEnumeration; use spacepackets::ecss::EcssEnumeration;
use spacepackets::tm::PusTm; use spacepackets::tm::PusTm;
use spacepackets::tm::PusTmSecondaryHeader; use spacepackets::tm::PusTmSecondaryHeader;
@ -82,7 +82,7 @@ impl EventReporterBase {
time_stamp: &[u8], time_stamp: &[u8],
event_id: impl EcssEnumeration, event_id: impl EcssEnumeration,
aux_data: Option<&[u8]>, aux_data: Option<&[u8]>,
) -> Result<(), EcssTmError<E>> { ) -> Result<(), EcssTmErrorWithSend<E>> {
self.generate_and_send_generic_tm( self.generate_and_send_generic_tm(
buf, buf,
Subservices::TmInfoReport, Subservices::TmInfoReport,
@ -100,7 +100,7 @@ impl EventReporterBase {
time_stamp: &[u8], time_stamp: &[u8],
event_id: impl EcssEnumeration, event_id: impl EcssEnumeration,
aux_data: Option<&[u8]>, aux_data: Option<&[u8]>,
) -> Result<(), EcssTmError<E>> { ) -> Result<(), EcssTmErrorWithSend<E>> {
self.generate_and_send_generic_tm( self.generate_and_send_generic_tm(
buf, buf,
Subservices::TmLowSeverityReport, Subservices::TmLowSeverityReport,
@ -118,7 +118,7 @@ impl EventReporterBase {
time_stamp: &[u8], time_stamp: &[u8],
event_id: impl EcssEnumeration, event_id: impl EcssEnumeration,
aux_data: Option<&[u8]>, aux_data: Option<&[u8]>,
) -> Result<(), EcssTmError<E>> { ) -> Result<(), EcssTmErrorWithSend<E>> {
self.generate_and_send_generic_tm( self.generate_and_send_generic_tm(
buf, buf,
Subservices::TmMediumSeverityReport, Subservices::TmMediumSeverityReport,
@ -136,7 +136,7 @@ impl EventReporterBase {
time_stamp: &[u8], time_stamp: &[u8],
event_id: impl EcssEnumeration, event_id: impl EcssEnumeration,
aux_data: Option<&[u8]>, aux_data: Option<&[u8]>,
) -> Result<(), EcssTmError<E>> { ) -> Result<(), EcssTmErrorWithSend<E>> {
self.generate_and_send_generic_tm( self.generate_and_send_generic_tm(
buf, buf,
Subservices::TmHighSeverityReport, Subservices::TmHighSeverityReport,
@ -155,21 +155,21 @@ impl EventReporterBase {
time_stamp: &[u8], time_stamp: &[u8],
event_id: impl EcssEnumeration, event_id: impl EcssEnumeration,
aux_data: Option<&[u8]>, aux_data: Option<&[u8]>,
) -> Result<(), EcssTmError<E>> { ) -> Result<(), EcssTmErrorWithSend<E>> {
let tm = self.generate_generic_event_tm(buf, subservice, time_stamp, event_id, aux_data)?; let tm = self.generate_generic_event_tm(buf, subservice, time_stamp, event_id, aux_data)?;
sender.send_tm(tm)?; sender.send_tm(tm)?;
self.msg_count += 1; self.msg_count += 1;
Ok(()) Ok(())
} }
fn generate_generic_event_tm<'a, E>( fn generate_generic_event_tm<'a>(
&'a self, &'a self,
buf: &'a mut [u8], buf: &'a mut [u8],
subservice: Subservices, subservice: Subservices,
time_stamp: &'a [u8], time_stamp: &'a [u8],
event_id: impl EcssEnumeration, event_id: impl EcssEnumeration,
aux_data: Option<&[u8]>, aux_data: Option<&[u8]>,
) -> Result<PusTm, EcssTmError<E>> { ) -> Result<PusTm, EcssTmError> {
let mut src_data_len = event_id.byte_width(); let mut src_data_len = event_id.byte_width();
if let Some(aux_data) = aux_data { if let Some(aux_data) = aux_data {
src_data_len += aux_data.len(); src_data_len += aux_data.len();
@ -224,7 +224,7 @@ mod allocvec {
time_stamp: &[u8], time_stamp: &[u8],
event_id: impl EcssEnumeration, event_id: impl EcssEnumeration,
aux_data: Option<&[u8]>, aux_data: Option<&[u8]>,
) -> Result<(), EcssTmError<E>> { ) -> Result<(), EcssTmErrorWithSend<E>> {
self.reporter.event_info( self.reporter.event_info(
self.source_data_buf.as_mut_slice(), self.source_data_buf.as_mut_slice(),
sender, sender,
@ -240,7 +240,7 @@ mod allocvec {
time_stamp: &[u8], time_stamp: &[u8],
event_id: impl EcssEnumeration, event_id: impl EcssEnumeration,
aux_data: Option<&[u8]>, aux_data: Option<&[u8]>,
) -> Result<(), EcssTmError<E>> { ) -> Result<(), EcssTmErrorWithSend<E>> {
self.reporter.event_low_severity( self.reporter.event_low_severity(
self.source_data_buf.as_mut_slice(), self.source_data_buf.as_mut_slice(),
sender, sender,
@ -256,7 +256,7 @@ mod allocvec {
time_stamp: &[u8], time_stamp: &[u8],
event_id: impl EcssEnumeration, event_id: impl EcssEnumeration,
aux_data: Option<&[u8]>, aux_data: Option<&[u8]>,
) -> Result<(), EcssTmError<E>> { ) -> Result<(), EcssTmErrorWithSend<E>> {
self.reporter.event_medium_severity( self.reporter.event_medium_severity(
self.source_data_buf.as_mut_slice(), self.source_data_buf.as_mut_slice(),
sender, sender,
@ -272,7 +272,7 @@ mod allocvec {
time_stamp: &[u8], time_stamp: &[u8],
event_id: impl EcssEnumeration, event_id: impl EcssEnumeration,
aux_data: Option<&[u8]>, aux_data: Option<&[u8]>,
) -> Result<(), EcssTmError<E>> { ) -> Result<(), EcssTmErrorWithSend<E>> {
self.reporter.event_high_severity( self.reporter.event_high_severity(
self.source_data_buf.as_mut_slice(), self.source_data_buf.as_mut_slice(),
sender, sender,
@ -314,7 +314,7 @@ mod tests {
impl EcssTmSenderCore for TestSender { impl EcssTmSenderCore for TestSender {
type Error = (); type Error = ();
fn send_tm(&mut self, tm: PusTm) -> Result<(), EcssTmError<()>> { fn send_tm(&mut self, tm: PusTm) -> Result<(), EcssTmErrorWithSend<()>> {
assert!(tm.source_data().is_some()); assert!(tm.source_data().is_some());
let src_data = tm.source_data().unwrap(); let src_data = tm.source_data().unwrap();
assert!(src_data.len() >= 4); assert!(src_data.len() >= 4);
@ -455,8 +455,9 @@ mod tests {
let err = reporter.event_info(sender, &time_stamp_empty, event, None); let err = reporter.event_info(sender, &time_stamp_empty, event, None);
assert!(err.is_err()); assert!(err.is_err());
let err = err.unwrap_err(); let err = err.unwrap_err();
if let EcssTmError::ByteConversionError(ByteConversionError::ToSliceTooSmall(missmatch)) = if let EcssTmErrorWithSend::EcssTmError(EcssTmError::ByteConversionError(
err ByteConversionError::ToSliceTooSmall(missmatch),
)) = err
{ {
assert_eq!(missmatch.expected, 4); assert_eq!(missmatch.expected, 4);
assert_eq!(missmatch.found, expected_found_len); assert_eq!(missmatch.found, expected_found_len);

17
satrs-core/src/pus/event_man.rs
View File

@ -11,7 +11,7 @@ use hashbrown::HashSet;
#[cfg(feature = "alloc")] #[cfg(feature = "alloc")]
pub use crate::pus::event::EventReporter; pub use crate::pus::event::EventReporter;
use crate::pus::verification::{TcStateStarted, VerificationToken}; use crate::pus::verification::{TcStateStarted, VerificationToken};
use crate::pus::EcssTmError; use crate::pus::EcssTmErrorWithSend;
#[cfg(feature = "alloc")] #[cfg(feature = "alloc")]
use crate::pus::EcssTmSenderCore; use crate::pus::EcssTmSenderCore;
#[cfg(feature = "alloc")] #[cfg(feature = "alloc")]
@ -96,12 +96,12 @@ pub struct EventRequestWithToken<Event: GenericEvent = EventU32> {
#[derive(Debug)] #[derive(Debug)]
pub enum EventManError<SenderE> { pub enum EventManError<SenderE> {
EcssTmError(EcssTmError<SenderE>), EcssTmError(EcssTmErrorWithSend<SenderE>),
SeverityMissmatch(Severity, Severity), SeverityMissmatch(Severity, Severity),
} }
impl<SenderE> From<EcssTmError<SenderE>> for EventManError<SenderE> { impl<SenderE> From<EcssTmErrorWithSend<SenderE>> for EventManError<SenderE> {
fn from(v: EcssTmError<SenderE>) -> Self { fn from(v: EcssTmErrorWithSend<SenderE>) -> Self {
Self::EcssTmError(v) Self::EcssTmError(v)
} }
} }
@ -254,10 +254,13 @@ mod tests {
impl EcssTmSenderCore for EventTmSender { impl EcssTmSenderCore for EventTmSender {
type Error = SendError<Vec<u8>>; type Error = SendError<Vec<u8>>;
fn send_tm(&mut self, tm: PusTm) -> Result<(), EcssTmError<Self::Error>> { fn send_tm(&mut self, tm: PusTm) -> Result<(), EcssTmErrorWithSend<Self::Error>> {
let mut vec = Vec::new(); let mut vec = Vec::new();
tm.append_to_vec(&mut vec)?; tm.append_to_vec(&mut vec)
self.sender.send(vec).map_err(EcssTmError::SendError)?; .map_err(|e| EcssTmErrorWithSend::EcssTmError(e.into()))?;
self.sender
.send(vec)
.map_err(EcssTmErrorWithSend::SendError)?;
Ok(()) Ok(())
} }
} }

23
satrs-core/src/pus/mod.rs
View File

@ -17,11 +17,22 @@ pub mod event_man;
pub mod hk; pub mod hk;
pub mod verification; pub mod verification;
/// Generic error type which is also able to wrap a user send error with the user supplied type E.
#[derive(Debug, Clone)] #[derive(Debug, Clone)]
pub enum EcssTmError<E> { pub enum EcssTmErrorWithSend<E> {
/// Errors related to sending the verification telemetry to a TM recipient /// Errors related to sending the verification telemetry to a TM recipient
SendError(E), SendError(E),
EcssTmError(EcssTmError),
}
impl<E> From<EcssTmError> for EcssTmErrorWithSend<E> {
fn from(value: EcssTmError) -> Self {
Self::EcssTmError(value)
}
}
/// Generic error type which is also able to wrap a user send error with the user supplied type E.
#[derive(Debug, Clone)]
pub enum EcssTmError {
/// Errors related to the time stamp format of the telemetry /// Errors related to the time stamp format of the telemetry
TimestampError(TimestampError), TimestampError(TimestampError),
/// Errors related to byte conversion, for example insufficient buffer size for given data /// Errors related to byte conversion, for example insufficient buffer size for given data
@ -30,13 +41,13 @@ pub enum EcssTmError<E> {
PusError(PusError), PusError(PusError),
} }
impl<E> From<PusError> for EcssTmError<E> { impl From<PusError> for EcssTmError {
fn from(e: PusError) -> Self { fn from(e: PusError) -> Self {
EcssTmError::PusError(e) EcssTmError::PusError(e)
} }
} }
impl<E> From<ByteConversionError> for EcssTmError<E> { impl From<ByteConversionError> for EcssTmError {
fn from(e: ByteConversionError) -> Self { fn from(e: ByteConversionError) -> Self {
EcssTmError::ByteConversionError(e) EcssTmError::ByteConversionError(e)
} }
@ -48,7 +59,7 @@ impl<E> From<ByteConversionError> for EcssTmError<E> {
pub trait EcssTmSenderCore: Send { pub trait EcssTmSenderCore: Send {
type Error; type Error;
fn send_tm(&mut self, tm: PusTm) -> Result<(), EcssTmError<Self::Error>>; fn send_tm(&mut self, tm: PusTm) -> Result<(), EcssTmErrorWithSend<Self::Error>>;
} }
#[cfg(feature = "alloc")] #[cfg(feature = "alloc")]
@ -74,7 +85,7 @@ pub mod alloc_mod {
impl_downcast!(EcssTmSender assoc Error); impl_downcast!(EcssTmSender assoc Error);
} }
pub(crate) fn source_buffer_large_enough<E>(cap: usize, len: usize) -> Result<(), EcssTmError<E>> { pub(crate) fn source_buffer_large_enough(cap: usize, len: usize) -> Result<(), EcssTmError> {
if len > cap { if len > cap {
return Err(EcssTmError::ByteConversionError( return Err(EcssTmError::ByteConversionError(
ByteConversionError::ToSliceTooSmall(SizeMissmatch { ByteConversionError::ToSliceTooSmall(SizeMissmatch {

145
satrs-core/src/pus/verification.rs
View File

@ -72,7 +72,7 @@
//! The [integration test](https://egit.irs.uni-stuttgart.de/rust/fsrc-launchpad/src/branch/main/fsrc-core/tests/verification_test.rs) //! The [integration test](https://egit.irs.uni-stuttgart.de/rust/fsrc-launchpad/src/branch/main/fsrc-core/tests/verification_test.rs)
//! for the verification module contains examples how this module could be used in a more complex //! for the verification module contains examples how this module could be used in a more complex
//! context involving multiple threads //! context involving multiple threads
use crate::pus::{source_buffer_large_enough, EcssTmError, EcssTmSenderCore}; use crate::pus::{source_buffer_large_enough, EcssTmError, EcssTmErrorWithSend, EcssTmSenderCore};
use core::fmt::{Display, Formatter}; use core::fmt::{Display, Formatter};
use core::hash::{Hash, Hasher}; use core::hash::{Hash, Hasher};
use core::marker::PhantomData; use core::marker::PhantomData;
@ -192,8 +192,16 @@ impl RequestId {
/// If a verification operation fails, the passed token will be returned as well. This allows /// If a verification operation fails, the passed token will be returned as well. This allows
/// re-trying the operation at a later point. /// re-trying the operation at a later point.
#[derive(Debug, Clone)] #[derive(Debug, Clone)]
pub struct VerificationErrorWithToken<E, T>(EcssTmError<E>, VerificationToken<T>); pub struct VerificationOrSendErrorWithToken<E, T>(EcssTmErrorWithSend<E>, VerificationToken<T>);
#[derive(Debug, Clone)]
pub struct VerificationErrorWithToken<T>(EcssTmError, VerificationToken<T>);
impl<E, T> From<VerificationErrorWithToken<T>> for VerificationOrSendErrorWithToken<E, T> {
fn from(value: VerificationErrorWithToken<T>) -> Self {
VerificationOrSendErrorWithToken(value.0.into(), value.1)
}
}
/// Support token to allow type-state programming. This prevents calling the verification /// Support token to allow type-state programming. This prevents calling the verification
/// steps in an invalid order. /// steps in an invalid order.
#[derive(Debug, Clone, Copy, Eq, PartialEq)] #[derive(Debug, Clone, Copy, Eq, PartialEq)]
@ -412,14 +420,14 @@ impl VerificationReporterCore {
VerificationToken::<TcStateNone>::new(req_id) VerificationToken::<TcStateNone>::new(req_id)
} }
fn sendable_success_no_step<'slice, E, State: Copy>( fn sendable_success_no_step<'slice, State: Copy>(
&mut self, &mut self,
buf: &'slice mut [u8], buf: &'slice mut [u8],
subservice: u8, subservice: u8,
token: VerificationToken<State>, token: VerificationToken<State>,
seq_counter: &(impl SequenceCountProviderCore<u16> + ?Sized), seq_counter: &(impl SequenceCountProviderCore<u16> + ?Sized),
time_stamp: &'slice [u8], time_stamp: &'slice [u8],
) -> Result<VerificationSendable<'slice, State>, VerificationErrorWithToken<E, State>> { ) -> Result<VerificationSendable<'slice, State>, VerificationErrorWithToken<State>> {
Ok(VerificationSendable { Ok(VerificationSendable {
pus_tm: Some( pus_tm: Some(
self.create_pus_verif_success_tm( self.create_pus_verif_success_tm(
@ -437,13 +445,13 @@ impl VerificationReporterCore {
} }
/// Package a PUS TM\[1, 1\] packet, see 8.1.2.1 of the PUS standard. /// Package a PUS TM\[1, 1\] packet, see 8.1.2.1 of the PUS standard.
pub fn acceptance_success<'slice, E>( pub fn acceptance_success<'slice>(
&mut self, &mut self,
buf: &'slice mut [u8], buf: &'slice mut [u8],
token: VerificationToken<TcStateNone>, token: VerificationToken<TcStateNone>,
seq_counter: &(impl SequenceCountProviderCore<u16> + ?Sized), seq_counter: &(impl SequenceCountProviderCore<u16> + ?Sized),
time_stamp: &'slice [u8], time_stamp: &'slice [u8],
) -> Result<VerificationSendable<'slice, TcStateNone>, VerificationErrorWithToken<E, TcStateNone>> ) -> Result<VerificationSendable<'slice, TcStateNone>, VerificationErrorWithToken<TcStateNone>>
{ {
self.sendable_success_no_step( self.sendable_success_no_step(
buf, buf,
@ -455,13 +463,13 @@ impl VerificationReporterCore {
} }
/// Package a PUS TM\[1, 2\] packet, see 8.1.2.2 of the PUS standard. /// Package a PUS TM\[1, 2\] packet, see 8.1.2.2 of the PUS standard.
pub fn acceptance_failure<'slice, E>( pub fn acceptance_failure<'slice>(
&mut self, &mut self,
buf: &'slice mut [u8], buf: &'slice mut [u8],
token: VerificationToken<TcStateNone>, token: VerificationToken<TcStateNone>,
seq_counter: &(impl SequenceCountProviderCore<u16> + ?Sized), seq_counter: &(impl SequenceCountProviderCore<u16> + ?Sized),
params: FailParams<'slice, '_>, params: FailParams<'slice, '_>,
) -> Result<VerificationSendable<'slice, TcStateNone>, VerificationErrorWithToken<E, TcStateNone>> ) -> Result<VerificationSendable<'slice, TcStateNone>, VerificationErrorWithToken<TcStateNone>>
{ {
Ok(VerificationSendable { Ok(VerificationSendable {
pus_tm: Some( pus_tm: Some(
@ -482,7 +490,7 @@ impl VerificationReporterCore {
/// Package and send a PUS TM\[1, 3\] packet, see 8.1.2.3 of the PUS standard. /// Package and send a PUS TM\[1, 3\] packet, see 8.1.2.3 of the PUS standard.
/// ///
/// Requires a token previously acquired by calling [Self::acceptance_success]. /// Requires a token previously acquired by calling [Self::acceptance_success].
pub fn start_success<'slice, E>( pub fn start_success<'slice>(
&mut self, &mut self,
buf: &'slice mut [u8], buf: &'slice mut [u8],
token: VerificationToken<TcStateAccepted>, token: VerificationToken<TcStateAccepted>,
@ -490,7 +498,7 @@ impl VerificationReporterCore {
time_stamp: &'slice [u8], time_stamp: &'slice [u8],
) -> Result< ) -> Result<
VerificationSendable<'slice, TcStateAccepted>, VerificationSendable<'slice, TcStateAccepted>,
VerificationErrorWithToken<E, TcStateAccepted>, VerificationErrorWithToken<TcStateAccepted>,
> { > {
self.sendable_success_no_step( self.sendable_success_no_step(
buf, buf,
@ -505,7 +513,7 @@ impl VerificationReporterCore {
/// ///
/// Requires a token previously acquired by calling [Self::acceptance_success]. It consumes /// Requires a token previously acquired by calling [Self::acceptance_success]. It consumes
/// the token because verification handling is done. /// the token because verification handling is done.
pub fn start_failure<'slice, E>( pub fn start_failure<'slice>(
&mut self, &mut self,
buf: &'slice mut [u8], buf: &'slice mut [u8],
token: VerificationToken<TcStateAccepted>, token: VerificationToken<TcStateAccepted>,
@ -513,7 +521,7 @@ impl VerificationReporterCore {
params: FailParams<'slice, '_>, params: FailParams<'slice, '_>,
) -> Result< ) -> Result<
VerificationSendable<'slice, TcStateAccepted>, VerificationSendable<'slice, TcStateAccepted>,
VerificationErrorWithToken<E, TcStateAccepted>, VerificationErrorWithToken<TcStateAccepted>,
> { > {
Ok(VerificationSendable { Ok(VerificationSendable {
pus_tm: Some( pus_tm: Some(
@ -534,14 +542,14 @@ impl VerificationReporterCore {
/// Package and send a PUS TM\[1, 5\] packet, see 8.1.2.5 of the PUS standard. /// Package and send a PUS TM\[1, 5\] packet, see 8.1.2.5 of the PUS standard.
/// ///
/// Requires a token previously acquired by calling [Self::start_success]. /// Requires a token previously acquired by calling [Self::start_success].
pub fn step_success<'slice, E>( pub fn step_success<'slice>(
&mut self, &mut self,
buf: &'slice mut [u8], buf: &'slice mut [u8],
token: &VerificationToken<TcStateStarted>, token: &VerificationToken<TcStateStarted>,
seq_counter: &(impl SequenceCountProviderCore<u16> + ?Sized), seq_counter: &(impl SequenceCountProviderCore<u16> + ?Sized),
time_stamp: &'slice [u8], time_stamp: &'slice [u8],
step: impl EcssEnumeration, step: impl EcssEnumeration,
) -> Result<VerificationSendable<'slice, TcStateStarted>, EcssTmError<E>> { ) -> Result<VerificationSendable<'slice, TcStateStarted>, EcssTmError> {
Ok(VerificationSendable { Ok(VerificationSendable {
pus_tm: Some(self.create_pus_verif_success_tm( pus_tm: Some(self.create_pus_verif_success_tm(
buf, buf,
@ -559,7 +567,7 @@ impl VerificationReporterCore {
/// ///
/// Requires a token previously acquired by calling [Self::start_success]. It consumes the /// Requires a token previously acquired by calling [Self::start_success]. It consumes the
/// token because verification handling is done. /// token because verification handling is done.
pub fn step_failure<'slice, E>( pub fn step_failure<'slice>(
&mut self, &mut self,
buf: &'slice mut [u8], buf: &'slice mut [u8],
token: VerificationToken<TcStateStarted>, token: VerificationToken<TcStateStarted>,
@ -567,7 +575,7 @@ impl VerificationReporterCore {
params: FailParamsWithStep<'slice, '_>, params: FailParamsWithStep<'slice, '_>,
) -> Result< ) -> Result<
VerificationSendable<'slice, TcStateStarted>, VerificationSendable<'slice, TcStateStarted>,
VerificationErrorWithToken<E, TcStateStarted>, VerificationErrorWithToken<TcStateStarted>,
> { > {
Ok(VerificationSendable { Ok(VerificationSendable {
pus_tm: Some( pus_tm: Some(
@ -589,7 +597,7 @@ impl VerificationReporterCore {
/// ///
/// Requires a token previously acquired by calling [Self::start_success]. It consumes the /// Requires a token previously acquired by calling [Self::start_success]. It consumes the
/// token because verification handling is done. /// token because verification handling is done.
pub fn completion_success<'slice, E>( pub fn completion_success<'slice>(
&mut self, &mut self,
buf: &'slice mut [u8], buf: &'slice mut [u8],
token: VerificationToken<TcStateStarted>, token: VerificationToken<TcStateStarted>,
@ -597,7 +605,7 @@ impl VerificationReporterCore {
time_stamp: &'slice [u8], time_stamp: &'slice [u8],
) -> Result< ) -> Result<
VerificationSendable<'slice, TcStateStarted>, VerificationSendable<'slice, TcStateStarted>,
VerificationErrorWithToken<E, TcStateStarted>, VerificationErrorWithToken<TcStateStarted>,
> { > {
self.sendable_success_no_step( self.sendable_success_no_step(
buf, buf,
@ -612,7 +620,7 @@ impl VerificationReporterCore {
/// ///
/// Requires a token previously acquired by calling [Self::start_success]. It consumes the /// Requires a token previously acquired by calling [Self::start_success]. It consumes the
/// token because verification handling is done. /// token because verification handling is done.
pub fn completion_failure<'slice, E>( pub fn completion_failure<'slice>(
&mut self, &mut self,
buf: &'slice mut [u8], buf: &'slice mut [u8],
token: VerificationToken<TcStateStarted>, token: VerificationToken<TcStateStarted>,
@ -620,7 +628,7 @@ impl VerificationReporterCore {
params: FailParams<'slice, '_>, params: FailParams<'slice, '_>,
) -> Result< ) -> Result<
VerificationSendable<'slice, TcStateStarted>, VerificationSendable<'slice, TcStateStarted>,
VerificationErrorWithToken<E, TcStateStarted>, VerificationErrorWithToken<TcStateStarted>,
> { > {
Ok(VerificationSendable { Ok(VerificationSendable {
pus_tm: Some( pus_tm: Some(
@ -638,7 +646,7 @@ impl VerificationReporterCore {
}) })
} }
fn create_pus_verif_success_tm<'slice, E>( fn create_pus_verif_success_tm<'slice>(
&mut self, &mut self,
buf: &'slice mut [u8], buf: &'slice mut [u8],
subservice: u8, subservice: u8,
@ -646,7 +654,7 @@ impl VerificationReporterCore {
req_id: &RequestId, req_id: &RequestId,
time_stamp: &'slice [u8], time_stamp: &'slice [u8],
step: Option<&(impl EcssEnumeration + ?Sized)>, step: Option<&(impl EcssEnumeration + ?Sized)>,
) -> Result<PusTm<'slice>, EcssTmError<E>> { ) -> Result<PusTm<'slice>, EcssTmError> {
let mut source_data_len = size_of::<u32>(); let mut source_data_len = size_of::<u32>();
if let Some(step) = step { if let Some(step) = step {
source_data_len += step.byte_width(); source_data_len += step.byte_width();
@ -671,7 +679,7 @@ impl VerificationReporterCore {
)) ))
} }
fn create_pus_verif_fail_tm<'slice, E>( fn create_pus_verif_fail_tm<'slice>(
&mut self, &mut self,
buf: &'slice mut [u8], buf: &'slice mut [u8],
subservice: u8, subservice: u8,
@ -679,7 +687,7 @@ impl VerificationReporterCore {
req_id: &RequestId, req_id: &RequestId,
step: Option<&(impl EcssEnumeration + ?Sized)>, step: Option<&(impl EcssEnumeration + ?Sized)>,
params: &FailParams<'slice, '_>, params: &FailParams<'slice, '_>,
) -> Result<PusTm<'slice>, EcssTmError<E>> { ) -> Result<PusTm<'slice>, EcssTmError> {
let mut idx = 0; let mut idx = 0;
let mut source_data_len = RequestId::SIZE_AS_BYTES + params.failure_code.byte_width(); let mut source_data_len = RequestId::SIZE_AS_BYTES + params.failure_code.byte_width();
if let Some(step) = step { if let Some(step) = step {
@ -820,8 +828,10 @@ mod alloc_mod {
token: VerificationToken<TcStateNone>, token: VerificationToken<TcStateNone>,
sender: &mut (impl EcssTmSenderCore<Error = E> + ?Sized), sender: &mut (impl EcssTmSenderCore<Error = E> + ?Sized),
time_stamp: &[u8], time_stamp: &[u8],
) -> Result<VerificationToken<TcStateAccepted>, VerificationErrorWithToken<E, TcStateNone>> ) -> Result<
{ VerificationToken<TcStateAccepted>,
VerificationOrSendErrorWithToken<E, TcStateNone>,
> {
let mut sendable = self.reporter.acceptance_success( let mut sendable = self.reporter.acceptance_success(
self.source_data_buf.as_mut_slice(), self.source_data_buf.as_mut_slice(),
token, token,
@ -830,7 +840,7 @@ mod alloc_mod {
)?; )?;
sender sender
.send_tm(sendable.take_tm()) .send_tm(sendable.take_tm())
.map_err(|e| VerificationErrorWithToken(e, token))?; .map_err(|e| VerificationOrSendErrorWithToken(e, token))?;
let token = sendable.send_success_acceptance_success(Some(self.seq_counter.as_ref())); let token = sendable.send_success_acceptance_success(Some(self.seq_counter.as_ref()));
Ok(token) Ok(token)
} }
@ -841,7 +851,7 @@ mod alloc_mod {
token: VerificationToken<TcStateNone>, token: VerificationToken<TcStateNone>,
sender: &mut (impl EcssTmSenderCore<Error = E> + ?Sized), sender: &mut (impl EcssTmSenderCore<Error = E> + ?Sized),
params: FailParams, params: FailParams,
) -> Result<(), VerificationErrorWithToken<E, TcStateNone>> { ) -> Result<(), VerificationOrSendErrorWithToken<E, TcStateNone>> {
let mut sendable = self.reporter.acceptance_failure( let mut sendable = self.reporter.acceptance_failure(
self.source_data_buf.as_mut_slice(), self.source_data_buf.as_mut_slice(),
token, token,
@ -850,7 +860,7 @@ mod alloc_mod {
)?; )?;
sender sender
.send_tm(sendable.take_tm()) .send_tm(sendable.take_tm())
.map_err(|e| VerificationErrorWithToken(e, token))?; .map_err(|e| VerificationOrSendErrorWithToken(e, token))?;
sendable.send_success_verif_failure(Some(self.seq_counter.as_ref())); sendable.send_success_verif_failure(Some(self.seq_counter.as_ref()));
Ok(()) Ok(())
} }
@ -863,8 +873,10 @@ mod alloc_mod {
token: VerificationToken<TcStateAccepted>, token: VerificationToken<TcStateAccepted>,
sender: &mut (impl EcssTmSenderCore<Error = E> + ?Sized), sender: &mut (impl EcssTmSenderCore<Error = E> + ?Sized),
time_stamp: &[u8], time_stamp: &[u8],
) -> Result<VerificationToken<TcStateStarted>, VerificationErrorWithToken<E, TcStateAccepted>> ) -> Result<
{ VerificationToken<TcStateStarted>,
VerificationOrSendErrorWithToken<E, TcStateAccepted>,
> {
let mut sendable = self.reporter.start_success( let mut sendable = self.reporter.start_success(
self.source_data_buf.as_mut_slice(), self.source_data_buf.as_mut_slice(),
token, token,
@ -873,7 +885,7 @@ mod alloc_mod {
)?; )?;
sender sender
.send_tm(sendable.take_tm()) .send_tm(sendable.take_tm())
.map_err(|e| VerificationErrorWithToken(e, token))?; .map_err(|e| VerificationOrSendErrorWithToken(e, token))?;
let token = sendable.send_success_start_success(Some(self.seq_counter.as_ref())); let token = sendable.send_success_start_success(Some(self.seq_counter.as_ref()));
Ok(token) Ok(token)
} }
@ -887,7 +899,7 @@ mod alloc_mod {
token: VerificationToken<TcStateAccepted>, token: VerificationToken<TcStateAccepted>,
sender: &mut (impl EcssTmSenderCore<Error = E> + ?Sized), sender: &mut (impl EcssTmSenderCore<Error = E> + ?Sized),
params: FailParams, params: FailParams,
) -> Result<(), VerificationErrorWithToken<E, TcStateAccepted>> { ) -> Result<(), VerificationOrSendErrorWithToken<E, TcStateAccepted>> {
let mut sendable = self.reporter.start_failure( let mut sendable = self.reporter.start_failure(
self.source_data_buf.as_mut_slice(), self.source_data_buf.as_mut_slice(),
token, token,
@ -896,7 +908,7 @@ mod alloc_mod {
)?; )?;
sender sender
.send_tm(sendable.take_tm()) .send_tm(sendable.take_tm())
.map_err(|e| VerificationErrorWithToken(e, token))?; .map_err(|e| VerificationOrSendErrorWithToken(e, token))?;
sendable.send_success_verif_failure(Some(self.seq_counter.as_ref())); sendable.send_success_verif_failure(Some(self.seq_counter.as_ref()));
Ok(()) Ok(())
} }
@ -910,7 +922,7 @@ mod alloc_mod {
sender: &mut (impl EcssTmSenderCore<Error = E> + ?Sized), sender: &mut (impl EcssTmSenderCore<Error = E> + ?Sized),
time_stamp: &[u8], time_stamp: &[u8],
step: impl EcssEnumeration, step: impl EcssEnumeration,
) -> Result<(), EcssTmError<E>> { ) -> Result<(), EcssTmErrorWithSend<E>> {
let mut sendable = self.reporter.step_success( let mut sendable = self.reporter.step_success(
self.source_data_buf.as_mut_slice(), self.source_data_buf.as_mut_slice(),
token, token,
@ -932,7 +944,7 @@ mod alloc_mod {
token: VerificationToken<TcStateStarted>, token: VerificationToken<TcStateStarted>,
sender: &mut (impl EcssTmSenderCore<Error = E> + ?Sized), sender: &mut (impl EcssTmSenderCore<Error = E> + ?Sized),
params: FailParamsWithStep, params: FailParamsWithStep,
) -> Result<(), VerificationErrorWithToken<E, TcStateStarted>> { ) -> Result<(), VerificationOrSendErrorWithToken<E, TcStateStarted>> {
let mut sendable = self.reporter.step_failure( let mut sendable = self.reporter.step_failure(
self.source_data_buf.as_mut_slice(), self.source_data_buf.as_mut_slice(),
token, token,
@ -941,7 +953,7 @@ mod alloc_mod {
)?; )?;
sender sender
.send_tm(sendable.take_tm()) .send_tm(sendable.take_tm())
.map_err(|e| VerificationErrorWithToken(e, token))?; .map_err(|e| VerificationOrSendErrorWithToken(e, token))?;
sendable.send_success_step_or_completion_success(Some(self.seq_counter.as_ref())); sendable.send_success_step_or_completion_success(Some(self.seq_counter.as_ref()));
Ok(()) Ok(())
} }
@ -955,7 +967,7 @@ mod alloc_mod {
token: VerificationToken<TcStateStarted>, token: VerificationToken<TcStateStarted>,
sender: &mut (impl EcssTmSenderCore<Error = E> + ?Sized), sender: &mut (impl EcssTmSenderCore<Error = E> + ?Sized),
time_stamp: &[u8], time_stamp: &[u8],
) -> Result<(), VerificationErrorWithToken<E, TcStateStarted>> { ) -> Result<(), VerificationOrSendErrorWithToken<E, TcStateStarted>> {
let mut sendable = self.reporter.completion_success( let mut sendable = self.reporter.completion_success(
self.source_data_buf.as_mut_slice(), self.source_data_buf.as_mut_slice(),
token, token,
@ -964,7 +976,7 @@ mod alloc_mod {
)?; )?;
sender sender
.send_tm(sendable.take_tm()) .send_tm(sendable.take_tm())
.map_err(|e| VerificationErrorWithToken(e, token))?; .map_err(|e| VerificationOrSendErrorWithToken(e, token))?;
sendable.send_success_step_or_completion_success(Some(self.seq_counter.as_ref())); sendable.send_success_step_or_completion_success(Some(self.seq_counter.as_ref()));
Ok(()) Ok(())
} }
@ -978,7 +990,7 @@ mod alloc_mod {
token: VerificationToken<TcStateStarted>, token: VerificationToken<TcStateStarted>,
sender: &mut (impl EcssTmSenderCore<Error = E> + ?Sized), sender: &mut (impl EcssTmSenderCore<Error = E> + ?Sized),
params: FailParams, params: FailParams,
) -> Result<(), VerificationErrorWithToken<E, TcStateStarted>> { ) -> Result<(), VerificationOrSendErrorWithToken<E, TcStateStarted>> {
let mut sendable = self.reporter.completion_failure( let mut sendable = self.reporter.completion_failure(
self.source_data_buf.as_mut_slice(), self.source_data_buf.as_mut_slice(),
token, token,
@ -987,7 +999,7 @@ mod alloc_mod {
)?; )?;
sender sender
.send_tm(sendable.take_tm()) .send_tm(sendable.take_tm())
.map_err(|e| VerificationErrorWithToken(e, token))?; .map_err(|e| VerificationOrSendErrorWithToken(e, token))?;
sendable.send_success_step_or_completion_success(Some(self.seq_counter.as_ref())); sendable.send_success_step_or_completion_success(Some(self.seq_counter.as_ref()));
Ok(()) Ok(())
} }
@ -1032,8 +1044,10 @@ mod alloc_mod {
&mut self, &mut self,
token: VerificationToken<TcStateNone>, token: VerificationToken<TcStateNone>,
time_stamp: &[u8], time_stamp: &[u8],
) -> Result<VerificationToken<TcStateAccepted>, VerificationErrorWithToken<E, TcStateNone>> ) -> Result<
{ VerificationToken<TcStateAccepted>,
VerificationOrSendErrorWithToken<E, TcStateNone>,
> {
self.reporter self.reporter
.acceptance_success(token, self.sender.as_mut(), time_stamp) .acceptance_success(token, self.sender.as_mut(), time_stamp)
} }
@ -1042,7 +1056,7 @@ mod alloc_mod {
&mut self, &mut self,
token: VerificationToken<TcStateNone>, token: VerificationToken<TcStateNone>,
params: FailParams, params: FailParams,
) -> Result<(), VerificationErrorWithToken<E, TcStateNone>> { ) -> Result<(), VerificationOrSendErrorWithToken<E, TcStateNone>> {
self.reporter self.reporter
.acceptance_failure(token, self.sender.as_mut(), params) .acceptance_failure(token, self.sender.as_mut(), params)
} }
@ -1051,8 +1065,10 @@ mod alloc_mod {
&mut self, &mut self,
token: VerificationToken<TcStateAccepted>, token: VerificationToken<TcStateAccepted>,
time_stamp: &[u8], time_stamp: &[u8],
) -> Result<VerificationToken<TcStateStarted>, VerificationErrorWithToken<E, TcStateAccepted>> ) -> Result<
{ VerificationToken<TcStateStarted>,
VerificationOrSendErrorWithToken<E, TcStateAccepted>,
> {
self.reporter self.reporter
.start_success(token, self.sender.as_mut(), time_stamp) .start_success(token, self.sender.as_mut(), time_stamp)
} }
@ -1061,7 +1077,7 @@ mod alloc_mod {
&mut self, &mut self,
token: VerificationToken<TcStateAccepted>, token: VerificationToken<TcStateAccepted>,
params: FailParams, params: FailParams,
) -> Result<(), VerificationErrorWithToken<E, TcStateAccepted>> { ) -> Result<(), VerificationOrSendErrorWithToken<E, TcStateAccepted>> {
self.reporter self.reporter
.start_failure(token, self.sender.as_mut(), params) .start_failure(token, self.sender.as_mut(), params)
} }
@ -1071,7 +1087,7 @@ mod alloc_mod {
token: &VerificationToken<TcStateStarted>, token: &VerificationToken<TcStateStarted>,
time_stamp: &[u8], time_stamp: &[u8],
step: impl EcssEnumeration, step: impl EcssEnumeration,
) -> Result<(), EcssTmError<E>> { ) -> Result<(), EcssTmErrorWithSend<E>> {
self.reporter self.reporter
.step_success(token, self.sender.as_mut(), time_stamp, step) .step_success(token, self.sender.as_mut(), time_stamp, step)
} }
@ -1080,7 +1096,7 @@ mod alloc_mod {
&mut self, &mut self,
token: VerificationToken<TcStateStarted>, token: VerificationToken<TcStateStarted>,
params: FailParamsWithStep, params: FailParamsWithStep,
) -> Result<(), VerificationErrorWithToken<E, TcStateStarted>> { ) -> Result<(), VerificationOrSendErrorWithToken<E, TcStateStarted>> {
self.reporter self.reporter
.step_failure(token, self.sender.as_mut(), params) .step_failure(token, self.sender.as_mut(), params)
} }
@ -1089,7 +1105,7 @@ mod alloc_mod {
&mut self, &mut self,
token: VerificationToken<TcStateStarted>, token: VerificationToken<TcStateStarted>,
time_stamp: &[u8], time_stamp: &[u8],
) -> Result<(), VerificationErrorWithToken<E, TcStateStarted>> { ) -> Result<(), VerificationOrSendErrorWithToken<E, TcStateStarted>> {
self.reporter self.reporter
.completion_success(token, self.sender.as_mut(), time_stamp) .completion_success(token, self.sender.as_mut(), time_stamp)
} }
@ -1098,7 +1114,7 @@ mod alloc_mod {
&mut self, &mut self,
token: VerificationToken<TcStateStarted>, token: VerificationToken<TcStateStarted>,
params: FailParams, params: FailParams,
) -> Result<(), VerificationErrorWithToken<E, TcStateStarted>> { ) -> Result<(), VerificationOrSendErrorWithToken<E, TcStateStarted>> {
self.reporter self.reporter
.completion_failure(token, self.sender.as_mut(), params) .completion_failure(token, self.sender.as_mut(), params)
} }
@ -1130,9 +1146,9 @@ mod stdmod {
} }
} }
impl From<StoreError> for EcssTmError<StdVerifSenderError> { impl From<StoreError> for EcssTmErrorWithSend<StdVerifSenderError> {
fn from(e: StoreError) -> Self { fn from(e: StoreError) -> Self {
EcssTmError::SendError(e.into()) EcssTmErrorWithSend::SendError(e.into())
} }
} }
@ -1187,7 +1203,7 @@ mod stdmod {
delegate!( delegate!(
to self.base { to self.base {
fn send_tm(&mut self, tm: PusTm) -> Result<(), EcssTmError<StdVerifSenderError>>; fn send_tm(&mut self, tm: PusTm) -> Result<(), EcssTmErrorWithSend<StdVerifSenderError>>;
} }
); );
} }
@ -1222,20 +1238,20 @@ mod stdmod {
delegate!( delegate!(
to self.base { to self.base {
fn send_tm(&mut self, tm: PusTm) -> Result<(), EcssTmError<StdVerifSenderError>>; fn send_tm(&mut self, tm: PusTm) -> Result<(), EcssTmErrorWithSend<StdVerifSenderError>>;
} }
); );
} }
impl<S: SendBackend + Clone + 'static> EcssTmSenderCore for StdSenderBase<S> { impl<S: SendBackend + Clone + 'static> EcssTmSenderCore for StdSenderBase<S> {
type Error = StdVerifSenderError; type Error = StdVerifSenderError;
fn send_tm(&mut self, tm: PusTm) -> Result<(), EcssTmError<Self::Error>> { fn send_tm(&mut self, tm: PusTm) -> Result<(), EcssTmErrorWithSend<Self::Error>> {
let operation = |mut mg: RwLockWriteGuard<ShareablePoolProvider>| { let operation = |mut mg: RwLockWriteGuard<ShareablePoolProvider>| {
let (addr, buf) = mg.free_element(tm.len_packed())?; let (addr, buf) = mg.free_element(tm.len_packed())?;
tm.write_to_bytes(buf).map_err(EcssTmError::PusError)?; tm.write_to_bytes(buf).map_err(EcssTmError::PusError)?;
drop(mg); drop(mg);
self.tx.send(addr).map_err(|_| { self.tx.send(addr).map_err(|_| {
EcssTmError::SendError(StdVerifSenderError::RxDisconnected(addr)) EcssTmErrorWithSend::SendError(StdVerifSenderError::RxDisconnected(addr))
})?; })?;
Ok(()) Ok(())
}; };
@ -1245,7 +1261,9 @@ mod stdmod {
if self.ignore_poison_error { if self.ignore_poison_error {
operation(poison_error.into_inner()) operation(poison_error.into_inner())
} else { } else {
Err(EcssTmError::SendError(StdVerifSenderError::PoisonError)) Err(EcssTmErrorWithSend::SendError(
StdVerifSenderError::PoisonError,
))
} }
} }
} }
@ -1262,6 +1280,7 @@ mod tests {
TcStateNone, VerificationReporter, VerificationReporterCfg, VerificationReporterWithSender, TcStateNone, VerificationReporter, VerificationReporterCfg, VerificationReporterWithSender,
VerificationToken, VerificationToken,
}; };
use crate::pus::EcssTmErrorWithSend;
use crate::seq_count::SeqCountProviderSimple; use crate::seq_count::SeqCountProviderSimple;
use alloc::boxed::Box; use alloc::boxed::Box;
use alloc::format; use alloc::format;
@ -1295,7 +1314,7 @@ mod tests {
impl EcssTmSenderCore for TestSender { impl EcssTmSenderCore for TestSender {
type Error = (); type Error = ();
fn send_tm(&mut self, tm: PusTm) -> Result<(), EcssTmError<Self::Error>> { fn send_tm(&mut self, tm: PusTm) -> Result<(), EcssTmErrorWithSend<Self::Error>> {
assert_eq!(PusPacket::service(&tm), 1); assert_eq!(PusPacket::service(&tm), 1);
assert!(tm.source_data().is_some()); assert!(tm.source_data().is_some());
let mut time_stamp = [0; 7]; let mut time_stamp = [0; 7];
@ -1325,8 +1344,8 @@ mod tests {
impl EcssTmSenderCore for FallibleSender { impl EcssTmSenderCore for FallibleSender {
type Error = DummyError; type Error = DummyError;
fn send_tm(&mut self, _: PusTm) -> Result<(), EcssTmError<DummyError>> { fn send_tm(&mut self, _: PusTm) -> Result<(), EcssTmErrorWithSend<DummyError>> {
Err(EcssTmError::SendError(DummyError {})) Err(EcssTmErrorWithSend::SendError(DummyError {}))
} }
} }
@ -1460,7 +1479,7 @@ mod tests {
let err = res.unwrap_err(); let err = res.unwrap_err();
assert_eq!(err.1, tok); assert_eq!(err.1, tok);
match err.0 { match err.0 {
EcssTmError::SendError(e) => { EcssTmErrorWithSend::SendError(e) => {
assert_eq!(e, DummyError {}) assert_eq!(e, DummyError {})
} }
_ => panic!("{}", format!("Unexpected error {:?}", err.0)), _ => panic!("{}", format!("Unexpected error {:?}", err.0)),
@ -1527,7 +1546,7 @@ mod tests {
let err_with_token = res.unwrap_err(); let err_with_token = res.unwrap_err();
assert_eq!(err_with_token.1, tok); assert_eq!(err_with_token.1, tok);
match err_with_token.0 { match err_with_token.0 {
EcssTmError::ByteConversionError(e) => match e { EcssTmErrorWithSend::EcssTmError(EcssTmError::ByteConversionError(e)) => match e {
ByteConversionError::ToSliceTooSmall(missmatch) => { ByteConversionError::ToSliceTooSmall(missmatch) => {
assert_eq!( assert_eq!(
missmatch.expected, missmatch.expected,

11
satrs-core/tests/pus_events.rs
View File

@ -7,7 +7,7 @@ use satrs_core::params::{Params, ParamsHeapless, WritableToBeBytes};
use satrs_core::pus::event_man::{ use satrs_core::pus::event_man::{
DefaultPusMgmtBackendProvider, EventReporter, PusEventDispatcher, DefaultPusMgmtBackendProvider, EventReporter, PusEventDispatcher,
}; };
use satrs_core::pus::{EcssTmError, EcssTmSenderCore}; use satrs_core::pus::{EcssTmErrorWithSend, EcssTmSenderCore};
use spacepackets::ecss::PusPacket; use spacepackets::ecss::PusPacket;
use spacepackets::tm::PusTm; use spacepackets::tm::PusTm;
use std::sync::mpsc::{channel, SendError, TryRecvError}; use std::sync::mpsc::{channel, SendError, TryRecvError};
@ -25,10 +25,13 @@ struct EventTmSender {
impl EcssTmSenderCore for EventTmSender { impl EcssTmSenderCore for EventTmSender {
type Error = SendError<Vec<u8>>; type Error = SendError<Vec<u8>>;
fn send_tm(&mut self, tm: PusTm) -> Result<(), EcssTmError<Self::Error>> { fn send_tm(&mut self, tm: PusTm) -> Result<(), EcssTmErrorWithSend<Self::Error>> {
let mut vec = Vec::new(); let mut vec = Vec::new();
tm.append_to_vec(&mut vec)?; tm.append_to_vec(&mut vec)
self.sender.send(vec).map_err(EcssTmError::SendError)?; .map_err(|e| EcssTmErrorWithSend::EcssTmError(e.into()))?;
self.sender
.send(vec)
.map_err(EcssTmErrorWithSend::SendError)?;
Ok(()) Ok(())
} }
} }

8
satrs-example/src/main.rs
View File

@ -22,7 +22,7 @@ use satrs_core::pus::hk::Subservice;
use satrs_core::pus::verification::{ use satrs_core::pus::verification::{
MpscVerifSender, VerificationReporterCfg, VerificationReporterWithSender, MpscVerifSender, VerificationReporterCfg, VerificationReporterWithSender,
}; };
use satrs_core::pus::{EcssTmError, EcssTmSenderCore}; use satrs_core::pus::{EcssTmErrorWithSend, EcssTmSenderCore};
use satrs_core::seq_count::SeqCountProviderSimple; use satrs_core::seq_count::SeqCountProviderSimple;
use satrs_example::{RequestTargetId, OBSW_SERVER_ADDR, SERVER_PORT}; use satrs_example::{RequestTargetId, OBSW_SERVER_ADDR, SERVER_PORT};
use spacepackets::time::cds::TimeProvider; use spacepackets::time::cds::TimeProvider;
@ -54,9 +54,11 @@ impl EventTmSender {
impl EcssTmSenderCore for EventTmSender { impl EcssTmSenderCore for EventTmSender {
type Error = mpsc::SendError<StoreAddr>; type Error = mpsc::SendError<StoreAddr>;
fn send_tm(&mut self, tm: PusTm) -> Result<(), EcssTmError<Self::Error>> { fn send_tm(&mut self, tm: PusTm) -> Result<(), EcssTmErrorWithSend<Self::Error>> {
let addr = self.store_helper.add_pus_tm(&tm); let addr = self.store_helper.add_pus_tm(&tm);
self.sender.send(addr).map_err(EcssTmError::SendError) self.sender
.send(addr)
.map_err(EcssTmErrorWithSend::SendError)
} }
} }