2023-07-06 00:49:18 +02:00
|
|
|
use log::{error, warn};
|
2024-02-12 15:51:37 +01:00
|
|
|
use satrs::hk::{CollectionIntervalFactor, HkRequest};
|
|
|
|
use satrs::pool::{SharedStaticMemoryPool, StoreAddr};
|
2024-02-20 14:33:21 +01:00
|
|
|
use satrs::pus::hk::{PusHkToRequestConverter, PusService3HkHandler};
|
2024-02-26 11:41:42 +01:00
|
|
|
use satrs::pus::verification::std_mod::{
|
|
|
|
VerificationReporterWithSharedPoolMpscBoundedSender, VerificationReporterWithVecMpscSender,
|
|
|
|
};
|
2024-02-12 15:51:37 +01:00
|
|
|
use satrs::pus::verification::{
|
2024-02-26 11:41:42 +01:00
|
|
|
FailParams, TcStateAccepted, VerificationReportingProvider, VerificationToken,
|
2024-02-07 18:10:47 +01:00
|
|
|
};
|
2024-02-12 15:51:37 +01:00
|
|
|
use satrs::pus::{
|
2024-02-07 18:10:47 +01:00
|
|
|
EcssTcAndToken, EcssTcInMemConverter, EcssTcInSharedStoreConverter, EcssTcInVecConverter,
|
2024-02-26 11:41:42 +01:00
|
|
|
MpscTcReceiver, PusPacketHandlerResult, PusPacketHandlingError, PusServiceHelper,
|
|
|
|
TmAsVecSenderWithId, TmInSharedPoolSenderWithId,
|
2023-07-06 00:49:18 +02:00
|
|
|
};
|
2024-02-20 14:33:21 +01:00
|
|
|
use satrs::request::TargetAndApidId;
|
|
|
|
use satrs::spacepackets::ecss::tc::PusTcReader;
|
2024-02-12 15:51:37 +01:00
|
|
|
use satrs::spacepackets::ecss::{hk, PusPacket};
|
|
|
|
use satrs::tmtc::tm_helper::SharedTmPool;
|
2024-02-20 14:33:21 +01:00
|
|
|
use satrs::{ChannelId, TargetId};
|
2024-02-07 18:10:47 +01:00
|
|
|
use satrs_example::config::{hk_err, tmtc_err, TcReceiverId, TmSenderId, PUS_APID};
|
2024-02-20 14:33:21 +01:00
|
|
|
use std::sync::mpsc::{self};
|
|
|
|
|
|
|
|
use crate::requests::GenericRequestRouter;
|
|
|
|
|
|
|
|
use super::GenericRoutingErrorHandler;
|
|
|
|
|
|
|
|
#[derive(Default)]
|
|
|
|
pub struct ExampleHkRequestConverter {}
|
|
|
|
|
|
|
|
impl PusHkToRequestConverter for ExampleHkRequestConverter {
|
|
|
|
type Error = PusPacketHandlingError;
|
|
|
|
|
|
|
|
fn convert(
|
|
|
|
&mut self,
|
|
|
|
token: VerificationToken<TcStateAccepted>,
|
|
|
|
tc: &PusTcReader,
|
|
|
|
time_stamp: &[u8],
|
|
|
|
verif_reporter: &impl VerificationReportingProvider,
|
|
|
|
) -> Result<(TargetId, HkRequest), Self::Error> {
|
|
|
|
let user_data = tc.user_data();
|
|
|
|
if user_data.is_empty() {
|
|
|
|
let user_data_len = user_data.len() as u32;
|
|
|
|
let user_data_len_raw = user_data_len.to_be_bytes();
|
|
|
|
verif_reporter
|
|
|
|
.start_failure(
|
|
|
|
token,
|
|
|
|
FailParams::new(
|
|
|
|
time_stamp,
|
|
|
|
&tmtc_err::NOT_ENOUGH_APP_DATA,
|
|
|
|
&user_data_len_raw,
|
|
|
|
),
|
|
|
|
)
|
|
|
|
.expect("Sending start failure TM failed");
|
|
|
|
return Err(PusPacketHandlingError::NotEnoughAppData {
|
|
|
|
expected: 4,
|
|
|
|
found: 0,
|
|
|
|
});
|
|
|
|
}
|
|
|
|
if user_data.len() < 8 {
|
|
|
|
let err = if user_data.len() < 4 {
|
|
|
|
&hk_err::TARGET_ID_MISSING
|
|
|
|
} else {
|
|
|
|
&hk_err::UNIQUE_ID_MISSING
|
|
|
|
};
|
|
|
|
let user_data_len = user_data.len() as u32;
|
|
|
|
let user_data_len_raw = user_data_len.to_be_bytes();
|
|
|
|
verif_reporter
|
|
|
|
.start_failure(token, FailParams::new(time_stamp, err, &user_data_len_raw))
|
|
|
|
.expect("Sending start failure TM failed");
|
|
|
|
return Err(PusPacketHandlingError::NotEnoughAppData {
|
|
|
|
expected: 8,
|
|
|
|
found: 4,
|
|
|
|
});
|
|
|
|
}
|
|
|
|
let subservice = tc.subservice();
|
|
|
|
let target_id = TargetAndApidId::from_pus_tc(tc).expect("invalid tc format");
|
|
|
|
let unique_id = u32::from_be_bytes(tc.user_data()[4..8].try_into().unwrap());
|
|
|
|
|
|
|
|
let standard_subservice = hk::Subservice::try_from(subservice);
|
|
|
|
if standard_subservice.is_err() {
|
|
|
|
verif_reporter
|
|
|
|
.start_failure(
|
|
|
|
token,
|
|
|
|
FailParams::new(time_stamp, &tmtc_err::INVALID_PUS_SUBSERVICE, &[subservice]),
|
|
|
|
)
|
|
|
|
.expect("Sending start failure TM failed");
|
|
|
|
return Err(PusPacketHandlingError::InvalidSubservice(subservice));
|
|
|
|
}
|
|
|
|
Ok((
|
|
|
|
target_id.into(),
|
|
|
|
match standard_subservice.unwrap() {
|
|
|
|
hk::Subservice::TcEnableHkGeneration | hk::Subservice::TcEnableDiagGeneration => {
|
|
|
|
HkRequest::Enable(unique_id)
|
|
|
|
}
|
|
|
|
hk::Subservice::TcDisableHkGeneration | hk::Subservice::TcDisableDiagGeneration => {
|
|
|
|
HkRequest::Disable(unique_id)
|
|
|
|
}
|
|
|
|
hk::Subservice::TcReportHkReportStructures => todo!(),
|
|
|
|
hk::Subservice::TmHkPacket => todo!(),
|
|
|
|
hk::Subservice::TcGenerateOneShotHk | hk::Subservice::TcGenerateOneShotDiag => {
|
|
|
|
HkRequest::OneShot(unique_id)
|
|
|
|
}
|
|
|
|
hk::Subservice::TcModifyDiagCollectionInterval
|
|
|
|
| hk::Subservice::TcModifyHkCollectionInterval => {
|
|
|
|
if user_data.len() < 12 {
|
|
|
|
verif_reporter
|
|
|
|
.start_failure(
|
|
|
|
token,
|
|
|
|
FailParams::new_no_fail_data(
|
|
|
|
time_stamp,
|
|
|
|
&tmtc_err::NOT_ENOUGH_APP_DATA,
|
|
|
|
),
|
|
|
|
)
|
|
|
|
.expect("Sending start failure TM failed");
|
|
|
|
return Err(PusPacketHandlingError::NotEnoughAppData {
|
|
|
|
expected: 12,
|
|
|
|
found: user_data.len(),
|
|
|
|
});
|
|
|
|
}
|
|
|
|
HkRequest::ModifyCollectionInterval(
|
|
|
|
unique_id,
|
|
|
|
CollectionIntervalFactor::from_be_bytes(
|
|
|
|
user_data[8..12].try_into().unwrap(),
|
|
|
|
),
|
|
|
|
)
|
|
|
|
}
|
|
|
|
_ => {
|
|
|
|
verif_reporter
|
|
|
|
.start_failure(
|
|
|
|
token,
|
|
|
|
FailParams::new(
|
|
|
|
time_stamp,
|
|
|
|
&tmtc_err::PUS_SUBSERVICE_NOT_IMPLEMENTED,
|
|
|
|
&[subservice],
|
|
|
|
),
|
|
|
|
)
|
|
|
|
.expect("Sending start failure TM failed");
|
|
|
|
return Err(PusPacketHandlingError::InvalidSubservice(subservice));
|
|
|
|
}
|
|
|
|
},
|
|
|
|
))
|
|
|
|
}
|
|
|
|
}
|
2024-02-07 18:10:47 +01:00
|
|
|
|
|
|
|
pub fn create_hk_service_static(
|
2024-02-08 17:42:36 +01:00
|
|
|
shared_tm_store: SharedTmPool,
|
2024-02-26 11:41:42 +01:00
|
|
|
tm_funnel_tx: mpsc::SyncSender<StoreAddr>,
|
|
|
|
verif_reporter: VerificationReporterWithSharedPoolMpscBoundedSender,
|
2024-02-07 18:10:47 +01:00
|
|
|
tc_pool: SharedStaticMemoryPool,
|
|
|
|
pus_hk_rx: mpsc::Receiver<EcssTcAndToken>,
|
2024-02-20 14:33:21 +01:00
|
|
|
request_router: GenericRequestRouter,
|
2024-02-26 11:41:42 +01:00
|
|
|
) -> Pus3Wrapper<EcssTcInSharedStoreConverter, VerificationReporterWithSharedPoolMpscBoundedSender>
|
|
|
|
{
|
|
|
|
let hk_srv_tm_sender = TmInSharedPoolSenderWithId::new(
|
2024-02-07 18:10:47 +01:00
|
|
|
TmSenderId::PusHk as ChannelId,
|
|
|
|
"PUS_3_TM_SENDER",
|
|
|
|
shared_tm_store.clone(),
|
|
|
|
tm_funnel_tx.clone(),
|
|
|
|
);
|
|
|
|
let hk_srv_receiver =
|
|
|
|
MpscTcReceiver::new(TcReceiverId::PusHk as ChannelId, "PUS_8_TC_RECV", pus_hk_rx);
|
|
|
|
let pus_3_handler = PusService3HkHandler::new(
|
2024-02-20 14:33:21 +01:00
|
|
|
PusServiceHelper::new(
|
|
|
|
Box::new(hk_srv_receiver),
|
|
|
|
Box::new(hk_srv_tm_sender),
|
|
|
|
PUS_APID,
|
|
|
|
verif_reporter.clone(),
|
|
|
|
EcssTcInSharedStoreConverter::new(tc_pool, 2048),
|
|
|
|
),
|
|
|
|
ExampleHkRequestConverter::default(),
|
|
|
|
request_router,
|
|
|
|
GenericRoutingErrorHandler::default(),
|
2024-02-07 18:10:47 +01:00
|
|
|
);
|
|
|
|
Pus3Wrapper { pus_3_handler }
|
|
|
|
}
|
|
|
|
|
|
|
|
pub fn create_hk_service_dynamic(
|
|
|
|
tm_funnel_tx: mpsc::Sender<Vec<u8>>,
|
2024-02-26 11:41:42 +01:00
|
|
|
verif_reporter: VerificationReporterWithVecMpscSender,
|
2024-02-07 18:10:47 +01:00
|
|
|
pus_hk_rx: mpsc::Receiver<EcssTcAndToken>,
|
2024-02-20 14:33:21 +01:00
|
|
|
request_router: GenericRequestRouter,
|
2024-02-26 11:41:42 +01:00
|
|
|
) -> Pus3Wrapper<EcssTcInVecConverter, VerificationReporterWithVecMpscSender> {
|
|
|
|
let hk_srv_tm_sender = TmAsVecSenderWithId::new(
|
2024-02-07 18:10:47 +01:00
|
|
|
TmSenderId::PusHk as ChannelId,
|
|
|
|
"PUS_3_TM_SENDER",
|
|
|
|
tm_funnel_tx.clone(),
|
|
|
|
);
|
|
|
|
let hk_srv_receiver =
|
|
|
|
MpscTcReceiver::new(TcReceiverId::PusHk as ChannelId, "PUS_8_TC_RECV", pus_hk_rx);
|
|
|
|
let pus_3_handler = PusService3HkHandler::new(
|
2024-02-20 14:33:21 +01:00
|
|
|
PusServiceHelper::new(
|
|
|
|
Box::new(hk_srv_receiver),
|
|
|
|
Box::new(hk_srv_tm_sender),
|
|
|
|
PUS_APID,
|
|
|
|
verif_reporter.clone(),
|
|
|
|
EcssTcInVecConverter::default(),
|
|
|
|
),
|
|
|
|
ExampleHkRequestConverter::default(),
|
|
|
|
request_router,
|
|
|
|
GenericRoutingErrorHandler::default(),
|
2024-02-07 18:10:47 +01:00
|
|
|
);
|
|
|
|
Pus3Wrapper { pus_3_handler }
|
|
|
|
}
|
2023-07-05 21:10:45 +02:00
|
|
|
|
2024-02-26 11:41:42 +01:00
|
|
|
pub struct Pus3Wrapper<
|
|
|
|
TcInMemConverter: EcssTcInMemConverter,
|
|
|
|
VerificationReporter: VerificationReportingProvider,
|
|
|
|
> {
|
2024-02-20 14:33:21 +01:00
|
|
|
pub(crate) pus_3_handler: PusService3HkHandler<
|
|
|
|
TcInMemConverter,
|
2024-02-26 11:41:42 +01:00
|
|
|
VerificationReporter,
|
2024-02-20 14:33:21 +01:00
|
|
|
ExampleHkRequestConverter,
|
|
|
|
GenericRequestRouter,
|
|
|
|
GenericRoutingErrorHandler<3>,
|
|
|
|
>,
|
2023-07-06 00:49:18 +02:00
|
|
|
}
|
|
|
|
|
2024-02-26 11:41:42 +01:00
|
|
|
impl<
|
|
|
|
TcInMemConverter: EcssTcInMemConverter,
|
|
|
|
VerificationReporter: VerificationReportingProvider,
|
|
|
|
> Pus3Wrapper<TcInMemConverter, VerificationReporter>
|
|
|
|
{
|
2023-07-06 00:49:18 +02:00
|
|
|
pub fn handle_next_packet(&mut self) -> bool {
|
2024-01-30 01:18:48 +01:00
|
|
|
match self.pus_3_handler.handle_one_tc() {
|
2023-07-06 00:49:18 +02:00
|
|
|
Ok(result) => match result {
|
|
|
|
PusPacketHandlerResult::RequestHandled => {}
|
|
|
|
PusPacketHandlerResult::RequestHandledPartialSuccess(e) => {
|
|
|
|
warn!("PUS 3 partial packet handling success: {e:?}")
|
|
|
|
}
|
|
|
|
PusPacketHandlerResult::CustomSubservice(invalid, _) => {
|
|
|
|
warn!("PUS 3 invalid subservice {invalid}");
|
|
|
|
}
|
|
|
|
PusPacketHandlerResult::SubserviceNotImplemented(subservice, _) => {
|
|
|
|
warn!("PUS 3 subservice {subservice} not implemented");
|
|
|
|
}
|
|
|
|
PusPacketHandlerResult::Empty => {
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
},
|
|
|
|
Err(error) => {
|
|
|
|
error!("PUS packet handling error: {error:?}")
|
|
|
|
}
|
|
|
|
}
|
|
|
|
false
|
|
|
|
}
|
|
|
|
}
|