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

allow verif failure and completion starting from accepted

Browse Source 
- Also add some prototyping code a prep for generic PUS router
This commit is contained in:
Robin Müller 2023-02-28 14:53:57 +01:00
parent b2fc172b0a
commit 53003b9c66
No known key found for this signature in database
GPG Key ID: 11D4952C8CCEF814
3 changed files with 80 additions and 31 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
satrs-core/src/mode.rs
View File

@ -36,9 +36,13 @@ impl ModeAndSubmode {
})
}
pub fn mode(&self) -> u32 {self.mode}
pub fn mode(&self) -> u32 {
self.mode
}
pub fn submode(&self) -> u16 {self.submode}
pub fn submode(&self) -> u16 {
self.submode
}
}
#[derive(Debug, Copy, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]

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

@ -199,6 +199,8 @@ pub struct VerificationToken<STATE> {
req_id: RequestId,
}
pub trait WasAtLeastAccepted {}
#[derive(Copy, Clone, Debug, Eq, PartialEq)]
pub struct TcStateNone;
#[derive(Copy, Clone, Debug, Eq, PartialEq)]
@ -206,6 +208,9 @@ pub struct TcStateAccepted;
#[derive(Copy, Clone, Debug, Eq, PartialEq)]
pub struct TcStateStarted;
impl WasAtLeastAccepted for TcStateAccepted {}
impl WasAtLeastAccepted for TcStateStarted {}
#[derive(Debug, Eq, PartialEq)]
pub enum TcStateToken {
None(VerificationToken<TcStateNone>),
@ -381,7 +386,9 @@ impl<'src_data> VerificationSendable<'src_data, TcStateAccepted, VerifSuccess> {
}
}
impl<'src_data> VerificationSendable<'src_data, TcStateStarted, VerifSuccess> {
impl<'src_data, TcState: WasAtLeastAccepted + Copy>
VerificationSendable<'src_data, TcState, VerifSuccess>
{
pub fn send_success_step_or_completion_success(
self,
seq_counter: Option<&(impl SequenceCountProviderCore<u16> + ?Sized)>,
@ -704,15 +711,15 @@ impl VerificationReporterCore {
///
/// Requires a token previously acquired by calling [Self::start_success]. It consumes the
/// token because verification handling is done.
pub fn completion_success<'src_data>(
pub fn completion_success<'src_data, TcState: WasAtLeastAccepted + Copy>(
&mut self,
src_data_buf: &'src_data mut [u8],
token: VerificationToken<TcStateStarted>,
token: VerificationToken<TcState>,
seq_counter: &(impl SequenceCountProviderCore<u16> + ?Sized),
time_stamp: Option<&'src_data [u8]>,
) -> Result<
VerificationSendable<'src_data, TcStateStarted, VerifSuccess>,
VerificationErrorWithToken<TcStateStarted>,
VerificationSendable<'src_data, TcState, VerifSuccess>,
VerificationErrorWithToken<TcState>,
> {
self.sendable_success_no_step(
src_data_buf,
@ -727,15 +734,15 @@ impl VerificationReporterCore {
///
/// Requires a token previously acquired by calling [Self::start_success]. It consumes the
/// token because verification handling is done.
pub fn completion_failure<'src_data>(
pub fn completion_failure<'src_data, TcState: WasAtLeastAccepted + Copy>(
&mut self,
src_data_buf: &'src_data mut [u8],
token: VerificationToken<TcStateStarted>,
token: VerificationToken<TcState>,
seq_counter: &(impl SequenceCountProviderCore<u16> + ?Sized),
params: FailParams<'src_data, '_>,
) -> Result<
VerificationSendable<'src_data, TcStateStarted, VerifFailure>,
VerificationErrorWithToken<TcStateStarted>,
VerificationSendable<'src_data, TcState, VerifFailure>,
VerificationErrorWithToken<TcState>,
> {
self.sendable_failure_no_step(
src_data_buf,
@ -747,12 +754,12 @@ impl VerificationReporterCore {
)
}
pub fn send_step_or_completion_success<E>(
pub fn send_step_or_completion_success<E, TcState: WasAtLeastAccepted + Copy>(
&self,
mut sendable: VerificationSendable<'_, TcStateStarted, VerifSuccess>,
mut sendable: VerificationSendable<'_, TcState, VerifSuccess>,
seq_counter: &(impl SequenceCountProviderCore<u16> + ?Sized),
sender: &mut (impl EcssTmSenderCore<Error = E> + ?Sized),
) -> Result<(), VerificationOrSendErrorWithToken<E, TcStateStarted>> {
) -> Result<(), VerificationOrSendErrorWithToken<E, TcState>> {
sender
.send_tm(sendable.pus_tm.take().unwrap())
.map_err(|e| {
@ -765,12 +772,12 @@ impl VerificationReporterCore {
Ok(())
}
pub fn send_step_or_completion_failure<E>(
pub fn send_step_or_completion_failure<E, TcState: WasAtLeastAccepted + Copy>(
&self,
mut sendable: VerificationSendable<'_, TcStateStarted, VerifFailure>,
mut sendable: VerificationSendable<'_, TcState, VerifFailure>,
seq_counter: &(impl SequenceCountProviderCore<u16> + ?Sized),
sender: &mut (impl EcssTmSenderCore<Error = E> + ?Sized),
) -> Result<(), VerificationOrSendErrorWithToken<E, TcStateStarted>> {
) -> Result<(), VerificationOrSendErrorWithToken<E, TcState>> {
sender
.send_tm(sendable.pus_tm.take().unwrap())
.map_err(|e| {
@ -1087,12 +1094,12 @@ mod alloc_mod {
///
/// Requires a token previously acquired by calling [Self::start_success]. It consumes the
/// token because verification handling is done.
pub fn completion_success<E>(
pub fn completion_success<E, TcState: WasAtLeastAccepted + Copy>(
&mut self,
token: VerificationToken<TcStateStarted>,
token: VerificationToken<TcState>,
sender: &mut (impl EcssTmSenderCore<Error = E> + ?Sized),
time_stamp: Option<&[u8]>,
) -> Result<(), VerificationOrSendErrorWithToken<E, TcStateStarted>> {
) -> Result<(), VerificationOrSendErrorWithToken<E, TcState>> {
let sendable = self.reporter.completion_success(
self.source_data_buf.as_mut_slice(),
token,
@ -1110,12 +1117,12 @@ mod alloc_mod {
///
/// Requires a token previously acquired by calling [Self::start_success]. It consumes the
/// token because verification handling is done.
pub fn completion_failure<E>(
pub fn completion_failure<E, TcState: WasAtLeastAccepted + Copy>(
&mut self,
token: VerificationToken<TcStateStarted>,
token: VerificationToken<TcState>,
sender: &mut (impl EcssTmSenderCore<Error = E> + ?Sized),
params: FailParams,
) -> Result<(), VerificationOrSendErrorWithToken<E, TcStateStarted>> {
) -> Result<(), VerificationOrSendErrorWithToken<E, TcState>> {
let sendable = self.reporter.completion_failure(
self.source_data_buf.as_mut_slice(),
token,
@ -1226,20 +1233,20 @@ mod alloc_mod {
.step_failure(token, self.sender.as_mut(), params)
}
pub fn completion_success(
pub fn completion_success<TcState: WasAtLeastAccepted + Copy>(
&mut self,
token: VerificationToken<TcStateStarted>,
token: VerificationToken<TcState>,
time_stamp: Option<&[u8]>,
) -> Result<(), VerificationOrSendErrorWithToken<E, TcStateStarted>> {
) -> Result<(), VerificationOrSendErrorWithToken<E, TcState>> {
self.reporter
.completion_success(token, self.sender.as_mut(), time_stamp)
}
pub fn completion_failure(
pub fn completion_failure<TcState: WasAtLeastAccepted + Copy>(
&mut self,
token: VerificationToken<TcStateStarted>,
token: VerificationToken<TcState>,
params: FailParams,
) -> Result<(), VerificationOrSendErrorWithToken<E, TcStateStarted>> {
) -> Result<(), VerificationOrSendErrorWithToken<E, TcState>> {
self.reporter
.completion_failure(token, self.sender.as_mut(), params)
}

42
satrs-example/src/pus.rs
View File

@ -5,7 +5,7 @@ use satrs_core::events::EventU32;
use satrs_core::hk::{CollectionIntervalFactor, HkRequest};
use satrs_core::mode::{ModeAndSubmode, ModeRequest};
use satrs_core::params::Params;
use satrs_core::pool::StoreAddr;
use satrs_core::pool::{PoolProvider, StoreAddr};
use satrs_core::pus::event_man::{EventRequest, EventRequestWithToken};
use satrs_core::pus::hk;
use satrs_core::pus::mode;
@ -18,6 +18,7 @@ use satrs_core::pus::verification::{
use satrs_core::pus::{event, GenericTcCheckError};
use satrs_core::res_code::ResultU16;
use satrs_core::spacepackets::ecss::{scheduling, PusServiceId};
use satrs_core::spacepackets::time::CcsdsTimeProvider;
use satrs_core::tmtc::tm_helper::PusTmWithCdsShortHelper;
use satrs_core::tmtc::{AddressableId, PusServiceProvider, TargetId};
use satrs_core::{
@ -29,7 +30,7 @@ use std::cell::RefCell;
use std::collections::HashMap;
use std::convert::TryFrom;
use std::rc::Rc;
use std::sync::mpsc::Sender;
use std::sync::mpsc::{Receiver, Sender};
pub struct PusReceiver {
pub tm_helper: PusTmWithCdsShortHelper,
@ -53,6 +54,43 @@ impl PusTmArgs {
}
}
pub struct PusTcHandlerBase {
pub tc_store: Box<dyn PoolProvider>,
pub receiver: Receiver<(StoreAddr, VerificationToken<TcStateAccepted>)>,
pub verif_reporter: StdVerifReporterWithSender,
pub time_provider: Box<dyn CcsdsTimeProvider>,
}
pub trait TestHandlerNoPing {
fn handle_no_ping_tc(&mut self, tc: PusTc);
}
pub struct PusTestTcHandler {
pub base: PusTcHandlerBase,
handler: Option<Box<dyn TestHandlerNoPing>>,
}
pub struct PusScheduleTcHandler {
pub base: PusTestTcHandler,
}
impl PusTestTcHandler {
pub fn operation(&mut self) {
let (addr, token) = self.base.receiver.recv().unwrap();
let data = self.base.tc_store.read(&addr).unwrap();
let (pus_tc, _len) = PusTc::from_bytes(data).unwrap();
let stamp: [u8; 7] = [0; 7];
if pus_tc.subservice() == 1 {
self.base
.verif_reporter
.completion_success(token, Some(&stamp))
.unwrap();
} else if let Some(handler) = &mut self.handler {
handler.handle_no_ping_tc(pus_tc);
}
}
}
pub struct PusTcArgs {
pub event_request_tx: Sender<EventRequestWithToken>,
/// Request routing helper. Maps targeted requests to their recipient.