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

first implementation of apid with target id, currently main broken

Browse Source
This commit is contained in:
lkoester
2023-08-15 08:49:54 +02:00
parent 698c2edb93
commit 075dc38434
8 changed files with 163 additions and 79 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@ -11,13 +11,13 @@ use satrs_core::pus::{
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::{TargetIdWithApid, tmtc_err};
use std::collections::HashMap;
use std::sync::mpsc::Sender;
pub struct PusService8ActionHandler {
psb: PusServiceBase,
request_handlers: HashMap<TargetId, Sender<RequestWithToken>>,
request_handlers: HashMap<TargetIdWithApid, Sender<RequestWithToken>>,
}
impl PusService8ActionHandler {
@ -27,7 +27,7 @@ impl PusService8ActionHandler {
tm_sender: Box<dyn EcssTmSender>,
tm_apid: u16,
verification_handler: StdVerifReporterWithSender,
request_handlers: HashMap<TargetId, Sender<RequestWithToken>>,
request_handlers: HashMap<TargetIdWithApid, Sender<RequestWithToken>>,
) -> Self {
Self {
psb: PusServiceBase::new(
@ -63,7 +63,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
@ -78,7 +79,7 @@ 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()
.verification_handler
.borrow_mut()

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

@ -1,6 +1,6 @@
use crate::requests::{Request, RequestWithToken};
use log::{error, warn};
use satrs_core::hk::{CollectionIntervalFactor, HkRequest};
use satrs_core::hk::{CollectionIntervalFactor, HkRequest, UniqueId};
use satrs_core::pool::{SharedPool, StoreAddr};
use satrs_core::pus::verification::{
FailParams, StdVerifReporterWithSender, TcStateAccepted, VerificationToken,
@ -11,14 +11,14 @@ use satrs_core::pus::{
};
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_core::tmtc::TargetId;
use satrs_example::{hk_err, TargetIdWithApid, tmtc_err};
use std::collections::HashMap;
use std::sync::mpsc::Sender;
pub struct PusService3HkHandler {
psb: PusServiceBase,
request_handlers: HashMap<TargetId, Sender<RequestWithToken>>,
request_handlers: HashMap<TargetIdWithApid, Sender<RequestWithToken>>,
}
impl PusService3HkHandler {
@ -28,7 +28,7 @@ impl PusService3HkHandler {
tm_sender: Box<dyn EcssTmSender>,
tm_apid: u16,
verification_handler: StdVerifReporterWithSender,
request_handlers: HashMap<TargetId, Sender<RequestWithToken>>,
request_handlers: HashMap<TargetIdWithApid, Sender<RequestWithToken>>,
) -> Self {
Self {
psb: PusServiceBase::new(
@ -90,10 +90,11 @@ impl PusServiceHandler for PusService3HkHandler {
"Expected at least 8 bytes of app data".into(),
));
}
let addressable_id = AddressableId::from_raw_be(user_data).unwrap();
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(&addressable_id.target_id)
.contains_key(&target_id)
{
self.psb
.verification_handler
@ -103,15 +104,14 @@ impl PusServiceHandler for 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 send_request = |target: TargetIdWithApid, request: HkRequest| {
let sender = self
.request_handlers
.get(&addressable_id.target_id)
.get(&target)
.unwrap();
sender
.send(RequestWithToken::new(target, Request::Hk(request), token))
@ -119,18 +119,18 @@ impl PusServiceHandler for PusService3HkHandler {
};
if subservice == hk::Subservice::TcEnableHkGeneration as u8 {
send_request(
addressable_id.target_id,
HkRequest::Enable(addressable_id.unique_id),
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),
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),
target_id,
HkRequest::OneShot(unique_id),
);
} else if subservice == hk::Subservice::TcModifyHkCollectionInterval as u8 {
if user_data.len() < 12 {
@ -151,9 +151,9 @@ impl PusServiceHandler for 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()),
),
);