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

Merge remote-tracking branch 'origin/main' into tricky-pus-abstraction-changes
All checks were successful
Rust/sat-rs/pipeline/head This commit looks good
Details

Browse Source
This commit is contained in:
Robin Müller
2024-01-31 12:09:55 +01:00
parent 8bb13efe80 a09af65396
commit e2086391bc
17 changed files with 232 additions and 164 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@ -1,47 +1,44 @@
use crate::requests::{ActionRequest, Request, RequestWithToken};
use log::{error, warn};
use satrs_core::pool::SharedPool;
use satrs_core::pus::verification::{
FailParams, StdVerifReporterWithSender, TcStateAccepted, VerificationToken,
FailParams, TcStateAccepted, VerificationReporterWithSender, VerificationToken,
};
use satrs_core::pus::{
EcssTcReceiver, EcssTmSender, PusPacketHandlerResult, PusPacketHandlingError, PusServiceHandler,
EcssTcInMemConverter, EcssTcInStoreConverter, EcssTcReceiver, EcssTmSender,
PusPacketHandlerResult, PusPacketHandlingError, PusServiceBase, PusServiceHandler,
};
use satrs_core::spacepackets::ecss::tc::PusTcReader;
use satrs_core::spacepackets::ecss::PusPacket;
use satrs_core::tmtc::TargetId;
use satrs_example::tmtc_err;
use satrs_example::{tmtc_err, TargetIdWithApid};
use std::collections::HashMap;
use std::sync::mpsc::Sender;
pub struct PusService8ActionHandler {
psb: PusServiceHandler,
request_handlers: HashMap<TargetId, Sender<RequestWithToken>>,
pub struct PusService8ActionHandler<TcInMemConverter: EcssTcInMemConverter> {
psb: PusServiceHandler<TcInMemConverter>,
request_handlers: HashMap<TargetIdWithApid, Sender<RequestWithToken>>,
}
impl PusService8ActionHandler {
impl<TcInMemConverter: EcssTcInMemConverter> PusService8ActionHandler<TcInMemConverter> {
pub fn new(
tc_receiver: Box<dyn EcssTcReceiver>,
shared_tc_pool: SharedPool,
tm_sender: Box<dyn EcssTmSender>,
tm_apid: u16,
verification_handler: VerificationReporterWithSender,
request_handlers: HashMap<TargetId, Sender<RequestWithToken>>,
tc_in_mem_converter: TcInMemConverter,
request_handlers: HashMap<TargetIdWithApid, Sender<RequestWithToken>>,
) -> Self {
Self {
psb: PusServiceHandler::new(
tc_receiver,
shared_tc_pool,
tm_sender,
tm_apid,
verification_handler,
tc_in_mem_converter,
),
request_handlers,
}
}
}
impl PusService8ActionHandler {
fn handle_action_request_with_id(
&self,
token: VerificationToken<TcStateAccepted>,
@ -51,6 +48,7 @@ impl PusService8ActionHandler {
let user_data = tc.user_data();
if user_data.len() < 8 {
self.psb
.common
.verification_handler
.borrow_mut()
.start_failure(
@ -62,7 +60,8 @@ impl PusService8ActionHandler {
"Expected at least 4 bytes".into(),
));
}
let target_id = u32::from_be_bytes(user_data[0..4].try_into().unwrap());
//let target_id = u32::from_be_bytes(user_data[0..4].try_into().unwrap());
let target_id = TargetIdWithApid::from_tc(tc).unwrap();
let action_id = u32::from_be_bytes(user_data[4..8].try_into().unwrap());
if let Some(sender) = self.request_handlers.get(&target_id) {
sender
@ -77,8 +76,9 @@ impl PusService8ActionHandler {
.expect("Forwarding action request failed");
} else {
let mut fail_data: [u8; 4] = [0; 4];
fail_data.copy_from_slice(&target_id.to_be_bytes());
fail_data.copy_from_slice(&target_id.target.to_be_bytes());
self.psb
.common
.verification_handler
.borrow_mut()
.start_failure(
@ -104,11 +104,12 @@ impl PusService8ActionHandler {
}
let ecss_tc_and_token = possible_packet.unwrap();
self.psb
.convert_possible_packet_to_tc_buf(&ecss_tc_and_token)?;
let (tc, _) = PusTcReader::new(&self.psb.pus_buf).unwrap();
.tc_in_mem_converter
.cache_ecss_tc_in_memory(&ecss_tc_and_token)?;
let tc = PusTcReader::new(self.psb.tc_in_mem_converter.tc_slice_raw())?.0;
let subservice = tc.subservice();
let mut partial_error = None;
let time_stamp = self.psb.get_current_timestamp(&mut partial_error);
let time_stamp = PusServiceBase::get_current_timestamp(&mut partial_error);
match subservice {
128 => {
self.handle_action_request_with_id(ecss_tc_and_token.token, &tc, &time_stamp)?;
@ -116,6 +117,7 @@ impl PusService8ActionHandler {
_ => {
let fail_data = [subservice];
self.psb
.common
.verification_handler
.get_mut()
.start_failure(
@ -140,7 +142,7 @@ impl PusService8ActionHandler {
}
pub struct Pus8Wrapper {
pub(crate) pus_8_handler: PusService8ActionHandler,
pub(crate) pus_8_handler: PusService8ActionHandler<EcssTcInStoreConverter>,
}
impl Pus8Wrapper {

4
satrs-example/src/pus/event.rs
View File

@ -1,9 +1,9 @@
use log::{error, warn};
use satrs_core::pus::event_srv::PusService5EventHandler;
use satrs_core::pus::PusPacketHandlerResult;
use satrs_core::pus::{EcssTcInStoreConverter, PusPacketHandlerResult};
pub struct Pus5Wrapper {
pub pus_5_handler: PusService5EventHandler,
pub pus_5_handler: PusService5EventHandler<EcssTcInStoreConverter>,
}
impl Pus5Wrapper {

74
satrs-example/src/pus/hk.rs
View File

@ -1,39 +1,37 @@
use crate::requests::{Request, RequestWithToken};
use log::{error, warn};
use satrs_core::hk::{CollectionIntervalFactor, HkRequest};
use satrs_core::pool::SharedPool;
use satrs_core::pus::verification::{FailParams, StdVerifReporterWithSender};
use satrs_core::pus::{
EcssTcReceiver, EcssTmSender, PusPacketHandlerResult, PusPacketHandlingError, PusServiceHandler,
EcssTcInMemConverter, EcssTcInStoreConverter, EcssTcReceiver, EcssTmSender,
PusPacketHandlerResult, PusPacketHandlingError, PusServiceBase, PusServiceHandler,
};
use satrs_core::spacepackets::ecss::tc::PusTcReader;
use satrs_core::spacepackets::ecss::{hk, PusPacket};
use satrs_core::tmtc::{AddressableId, TargetId};
use satrs_example::{hk_err, tmtc_err};
use satrs_example::{hk_err, tmtc_err, TargetIdWithApid};
use std::collections::HashMap;
use std::sync::mpsc::Sender;
pub struct PusService3HkHandler {
psb: PusServiceHandler,
request_handlers: HashMap<TargetId, Sender<RequestWithToken>>,
pub struct PusService3HkHandler<TcInMemConverter: EcssTcInMemConverter> {
psb: PusServiceHandler<TcInMemConverter>,
request_handlers: HashMap<TargetIdWithApid, Sender<RequestWithToken>>,
}
impl PusService3HkHandler {
impl<TcInMemConverter: EcssTcInMemConverter> PusService3HkHandler<TcInMemConverter> {
pub fn new(
tc_receiver: Box<dyn EcssTcReceiver>,
shared_tc_pool: SharedPool,
tm_sender: Box<dyn EcssTmSender>,
tm_apid: u16,
verification_handler: StdVerifReporterWithSender,
request_handlers: HashMap<TargetId, Sender<RequestWithToken>>,
tc_in_mem_converter: TcInMemConverter,
request_handlers: HashMap<TargetIdWithApid, Sender<RequestWithToken>>,
) -> Self {
Self {
psb: PusServiceHandler::new(
tc_receiver,
shared_tc_pool,
tm_sender,
tm_apid,
verification_handler,
tc_in_mem_converter,
),
request_handlers,
}
@ -45,15 +43,17 @@ impl PusService3HkHandler {
return Ok(PusPacketHandlerResult::Empty);
}
let ecss_tc_and_token = possible_packet.unwrap();
self.psb
.convert_possible_packet_to_tc_buf(&ecss_tc_and_token)?;
let (tc, _) = PusTcReader::new(&self.psb.pus_buf).unwrap();
let tc = self
.psb
.tc_in_mem_converter
.convert_ecss_tc_in_memory_to_reader(&ecss_tc_and_token)?;
let subservice = tc.subservice();
let mut partial_error = None;
let time_stamp = self.psb.get_current_timestamp(&mut partial_error);
let time_stamp = PusServiceBase::get_current_timestamp(&mut partial_error);
let user_data = tc.user_data();
if user_data.is_empty() {
self.psb
.common
.verification_handler
.borrow_mut()
.start_failure(
@ -72,6 +72,7 @@ impl PusService3HkHandler {
&hk_err::UNIQUE_ID_MISSING
};
self.psb
.common
.verification_handler
.borrow_mut()
.start_failure(
@ -83,12 +84,11 @@ impl PusService3HkHandler {
"Expected at least 8 bytes of app data".into(),
));
}
let addressable_id = AddressableId::from_raw_be(user_data).unwrap();
if !self
.request_handlers
.contains_key(&addressable_id.target_id)
{
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());
if !self.request_handlers.contains_key(&target_id) {
self.psb
.common
.verification_handler
.borrow_mut()
.start_failure(
@ -96,16 +96,12 @@ impl PusService3HkHandler {
FailParams::new(Some(&time_stamp), &hk_err::UNKNOWN_TARGET_ID, None),
)
.expect("Sending start failure TM failed");
let tgt_id = addressable_id.target_id;
return Err(PusPacketHandlingError::NotEnoughAppData(format!(
"Unknown target ID {tgt_id}"
"Unknown target ID {target_id}"
)));
}
let send_request = |target: TargetId, request: HkRequest| {
let sender = self
.request_handlers
.get(&addressable_id.target_id)
.unwrap();
let send_request = |target: TargetIdWithApid, request: HkRequest| {
let sender = self.request_handlers.get(&target).unwrap();
sender
.send(RequestWithToken::new(
target,
@ -115,23 +111,15 @@ impl PusService3HkHandler {
.unwrap_or_else(|_| panic!("Sending HK request {request:?} failed"));
};
if subservice == hk::Subservice::TcEnableHkGeneration as u8 {
send_request(
addressable_id.target_id,
HkRequest::Enable(addressable_id.unique_id),
);
send_request(target_id, HkRequest::Enable(unique_id));
} else if subservice == hk::Subservice::TcDisableHkGeneration as u8 {
send_request(
addressable_id.target_id,
HkRequest::Disable(addressable_id.unique_id),
);
send_request(target_id, HkRequest::Disable(unique_id));
} else if subservice == hk::Subservice::TcGenerateOneShotHk as u8 {
send_request(
addressable_id.target_id,
HkRequest::OneShot(addressable_id.unique_id),
);
send_request(target_id, HkRequest::OneShot(unique_id));
} else if subservice == hk::Subservice::TcModifyHkCollectionInterval as u8 {
if user_data.len() < 12 {
self.psb
.common
.verification_handler
.borrow_mut()
.start_failure(
@ -148,9 +136,9 @@ impl PusService3HkHandler {
));
}
send_request(
addressable_id.target_id,
target_id,
HkRequest::ModifyCollectionInterval(
addressable_id.unique_id,
unique_id,
CollectionIntervalFactor::from_be_bytes(user_data[8..12].try_into().unwrap()),
),
);
@ -160,7 +148,7 @@ impl PusService3HkHandler {
}
pub struct Pus3Wrapper {
pub(crate) pus_3_handler: PusService3HkHandler,
pub(crate) pus_3_handler: PusService3HkHandler<EcssTcInStoreConverter>,
}
impl Pus3Wrapper {

4
satrs-example/src/pus/scheduler.rs
View File

@ -2,10 +2,10 @@ use crate::tmtc::PusTcSource;
use log::{error, info, warn};
use satrs_core::pus::scheduler::TcInfo;
use satrs_core::pus::scheduler_srv::PusService11SchedHandler;
use satrs_core::pus::PusPacketHandlerResult;
use satrs_core::pus::{EcssTcInStoreConverter, PusPacketHandlerResult};
pub struct Pus11Wrapper {
pub pus_11_handler: PusService11SchedHandler,
pub pus_11_handler: PusService11SchedHandler<EcssTcInStoreConverter>,
pub tc_source_wrapper: PusTcSource,
}

24
satrs-example/src/pus/test.rs
View File

@ -1,18 +1,18 @@
use log::{info, warn};
use satrs_core::events::EventU32;
use satrs_core::params::Params;
use satrs_core::pus::test::PusService17TestHandler;
use satrs_core::pus::verification::FailParams;
use satrs_core::pus::PusPacketHandlerResult;
use satrs_core::pus::{EcssTcInMemConverter, PusPacketHandlerResult};
use satrs_core::spacepackets::ecss::tc::PusTcReader;
use satrs_core::spacepackets::ecss::PusPacket;
use satrs_core::spacepackets::time::cds::TimeProvider;
use satrs_core::spacepackets::time::TimeWriter;
use satrs_core::{events::EventU32, pus::EcssTcInStoreConverter};
use satrs_example::{tmtc_err, TEST_EVENT};
use std::sync::mpsc::Sender;
pub struct Service17CustomWrapper {
pub pus17_handler: PusService17TestHandler,
pub pus17_handler: PusService17TestHandler<EcssTcInStoreConverter>,
pub test_srv_event_sender: Sender<(EventU32, Option<Params>)>,
}
@ -38,9 +38,9 @@ impl Service17CustomWrapper {
warn!("PUS17: Subservice {subservice} not implemented")
}
PusPacketHandlerResult::CustomSubservice(subservice, token) => {
let psb_mut = &mut self.pus17_handler.psb;
let buf = psb_mut.pus_buf;
let (tc, _) = PusTcReader::new(&buf).unwrap();
let (tc, _) =
PusTcReader::new(self.pus17_handler.psb.tc_in_mem_converter.tc_slice_raw())
.unwrap();
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();
@ -49,12 +49,17 @@ impl Service17CustomWrapper {
self.test_srv_event_sender
.send((TEST_EVENT.into(), None))
.expect("Sending test event failed");
let start_token = psb_mut
let start_token = self
.pus17_handler
.psb
.common
.verification_handler
.get_mut()
.start_success(token.into(), Some(&stamp_buf))
.start_success(token, Some(&stamp_buf))
.expect("Error sending start success");
psb_mut
self.pus17_handler
.psb
.common
.verification_handler
.get_mut()
.completion_success(start_token, Some(&stamp_buf))
@ -63,6 +68,7 @@ impl Service17CustomWrapper {
let fail_data = [tc.subservice()];
self.pus17_handler
.psb
.common
.verification_handler
.get_mut()
.start_failure(