2023-07-05 11:25:23 +02:00
|
|
|
use log::{info, warn};
|
2024-02-12 15:51:37 +01:00
|
|
|
use satrs::params::Params;
|
|
|
|
use satrs::pool::{SharedStaticMemoryPool, StoreAddr};
|
|
|
|
use satrs::pus::test::PusService17TestHandler;
|
2024-02-26 11:41:42 +01:00
|
|
|
use satrs::pus::verification::{FailParams, VerificationReportingProvider};
|
2024-02-20 14:33:21 +01:00
|
|
|
use satrs::pus::verification::{
|
2024-02-26 11:41:42 +01:00
|
|
|
VerificationReporterWithSharedPoolMpscBoundedSender, VerificationReporterWithVecMpscSender,
|
2024-02-20 14:33:21 +01:00
|
|
|
};
|
2024-02-12 15:51:37 +01:00
|
|
|
use satrs::pus::{
|
2024-02-26 11:41:42 +01:00
|
|
|
EcssTcAndToken, EcssTcInMemConverter, EcssTcInVecConverter, MpscTcReceiver,
|
|
|
|
PusPacketHandlerResult, PusServiceHelper, TmAsVecSenderWithId, TmInSharedPoolSenderWithId,
|
2024-02-07 18:10:47 +01:00
|
|
|
};
|
2024-02-12 15:51:37 +01:00
|
|
|
use satrs::spacepackets::ecss::tc::PusTcReader;
|
|
|
|
use satrs::spacepackets::ecss::PusPacket;
|
|
|
|
use satrs::spacepackets::time::cds::TimeProvider;
|
|
|
|
use satrs::spacepackets::time::TimeWriter;
|
|
|
|
use satrs::tmtc::tm_helper::SharedTmPool;
|
|
|
|
use satrs::ChannelId;
|
|
|
|
use satrs::{events::EventU32, pus::EcssTcInSharedStoreConverter};
|
2024-02-07 18:10:47 +01:00
|
|
|
use satrs_example::config::{tmtc_err, TcReceiverId, TmSenderId, PUS_APID, TEST_EVENT};
|
|
|
|
use std::sync::mpsc::{self, Sender};
|
2023-07-03 18:22:08 +02:00
|
|
|
|
2024-02-07 18:10:47 +01:00
|
|
|
pub fn create_test_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,
|
|
|
|
event_sender: mpsc::Sender<(EventU32, Option<Params>)>,
|
|
|
|
pus_test_rx: mpsc::Receiver<EcssTcAndToken>,
|
2024-02-26 11:41:42 +01:00
|
|
|
) -> Service17CustomWrapper<
|
|
|
|
EcssTcInSharedStoreConverter,
|
|
|
|
VerificationReporterWithSharedPoolMpscBoundedSender,
|
|
|
|
> {
|
|
|
|
let test_srv_tm_sender = TmInSharedPoolSenderWithId::new(
|
2024-02-07 18:10:47 +01:00
|
|
|
TmSenderId::PusTest as ChannelId,
|
|
|
|
"PUS_17_TM_SENDER",
|
|
|
|
shared_tm_store.clone(),
|
|
|
|
tm_funnel_tx.clone(),
|
|
|
|
);
|
|
|
|
let test_srv_receiver = MpscTcReceiver::new(
|
|
|
|
TcReceiverId::PusTest as ChannelId,
|
|
|
|
"PUS_17_TC_RECV",
|
|
|
|
pus_test_rx,
|
|
|
|
);
|
|
|
|
let pus17_handler = PusService17TestHandler::new(PusServiceHelper::new(
|
|
|
|
Box::new(test_srv_receiver),
|
|
|
|
Box::new(test_srv_tm_sender),
|
|
|
|
PUS_APID,
|
|
|
|
verif_reporter.clone(),
|
|
|
|
EcssTcInSharedStoreConverter::new(tc_pool, 2048),
|
|
|
|
));
|
|
|
|
Service17CustomWrapper {
|
|
|
|
pus17_handler,
|
|
|
|
test_srv_event_sender: event_sender,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
pub fn create_test_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
|
|
|
event_sender: mpsc::Sender<(EventU32, Option<Params>)>,
|
|
|
|
pus_test_rx: mpsc::Receiver<EcssTcAndToken>,
|
2024-02-26 11:41:42 +01:00
|
|
|
) -> Service17CustomWrapper<EcssTcInVecConverter, VerificationReporterWithVecMpscSender> {
|
|
|
|
let test_srv_tm_sender = TmAsVecSenderWithId::new(
|
2024-02-07 18:10:47 +01:00
|
|
|
TmSenderId::PusTest as ChannelId,
|
|
|
|
"PUS_17_TM_SENDER",
|
|
|
|
tm_funnel_tx.clone(),
|
|
|
|
);
|
|
|
|
let test_srv_receiver = MpscTcReceiver::new(
|
|
|
|
TcReceiverId::PusTest as ChannelId,
|
|
|
|
"PUS_17_TC_RECV",
|
|
|
|
pus_test_rx,
|
|
|
|
);
|
|
|
|
let pus17_handler = PusService17TestHandler::new(PusServiceHelper::new(
|
|
|
|
Box::new(test_srv_receiver),
|
|
|
|
Box::new(test_srv_tm_sender),
|
|
|
|
PUS_APID,
|
|
|
|
verif_reporter.clone(),
|
|
|
|
EcssTcInVecConverter::default(),
|
|
|
|
));
|
|
|
|
Service17CustomWrapper {
|
|
|
|
pus17_handler,
|
|
|
|
test_srv_event_sender: event_sender,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2024-02-26 11:41:42 +01:00
|
|
|
pub struct Service17CustomWrapper<
|
|
|
|
TcInMemConverter: EcssTcInMemConverter,
|
|
|
|
VerificationReporter: VerificationReportingProvider,
|
|
|
|
> {
|
|
|
|
pub pus17_handler: PusService17TestHandler<TcInMemConverter, VerificationReporter>,
|
2023-07-04 21:13:26 +02:00
|
|
|
pub test_srv_event_sender: Sender<(EventU32, Option<Params>)>,
|
2023-07-03 18:22:08 +02:00
|
|
|
}
|
|
|
|
|
2024-02-26 11:41:42 +01:00
|
|
|
impl<
|
|
|
|
TcInMemConverter: EcssTcInMemConverter,
|
|
|
|
VerificationReporter: VerificationReportingProvider,
|
|
|
|
> Service17CustomWrapper<TcInMemConverter, VerificationReporter>
|
|
|
|
{
|
2023-07-05 15:12:03 +02:00
|
|
|
pub fn handle_next_packet(&mut self) -> bool {
|
2024-01-30 01:18:48 +01:00
|
|
|
let res = self.pus17_handler.handle_one_tc();
|
2023-07-04 21:13:26 +02:00
|
|
|
if res.is_err() {
|
|
|
|
warn!("PUS17 handler failed with error {:?}", res.unwrap_err());
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
match res.unwrap() {
|
|
|
|
PusPacketHandlerResult::RequestHandled => {
|
|
|
|
info!("Received PUS ping command TC[17,1]");
|
|
|
|
info!("Sent ping reply PUS TM[17,2]");
|
|
|
|
}
|
2023-07-04 22:26:41 +02:00
|
|
|
PusPacketHandlerResult::RequestHandledPartialSuccess(partial_err) => {
|
|
|
|
warn!(
|
|
|
|
"Handled PUS ping command with partial success: {:?}",
|
|
|
|
partial_err
|
|
|
|
);
|
|
|
|
}
|
2023-07-05 14:25:51 +02:00
|
|
|
PusPacketHandlerResult::SubserviceNotImplemented(subservice, _) => {
|
|
|
|
warn!("PUS17: Subservice {subservice} not implemented")
|
|
|
|
}
|
2023-07-05 11:58:43 +02:00
|
|
|
PusPacketHandlerResult::CustomSubservice(subservice, token) => {
|
2024-02-03 13:41:51 +01:00
|
|
|
let (tc, _) = PusTcReader::new(
|
|
|
|
self.pus17_handler
|
|
|
|
.service_helper
|
|
|
|
.tc_in_mem_converter
|
|
|
|
.tc_slice_raw(),
|
|
|
|
)
|
|
|
|
.unwrap();
|
2023-07-04 21:13:26 +02:00
|
|
|
let time_stamper = TimeProvider::from_now_with_u16_days().unwrap();
|
|
|
|
let mut stamp_buf: [u8; 7] = [0; 7];
|
|
|
|
time_stamper.write_to_bytes(&mut stamp_buf).unwrap();
|
2023-07-05 11:58:43 +02:00
|
|
|
if subservice == 128 {
|
2023-07-04 21:13:26 +02:00
|
|
|
info!("Generating test event");
|
|
|
|
self.test_srv_event_sender
|
|
|
|
.send((TEST_EVENT.into(), None))
|
|
|
|
.expect("Sending test event failed");
|
2024-01-31 12:09:55 +01:00
|
|
|
let start_token = self
|
|
|
|
.pus17_handler
|
2024-02-03 13:41:51 +01:00
|
|
|
.service_helper
|
2024-01-31 12:09:55 +01:00
|
|
|
.common
|
2023-07-05 21:08:04 +02:00
|
|
|
.verification_handler
|
2024-02-20 14:33:21 +01:00
|
|
|
.start_success(token, &stamp_buf)
|
2023-07-04 21:13:26 +02:00
|
|
|
.expect("Error sending start success");
|
2024-01-31 12:09:55 +01:00
|
|
|
self.pus17_handler
|
2024-02-03 13:41:51 +01:00
|
|
|
.service_helper
|
2024-01-31 12:09:55 +01:00
|
|
|
.common
|
2023-07-05 21:08:04 +02:00
|
|
|
.verification_handler
|
2024-02-20 14:33:21 +01:00
|
|
|
.completion_success(start_token, &stamp_buf)
|
2023-07-04 21:13:26 +02:00
|
|
|
.expect("Error sending completion success");
|
|
|
|
} else {
|
|
|
|
let fail_data = [tc.subservice()];
|
|
|
|
self.pus17_handler
|
2024-02-03 13:41:51 +01:00
|
|
|
.service_helper
|
2024-01-31 12:09:55 +01:00
|
|
|
.common
|
2023-07-05 21:08:04 +02:00
|
|
|
.verification_handler
|
|
|
|
.start_failure(
|
2023-07-04 21:13:26 +02:00
|
|
|
token,
|
2023-07-05 21:08:04 +02:00
|
|
|
FailParams::new(
|
2024-02-20 14:33:21 +01:00
|
|
|
&stamp_buf,
|
2023-07-05 21:08:04 +02:00
|
|
|
&tmtc_err::INVALID_PUS_SUBSERVICE,
|
2024-02-20 14:33:21 +01:00
|
|
|
&fail_data,
|
2023-07-05 21:08:04 +02:00
|
|
|
),
|
2023-07-04 21:13:26 +02:00
|
|
|
)
|
|
|
|
.expect("Sending start failure verification failed");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
PusPacketHandlerResult::Empty => {
|
2023-07-05 15:15:19 +02:00
|
|
|
return true;
|
2023-07-04 21:13:26 +02:00
|
|
|
}
|
|
|
|
}
|
2023-07-05 15:15:19 +02:00
|
|
|
false
|
2023-07-04 21:13:26 +02:00
|
|
|
}
|
2023-07-04 18:51:54 +02:00
|
|
|
}
|