2023-07-06 00:49:18 +02:00
|
|
|
use crate::requests::{Request, RequestWithToken};
|
|
|
|
use log::{error, warn};
|
|
|
|
use satrs_core::hk::{CollectionIntervalFactor, HkRequest};
|
2024-01-30 01:18:48 +01:00
|
|
|
use satrs_core::pus::verification::{FailParams, StdVerifReporterWithSender};
|
2023-07-06 00:49:18 +02:00
|
|
|
use satrs_core::pus::{
|
2024-01-31 12:09:55 +01:00
|
|
|
EcssTcInMemConverter, EcssTcInStoreConverter, EcssTcReceiver, EcssTmSender,
|
|
|
|
PusPacketHandlerResult, PusPacketHandlingError, PusServiceBase, PusServiceHandler,
|
2023-07-06 00:49:18 +02:00
|
|
|
};
|
|
|
|
use satrs_core::spacepackets::ecss::{hk, PusPacket};
|
2023-08-15 21:07:15 +02:00
|
|
|
use satrs_example::{hk_err, tmtc_err, TargetIdWithApid};
|
2023-07-06 00:49:18 +02:00
|
|
|
use std::collections::HashMap;
|
2023-07-10 00:29:31 +02:00
|
|
|
use std::sync::mpsc::Sender;
|
2023-07-05 21:10:45 +02:00
|
|
|
|
2024-01-31 12:09:55 +01:00
|
|
|
pub struct PusService3HkHandler<TcInMemConverter: EcssTcInMemConverter> {
|
|
|
|
psb: PusServiceHandler<TcInMemConverter>,
|
2023-08-15 08:49:54 +02:00
|
|
|
request_handlers: HashMap<TargetIdWithApid, Sender<RequestWithToken>>,
|
2023-07-06 00:49:18 +02:00
|
|
|
}
|
|
|
|
|
2024-01-31 12:09:55 +01:00
|
|
|
impl<TcInMemConverter: EcssTcInMemConverter> PusService3HkHandler<TcInMemConverter> {
|
2023-07-06 00:49:18 +02:00
|
|
|
pub fn new(
|
2023-07-10 00:29:31 +02:00
|
|
|
tc_receiver: Box<dyn EcssTcReceiver>,
|
2023-07-09 17:04:18 +02:00
|
|
|
tm_sender: Box<dyn EcssTmSender>,
|
2023-07-06 00:49:18 +02:00
|
|
|
tm_apid: u16,
|
|
|
|
verification_handler: StdVerifReporterWithSender,
|
2024-01-31 12:09:55 +01:00
|
|
|
tc_in_mem_converter: TcInMemConverter,
|
2023-08-15 08:49:54 +02:00
|
|
|
request_handlers: HashMap<TargetIdWithApid, Sender<RequestWithToken>>,
|
2023-07-06 00:49:18 +02:00
|
|
|
) -> Self {
|
|
|
|
Self {
|
2024-01-31 11:40:01 +01:00
|
|
|
psb: PusServiceHandler::new(
|
2023-07-10 00:29:31 +02:00
|
|
|
tc_receiver,
|
|
|
|
tm_sender,
|
|
|
|
tm_apid,
|
|
|
|
verification_handler,
|
2024-01-31 12:09:55 +01:00
|
|
|
tc_in_mem_converter,
|
2023-07-10 00:29:31 +02:00
|
|
|
),
|
2023-07-06 00:49:18 +02:00
|
|
|
request_handlers,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2024-01-30 01:18:48 +01:00
|
|
|
fn handle_one_tc(&mut self) -> Result<PusPacketHandlerResult, PusPacketHandlingError> {
|
2024-01-30 09:59:45 +01:00
|
|
|
let possible_packet = self.psb.retrieve_and_accept_next_packet()?;
|
2024-01-30 01:18:48 +01:00
|
|
|
if possible_packet.is_none() {
|
|
|
|
return Ok(PusPacketHandlerResult::Empty);
|
|
|
|
}
|
2024-01-31 01:32:03 +01:00
|
|
|
let ecss_tc_and_token = possible_packet.unwrap();
|
2024-01-31 12:09:55 +01:00
|
|
|
let tc = self
|
|
|
|
.psb
|
|
|
|
.tc_in_mem_converter
|
|
|
|
.convert_ecss_tc_in_memory_to_reader(&ecss_tc_and_token)?;
|
2023-07-06 00:49:18 +02:00
|
|
|
let subservice = tc.subservice();
|
|
|
|
let mut partial_error = None;
|
2024-01-31 12:09:55 +01:00
|
|
|
let time_stamp = PusServiceBase::get_current_timestamp(&mut partial_error);
|
2023-07-11 00:28:28 +02:00
|
|
|
let user_data = tc.user_data();
|
|
|
|
if user_data.is_empty() {
|
2023-07-06 00:49:18 +02:00
|
|
|
self.psb
|
2024-01-31 12:09:55 +01:00
|
|
|
.common
|
2023-07-06 00:49:18 +02:00
|
|
|
.verification_handler
|
|
|
|
.borrow_mut()
|
|
|
|
.start_failure(
|
2024-01-31 01:32:03 +01:00
|
|
|
ecss_tc_and_token.token,
|
2023-07-06 00:49:18 +02:00
|
|
|
FailParams::new(Some(&time_stamp), &tmtc_err::NOT_ENOUGH_APP_DATA, None),
|
|
|
|
)
|
|
|
|
.expect("Sending start failure TM failed");
|
|
|
|
return Err(PusPacketHandlingError::NotEnoughAppData(
|
|
|
|
"Expected at least 8 bytes of app data".into(),
|
|
|
|
));
|
|
|
|
}
|
|
|
|
if user_data.len() < 8 {
|
|
|
|
let err = if user_data.len() < 4 {
|
|
|
|
&hk_err::TARGET_ID_MISSING
|
|
|
|
} else {
|
|
|
|
&hk_err::UNIQUE_ID_MISSING
|
|
|
|
};
|
|
|
|
self.psb
|
2024-01-31 12:09:55 +01:00
|
|
|
.common
|
2023-07-06 00:49:18 +02:00
|
|
|
.verification_handler
|
|
|
|
.borrow_mut()
|
2024-01-31 01:32:03 +01:00
|
|
|
.start_failure(
|
|
|
|
ecss_tc_and_token.token,
|
|
|
|
FailParams::new(Some(&time_stamp), err, None),
|
|
|
|
)
|
2023-07-06 00:49:18 +02:00
|
|
|
.expect("Sending start failure TM failed");
|
|
|
|
return Err(PusPacketHandlingError::NotEnoughAppData(
|
|
|
|
"Expected at least 8 bytes of app data".into(),
|
|
|
|
));
|
|
|
|
}
|
2023-08-15 08:49:54 +02:00
|
|
|
let target_id = TargetIdWithApid::from_tc(&tc).expect("invalid tc format");
|
|
|
|
let unique_id = u32::from_be_bytes(tc.user_data()[0..4].try_into().unwrap());
|
2023-08-15 21:07:15 +02:00
|
|
|
if !self.request_handlers.contains_key(&target_id) {
|
2023-07-06 00:49:18 +02:00
|
|
|
self.psb
|
2024-01-31 12:09:55 +01:00
|
|
|
.common
|
2023-07-06 00:49:18 +02:00
|
|
|
.verification_handler
|
|
|
|
.borrow_mut()
|
|
|
|
.start_failure(
|
2024-01-31 01:32:03 +01:00
|
|
|
ecss_tc_and_token.token,
|
2023-07-06 00:49:18 +02:00
|
|
|
FailParams::new(Some(&time_stamp), &hk_err::UNKNOWN_TARGET_ID, None),
|
|
|
|
)
|
|
|
|
.expect("Sending start failure TM failed");
|
|
|
|
return Err(PusPacketHandlingError::NotEnoughAppData(format!(
|
2023-08-15 08:49:54 +02:00
|
|
|
"Unknown target ID {target_id}"
|
2023-07-06 00:49:18 +02:00
|
|
|
)));
|
|
|
|
}
|
2023-08-15 08:49:54 +02:00
|
|
|
let send_request = |target: TargetIdWithApid, request: HkRequest| {
|
2023-08-15 21:07:15 +02:00
|
|
|
let sender = self.request_handlers.get(&target).unwrap();
|
2023-07-06 00:49:18 +02:00
|
|
|
sender
|
2024-01-31 01:32:03 +01:00
|
|
|
.send(RequestWithToken::new(
|
|
|
|
target,
|
|
|
|
Request::Hk(request),
|
|
|
|
ecss_tc_and_token.token,
|
|
|
|
))
|
2023-07-06 00:49:18 +02:00
|
|
|
.unwrap_or_else(|_| panic!("Sending HK request {request:?} failed"));
|
|
|
|
};
|
|
|
|
if subservice == hk::Subservice::TcEnableHkGeneration as u8 {
|
2023-08-15 21:07:15 +02:00
|
|
|
send_request(target_id, HkRequest::Enable(unique_id));
|
2023-07-06 00:49:18 +02:00
|
|
|
} else if subservice == hk::Subservice::TcDisableHkGeneration as u8 {
|
2023-08-15 21:07:15 +02:00
|
|
|
send_request(target_id, HkRequest::Disable(unique_id));
|
2023-07-06 00:49:18 +02:00
|
|
|
} else if subservice == hk::Subservice::TcGenerateOneShotHk as u8 {
|
2023-08-15 21:07:15 +02:00
|
|
|
send_request(target_id, HkRequest::OneShot(unique_id));
|
2023-07-06 00:49:18 +02:00
|
|
|
} else if subservice == hk::Subservice::TcModifyHkCollectionInterval as u8 {
|
|
|
|
if user_data.len() < 12 {
|
|
|
|
self.psb
|
2024-01-31 12:09:55 +01:00
|
|
|
.common
|
2023-07-06 00:49:18 +02:00
|
|
|
.verification_handler
|
|
|
|
.borrow_mut()
|
|
|
|
.start_failure(
|
2024-01-31 01:32:03 +01:00
|
|
|
ecss_tc_and_token.token,
|
2023-07-06 00:49:18 +02:00
|
|
|
FailParams::new(
|
|
|
|
Some(&time_stamp),
|
|
|
|
&hk_err::COLLECTION_INTERVAL_MISSING,
|
|
|
|
None,
|
|
|
|
),
|
|
|
|
)
|
|
|
|
.expect("Sending start failure TM failed");
|
|
|
|
return Err(PusPacketHandlingError::NotEnoughAppData(
|
|
|
|
"Collection interval missing".into(),
|
|
|
|
));
|
|
|
|
}
|
|
|
|
send_request(
|
2023-08-15 08:49:54 +02:00
|
|
|
target_id,
|
2023-07-06 00:49:18 +02:00
|
|
|
HkRequest::ModifyCollectionInterval(
|
2023-08-15 08:49:54 +02:00
|
|
|
unique_id,
|
2023-07-06 00:49:18 +02:00
|
|
|
CollectionIntervalFactor::from_be_bytes(user_data[8..12].try_into().unwrap()),
|
|
|
|
),
|
|
|
|
);
|
|
|
|
}
|
|
|
|
Ok(PusPacketHandlerResult::RequestHandled)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
pub struct Pus3Wrapper {
|
2024-01-31 12:09:55 +01:00
|
|
|
pub(crate) pus_3_handler: PusService3HkHandler<EcssTcInStoreConverter>,
|
2023-07-06 00:49:18 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
impl Pus3Wrapper {
|
|
|
|
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
|
|
|
|
}
|
|
|
|
}
|