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

continue fixing old code

Browse Source
This commit is contained in:
Robin Müller
2024-03-20 10:45:30 +01:00
parent 0f2a700ef1
commit 9903194cfc
6 changed files with 313 additions and 137 deletions
Download Patch File Download Diff File Expand all files Collapse all files

150
satrs-example/src/pus/action.rs
View File

@ -1,54 +1,119 @@
use log::{error, warn};
use satrs::action::{ActionRequest, ActionRequestVariant};
use satrs::params::WritableToBeBytes;
use satrs::pool::{SharedStaticMemoryPool, StoreAddr};
use satrs::pus::action::{
ActionReplyPus, ActionReplyPusWithActionId, ActiveActionRequest, DefaultActiveActionRequestMap,
PusService8ReplyHandler,
ActionReplyPus, ActionReplyPusWithActionId, ActionRequestWithId, ActivePusActionRequest,
DefaultActiveActionRequestMap,
};
use satrs::pus::verification::{
FailParams, TcStateAccepted, VerificationReporterWithSharedPoolMpscBoundedSender,
VerificationReporterWithVecMpscSender, VerificationReportingProvider, VerificationToken,
self, FailParams, FailParamsWithStep, TcStateAccepted,
VerificationReporterWithSharedPoolMpscBoundedSender, VerificationReporterWithVecMpscSender,
VerificationReportingProvider, VerificationToken,
};
use satrs::pus::{
EcssTcAndToken, EcssTcInMemConverter, EcssTcInSharedStoreConverter, EcssTcInVecConverter,
EcssTcReceiverCore, EcssTmSenderCore, MpscTcReceiver, PusPacketHandlerResult,
PusPacketHandlingError, PusReplyHandler, PusServiceHelper, PusTcToRequestConverter,
ReplyHandlerHook, TmAsVecSenderWithId, TmAsVecSenderWithMpsc,
ActiveRequestProvider, EcssTcAndToken, EcssTcInMemConverter, EcssTcInSharedStoreConverter,
EcssTcInVecConverter, EcssTcReceiverCore, EcssTmSenderCore, EcssTmtcError, MpscTcReceiver,
PusPacketHandlerResult, PusPacketHandlingError, PusReplyHandler, PusServiceHelper,
PusTcToRequestConverter, TmAsVecSenderWithId, TmAsVecSenderWithMpsc,
TmInSharedPoolSenderWithBoundedMpsc, TmInSharedPoolSenderWithId,
};
use satrs::request::TargetAndApidId;
use satrs::request::{GenericMessage, TargetAndApidId};
use satrs::spacepackets::ecss::tc::PusTcReader;
use satrs::spacepackets::ecss::PusPacket;
use satrs::spacepackets::ecss::{EcssEnumU16, PusPacket};
use satrs::spacepackets::time::UnixTimestamp;
use satrs::tmtc::tm_helper::SharedTmPool;
use satrs::{ChannelId, TargetId};
use satrs_example::config::tmtc_err::REQUEST_TIMEOUT;
use satrs::ChannelId;
use satrs_example::config::{tmtc_err, TcReceiverId, TmSenderId, PUS_APID};
use std::sync::mpsc::{self};
use std::time::Duration;
use crate::requests::GenericRequestRouter;
use super::PusTargetedRequestService;
#[derive(Default)]
pub struct ActionReplyHandler {}
pub struct ActionReplyHandler {
fail_data_buf: [u8; 128],
}
impl PusReplyHandler<ActiveActionRequest, ActionReplyPusWithActionId> for ActionReplyHandler {
type Error = ();
impl Default for ActionReplyHandler {
fn default() -> Self {
Self {
fail_data_buf: [0; 128],
}
}
}
impl PusReplyHandler<ActivePusActionRequest, ActionReplyPusWithActionId> for ActionReplyHandler {
type Error = EcssTmtcError;
fn handle_unexpected_reply(
&mut self,
reply: &satrs::request::GenericMessage<ActionReplyPusWithActionId>,
reply: &GenericMessage<ActionReplyPusWithActionId>,
tm_sender: &impl EcssTmSenderCore,
) {
log::warn!("received unexpected reply for service {SERVICE}: {reply}");
log::warn!("received unexpected reply for service 8: {reply:?}");
}
fn handle_reply(
&mut self,
reply: &satrs::request::GenericMessage<ActionReplyPusWithActionId>,
active_request: &ActivePusActionRequest,
verification_handler: &impl VerificationReportingProvider,
time_stamp: &[u8],
tm_sender: &impl EcssTmSenderCore,
) -> Result<bool, Self::Error> {
todo!()
let remove_entry = match reply.message.variant {
ActionReplyPus::CompletionFailed { error_code, params } => {
let fail_data_len = params.write_to_be_bytes(&mut self.fail_data_buf)?;
verification_handler
.completion_failure(
active_request.token(),
FailParams::new(
time_stamp,
&error_code,
&self.fail_data_buf[..fail_data_len],
),
)
.map_err(|e| e.0)?;
true
}
ActionReplyPus::StepFailed {
error_code,
step,
params,
} => {
let fail_data_len = params.write_to_be_bytes(&mut self.fail_data_buf)?;
verification_handler
.step_failure(
active_request.token(),
FailParamsWithStep::new(
time_stamp,
&EcssEnumU16::new(step),
&error_code,
&self.fail_data_buf[..fail_data_len],
),
)
.map_err(|e| e.0)?;
true
}
ActionReplyPus::Completed => {
verification_handler
.completion_success(active_request.token(), time_stamp)
.map_err(|e| e.0)?;
true
}
ActionReplyPus::StepSuccess { step } => {
verification_handler.step_success(
&active_request.token(),
time_stamp,
EcssEnumU16::new(step),
)?;
false
}
_ => false,
};
Ok(remove_entry)
}
/*
@ -65,7 +130,9 @@ impl PusReplyHandler<ActiveActionRequest, ActionReplyPusWithActionId> for Action
#[derive(Default)]
pub struct ExampleActionRequestConverter {}
impl PusTcToRequestConverter<ActionRequest> for ExampleActionRequestConverter {
impl PusTcToRequestConverter<ActivePusActionRequest, ActionRequestWithId>
for ExampleActionRequestConverter
{
type Error = PusPacketHandlingError;
fn convert(
@ -74,7 +141,7 @@ impl PusTcToRequestConverter<ActionRequest> for ExampleActionRequestConverter {
tc: &PusTcReader,
time_stamp: &[u8],
verif_reporter: &impl VerificationReportingProvider,
) -> Result<(TargetId, ActionRequest), Self::Error> {
) -> Result<(ActivePusActionRequest, ActionRequestWithId), Self::Error> {
let subservice = tc.subservice();
let user_data = tc.user_data();
if user_data.len() < 8 {
@ -89,15 +156,27 @@ impl PusTcToRequestConverter<ActionRequest> for ExampleActionRequestConverter {
found: user_data.len(),
});
}
let target_id = TargetAndApidId::from_pus_tc(tc).unwrap();
let target_id_and_apid = TargetAndApidId::from_pus_tc(tc).unwrap();
let action_id = u32::from_be_bytes(user_data[4..8].try_into().unwrap());
if subservice == 128 {
let token = verif_reporter
.start_success(token, time_stamp)
.map_err(|e| e.0)?;
Ok((
target_id.raw(),
ActionRequest::new(
ActivePusActionRequest::new(
action_id,
ActionRequestVariant::VecData(user_data[8..].to_vec()),
target_id_and_apid.into(),
token,
UnixTimestamp::from_now().unwrap(),
Duration::from_secs(30),
),
ActionRequestWithId {
request_id: verification::RequestId::new(tc).into(),
request: ActionRequest::new(
action_id,
ActionRequestVariant::VecData(user_data[8..].to_vec()),
),
},
))
} else {
verif_reporter
@ -148,7 +227,7 @@ pub fn create_action_service_static(
// TODO: Implementation which does not use run-time allocation? Maybe something like
// a bounded wrapper which pre-allocates using [HashMap::with_capacity]..
DefaultActiveActionRequestMap::default(),
ActionReplyHandler::<8>::default(),
ActionReplyHandler::default(),
);
Pus8Wrapper {
action_request_handler,
@ -187,17 +266,18 @@ pub fn create_action_service_dynamic(
ExampleActionRequestConverter::default(),
action_router,
DefaultActiveActionRequestMap::default(),
ActionReplyHandler::<8>::default(),
ActionReplyHandler::default(),
);
Pus8Wrapper {
action_request_handler,
}
}
/*
#[derive(Default)]
pub struct PusActionReplyHook {}
impl ReplyHandlerHook<ActiveActionRequest, ActionReplyPusWithActionId> for PusActionReplyHook {
impl ReplyHandlerHook<ActivePusActionRequest, ActionReplyPusWithActionId> for PusActionReplyHook {
fn handle_unexpected_reply(
&mut self,
reply: &satrs::request::GenericMessage<ActionReplyPusWithActionId>,
@ -205,7 +285,7 @@ impl ReplyHandlerHook<ActiveActionRequest, ActionReplyPusWithActionId> for PusAc
println!("received unexpected action reply {:?}", reply);
}
fn timeout_callback(&self, active_request: &ActiveActionRequest) {
fn timeout_callback(&self, active_request: &ActivePusActionRequest) {
println!("active request {active_request:?} timed out");
}
@ -213,6 +293,8 @@ impl ReplyHandlerHook<ActiveActionRequest, ActionReplyPusWithActionId> for PusAc
todo!()
}
}
*/
pub struct Pus8Wrapper<
TcReceiver: EcssTcReceiverCore,
TmSender: EcssTmSenderCore,
@ -225,7 +307,11 @@ pub struct Pus8Wrapper<
TcInMemConverter,
VerificationReporter,
ExampleActionRequestConverter,
ActionRequest,
ActionReplyHandler,
DefaultActiveActionRequestMap,
ActivePusActionRequest,
ActionRequestWithId,
ActionReplyPusWithActionId,
>,
}
@ -236,8 +322,8 @@ impl<
VerificationReporter: VerificationReportingProvider,
> Pus8Wrapper<TcReceiver, TmSender, TcInMemConverter, VerificationReporter>
{
pub fn handle_next_packet(&mut self) -> bool {
match self.action_request_handler.handle_one_tc() {
pub fn handle_next_packet(&mut self, time_stamp: &[u8]) -> bool {
match self.action_request_handler.handle_one_tc(time_stamp) {
Ok(result) => match result {
PusPacketHandlerResult::RequestHandled => {}
PusPacketHandlerResult::RequestHandledPartialSuccess(e) => {