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

Add basic mode request handling #34

Merged
muellerr merged 5 commits from add_mode_request into main 2023-02-15 17:16:43 +01:00
Conversation 0 Commits 5 Files Changed 13 +153 -121
5 changed files with 153 additions and 121 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files
Showing only changes of commit 943ae821de - Show all commits

18
satrs-core/src/mode.rs
View File

@ -1,5 +1,5 @@
use core::mem::size_of;
use crate::tmtc::TargetId; use crate::tmtc::TargetId;
use core::mem::size_of;
use serde::{Deserialize, Serialize}; use serde::{Deserialize, Serialize};
use spacepackets::{ByteConversionError, SizeMissmatch}; use spacepackets::{ByteConversionError, SizeMissmatch};
@ -12,17 +12,11 @@ pub struct ModeAndSubmode {
impl ModeAndSubmode { impl ModeAndSubmode {
pub const fn new_mode_only(mode: u32) -> Self { pub const fn new_mode_only(mode: u32) -> Self {
Self { Self { mode, submode: 0 }
mode,
submode: 0
}
} }
pub const fn new(mode: u32, submode: u16) -> Self { pub const fn new(mode: u32, submode: u16) -> Self {
Self { Self { mode, submode }
mode,
submode
}
} }
pub fn raw_len() -> usize { pub fn raw_len() -> usize {
@ -33,12 +27,12 @@ impl ModeAndSubmode {
if buf.len() < 6 { if buf.len() < 6 {
return Err(ByteConversionError::FromSliceTooSmall(SizeMissmatch { return Err(ByteConversionError::FromSliceTooSmall(SizeMissmatch {
expected: 6, expected: 6,
found: buf.len() found: buf.len(),
})); }));
} }
Ok(Self { Ok(Self {
mode: u32::from_be_bytes(buf[0..4].try_into().unwrap()), mode: u32::from_be_bytes(buf[0..4].try_into().unwrap()),
submode: u16::from_be_bytes(buf[4..6].try_into().unwrap()) submode: u16::from_be_bytes(buf[4..6].try_into().unwrap()),
}) })
} }
} }
@ -53,7 +47,7 @@ impl ModeCommand {
pub const fn new(address: TargetId, mode_submode: ModeAndSubmode) -> Self { pub const fn new(address: TargetId, mode_submode: ModeAndSubmode) -> Self {
Self { Self {
address, address,
mode_submode mode_submode,
} }
} }
} }

13
satrs-core/src/power.rs
View File

@ -32,19 +32,6 @@ pub trait PowerSwitcherCommandSender {
fn send_switch_on_cmd(&mut self, switch_id: SwitchId) -> Result<(), Self::Error>; fn send_switch_on_cmd(&mut self, switch_id: SwitchId) -> Result<(), Self::Error>;
fn send_switch_off_cmd(&mut self, switch_id: SwitchId) -> Result<(), Self::Error>; fn send_switch_off_cmd(&mut self, switch_id: SwitchId) -> Result<(), Self::Error>;
fn switch_on<T: PowerSwitch>(
&mut self,
switch: &mut T,
) -> Result<(), <T as PowerSwitch>::Error> {
switch.switch_on()
}
fn switch_off<T: PowerSwitch>(
&mut self,
switch: &mut T,
) -> Result<(), <T as PowerSwitch>::Error> {
switch.switch_off()
}
} }
pub trait PowerSwitchInfo { pub trait PowerSwitchInfo {

3
satrs-example/src/main.rs
View File

@ -245,6 +245,9 @@ fn main() {
HkRequest::Disable(_) => {} HkRequest::Disable(_) => {}
HkRequest::ModifyCollectionInterval(_, _) => {} HkRequest::ModifyCollectionInterval(_, _) => {}
}, },
Request::ModeRequest(_mode_req) => {
println!("mode request handling not implemented yet")
}
} }
let started_token = reporter_aocs let started_token = reporter_aocs
.start_success(request.1, Some(&timestamp)) .start_success(request.1, Some(&timestamp))

237
satrs-example/src/pus.rs
View File

@ -2,13 +2,18 @@ use crate::requests::{Request, RequestWithToken};
use crate::tmtc::{PusTcSource, TmStore}; use crate::tmtc::{PusTcSource, TmStore};
use satrs_core::events::EventU32; use satrs_core::events::EventU32;
use satrs_core::hk::{CollectionIntervalFactor, HkRequest}; use satrs_core::hk::{CollectionIntervalFactor, HkRequest};
use satrs_core::mode::{ModeAndSubmode, ModeCommand, ModeRequest};
use satrs_core::params::Params; use satrs_core::params::Params;
use satrs_core::pool::StoreAddr; use satrs_core::pool::StoreAddr;
use satrs_core::pus::event_man::{EventRequest, EventRequestWithToken}; use satrs_core::pus::event_man::{EventRequest, EventRequestWithToken};
use satrs_core::pus::hk; use satrs_core::pus::hk;
use satrs_core::pus::scheduling::PusScheduler;
use satrs_core::pus::mode; use satrs_core::pus::mode;
use satrs_core::pus::verification::{pus_11_generic_tc_check, FailParams, StdVerifReporterWithSender, TcStateAccepted, VerificationToken, StdVerifSenderError}; use satrs_core::pus::mode::Subservice;
use satrs_core::pus::scheduling::PusScheduler;
use satrs_core::pus::verification::{
pus_11_generic_tc_check, FailParams, StdVerifReporterWithSender, TcStateAccepted,
VerificationToken,
};
use satrs_core::pus::{event, GenericTcCheckError}; use satrs_core::pus::{event, GenericTcCheckError};
use satrs_core::res_code::ResultU16; use satrs_core::res_code::ResultU16;
use satrs_core::spacepackets::ecss::{scheduling, PusServiceId}; use satrs_core::spacepackets::ecss::{scheduling, PusServiceId};
@ -24,9 +29,6 @@ use std::collections::HashMap;
use std::convert::TryFrom; use std::convert::TryFrom;
use std::rc::Rc; use std::rc::Rc;
use std::sync::mpsc::Sender; use std::sync::mpsc::Sender;
use satrs_core::mode::{ModeCommand, ModeAndSubmode, ModeRequest};
use satrs_core::pus::mode::Subservice;
use satrs_core::spacepackets::tc::GenericPusTcSecondaryHeader;
pub struct PusReceiver { pub struct PusReceiver {
pub tm_helper: PusTmWithCdsShortHelper, pub tm_helper: PusTmWithCdsShortHelper,
@ -99,14 +101,6 @@ impl PusReceiver {
scheduler: tc_arguments.scheduler, scheduler: tc_arguments.scheduler,
} }
} }
fn vr_and_stamp(&mut self) -> (&mut StdVerifReporterWithSender, &[u8]) {
(&mut self.tm_args.verif_reporter, self.stamp())
}
fn stamp(&self) -> &[u8] {
self.stamp_helper.stamp()
}
} }
impl PusServiceProvider for PusReceiver { impl PusServiceProvider for PusReceiver {
@ -120,9 +114,10 @@ impl PusServiceProvider for PusReceiver {
) -> Result<(), Self::Error> { ) -> Result<(), Self::Error> {
let init_token = self.tm_args.verif_reporter.add_tc(pus_tc); let init_token = self.tm_args.verif_reporter.add_tc(pus_tc);
self.stamp_helper.update_from_now(); self.stamp_helper.update_from_now();
let (vr, stamp) = self.vr_and_stamp(); let accepted_token = self
let accepted_token = vr .tm_args
.acceptance_success(init_token, Some(stamp)) .verif_reporter
.acceptance_success(init_token, Some(self.stamp_helper.stamp()))
.expect("Acceptance success failure"); .expect("Acceptance success failure");
let service = PusServiceId::try_from(service); let service = PusServiceId::try_from(service);
match service { match service {
@ -131,11 +126,13 @@ impl PusServiceProvider for PusReceiver {
PusServiceId::Housekeeping => self.handle_hk_request(pus_tc, accepted_token), PusServiceId::Housekeeping => self.handle_hk_request(pus_tc, accepted_token),
PusServiceId::Event => self.handle_event_request(pus_tc, accepted_token), PusServiceId::Event => self.handle_event_request(pus_tc, accepted_token),
PusServiceId::Scheduling => self.handle_scheduled_tc(pus_tc, accepted_token), PusServiceId::Scheduling => self.handle_scheduled_tc(pus_tc, accepted_token),
_ => vr _ => self
.tm_args
.verif_reporter
.start_failure( .start_failure(
accepted_token, accepted_token,
FailParams::new( FailParams::new(
Some(stamp), Some(self.stamp_helper.stamp()),
&tmtc_err::PUS_SERVICE_NOT_IMPLEMENTED, &tmtc_err::PUS_SERVICE_NOT_IMPLEMENTED,
Some(&[standard_service as u8]), Some(&[standard_service as u8]),
), ),
@ -151,7 +148,8 @@ impl PusServiceProvider for PusReceiver {
CustomPusServiceId::Health => {} CustomPusServiceId::Health => {}
} }
} else { } else {
vr self.tm_args
.verif_reporter
.start_failure( .start_failure(
accepted_token, accepted_token,
FailParams::new( FailParams::new(
@ -170,40 +168,47 @@ impl PusServiceProvider for PusReceiver {
impl PusReceiver { impl PusReceiver {
fn handle_test_service(&mut self, pus_tc: &PusTc, token: VerificationToken<TcStateAccepted>) { fn handle_test_service(&mut self, pus_tc: &PusTc, token: VerificationToken<TcStateAccepted>) {
let (vr, stamp) = self.vr_and_stamp();
match PusPacket::subservice(pus_tc) { match PusPacket::subservice(pus_tc) {
1 => { 1 => {
println!("Received PUS ping command TC[17,1]"); println!("Received PUS ping command TC[17,1]");
println!("Sending ping reply PUS TM[17,2]"); println!("Sending ping reply PUS TM[17,2]");
let start_token = vr let start_token = self
.start_success(token, Some(stamp)) .tm_args
.verif_reporter
.start_success(token, Some(self.stamp_helper.stamp()))
.expect("Error sending start success"); .expect("Error sending start success");
let ping_reply = self.tm_helper.create_pus_tm_timestamp_now(17, 2, None); let ping_reply = self.tm_helper.create_pus_tm_timestamp_now(17, 2, None);
let addr = self.tm_args.tm_store.add_pus_tm(&ping_reply); let addr = self.tm_args.tm_store.add_pus_tm(&ping_reply);
self.tm_args.tm_tx self.tm_args
.tm_tx
.send(addr) .send(addr)
.expect("Sending TM to TM funnel failed"); .expect("Sending TM to TM funnel failed");
vr self.tm_args
.completion_success(start_token, Some(stamp)) .verif_reporter
.completion_success(start_token, Some(self.stamp_helper.stamp()))
.expect("Error sending completion success"); .expect("Error sending completion success");
} }
128 => { 128 => {
self.event_sender self.event_sender
.send((TEST_EVENT.into(), None)) .send((TEST_EVENT.into(), None))
.expect("Sending test event failed"); .expect("Sending test event failed");
let start_token = vr let start_token = self
.start_success(token, Some(stamp)) .tm_args
.verif_reporter
.start_success(token, Some(self.stamp_helper.stamp()))
.expect("Error sending start success"); .expect("Error sending start success");
vr self.tm_args
.completion_success(start_token, Some(stamp)) .verif_reporter
.completion_success(start_token, Some(self.stamp_helper.stamp()))
.expect("Error sending completion success"); .expect("Error sending completion success");
} }
_ => { _ => {
vr self.tm_args
.verif_reporter
.start_failure( .start_failure(
token, token,
FailParams::new( FailParams::new(
Some(stamp), Some(self.stamp_helper.stamp()),
&tmtc_err::INVALID_PUS_SUBSERVICE, &tmtc_err::INVALID_PUS_SUBSERVICE,
None, None,
), ),
@ -214,12 +219,13 @@ impl PusReceiver {
} }
fn handle_hk_request(&mut self, pus_tc: &PusTc, token: VerificationToken<TcStateAccepted>) { fn handle_hk_request(&mut self, pus_tc: &PusTc, token: VerificationToken<TcStateAccepted>) {
let (vr, stamp) = self.vr_and_stamp();
if pus_tc.user_data().is_none() { if pus_tc.user_data().is_none() {
vr.start_failure( self.tm_args
.verif_reporter
.start_failure(
token, token,
FailParams::new( FailParams::new(
Some(stamp), Some(self.stamp_helper.stamp()),
&tmtc_err::NOT_ENOUGH_APP_DATA, &tmtc_err::NOT_ENOUGH_APP_DATA,
None, None,
), ),
@ -234,20 +240,23 @@ impl PusReceiver {
} else { } else {
&hk_err::UNIQUE_ID_MISSING &hk_err::UNIQUE_ID_MISSING
}; };
vr self.tm_args
.verif_reporter
.start_failure( .start_failure(
token, token,
FailParams::new(Some(stamp), err, None), FailParams::new(Some(self.stamp_helper.stamp()), err, None),
) )
.expect("Sending start failure TM failed"); .expect("Sending start failure TM failed");
return; return;
} }
let addressable_id = AddressableId::from_raw_be(user_data).unwrap(); let addressable_id = AddressableId::from_raw_be(user_data).unwrap();
if !self.request_map.contains_key(&addressable_id.target_id) { if !self.request_map.contains_key(&addressable_id.target_id) {
vr.start_failure( self.tm_args
.verif_reporter
.start_failure(
token, token,
FailParams::new( FailParams::new(
Some(stamp), Some(self.stamp_helper.stamp()),
&hk_err::UNKNOWN_TARGET_ID, &hk_err::UNKNOWN_TARGET_ID,
None, None,
), ),
@ -271,10 +280,12 @@ impl PusReceiver {
== hk::Subservice::TcModifyHkCollectionInterval as u8 == hk::Subservice::TcModifyHkCollectionInterval as u8
{ {
if user_data.len() < 12 { if user_data.len() < 12 {
vr.start_failure( self.tm_args
.verif_reporter
.start_failure(
token, token,
FailParams::new( FailParams::new(
Some(stamp), Some(self.stamp_helper.stamp()),
&hk_err::COLLECTION_INTERVAL_MISSING, &hk_err::COLLECTION_INTERVAL_MISSING,
None, None,
), ),
@ -294,24 +305,20 @@ impl PusReceiver {
timestamp: &[u8], timestamp: &[u8],
failure_code: &ResultU16, failure_code: &ResultU16,
failure_data: Option<&[u8]>| { failure_data: Option<&[u8]>| {
vr vr.start_failure(
.start_failure( token,
token, FailParams::new(Some(timestamp), failure_code, failure_data),
FailParams::new(Some(timestamp), failure_code, failure_data), )
) .expect("Sending start failure TM failed");
.expect("Sending start failure TM failed");
}; };
let send_start_acceptance = |vr: &mut StdVerifReporterWithSender, let send_start_acceptance = |vr: &mut StdVerifReporterWithSender, timestamp: &[u8]| {
timestamp: &[u8]| { vr.start_success(token, Some(timestamp))
vr
.start_success(token, Some(timestamp))
.expect("Sending start success TM failed") .expect("Sending start success TM failed")
}; };
let (vr, stamp) = self.vr_and_stamp();
if pus_tc.user_data().is_none() { if pus_tc.user_data().is_none() {
send_start_failure( send_start_failure(
vr, &mut self.tm_args.verif_reporter,
stamp, self.stamp_helper.stamp(),
&tmtc_err::NOT_ENOUGH_APP_DATA, &tmtc_err::NOT_ENOUGH_APP_DATA,
None, None,
); );
@ -320,8 +327,8 @@ impl PusReceiver {
let app_data = pus_tc.user_data().unwrap(); let app_data = pus_tc.user_data().unwrap();
if app_data.len() < 4 { if app_data.len() < 4 {
send_start_failure( send_start_failure(
vr, &mut self.tm_args.verif_reporter,
stamp, self.stamp_helper.stamp(),
&tmtc_err::NOT_ENOUGH_APP_DATA, &tmtc_err::NOT_ENOUGH_APP_DATA,
None, None,
); );
@ -330,8 +337,10 @@ impl PusReceiver {
let event_id = EventU32::from(u32::from_be_bytes(app_data.try_into().unwrap())); let event_id = EventU32::from(u32::from_be_bytes(app_data.try_into().unwrap()));
match PusPacket::subservice(pus_tc).try_into() { match PusPacket::subservice(pus_tc).try_into() {
Ok(event::Subservice::TcEnableEventGeneration) => { Ok(event::Subservice::TcEnableEventGeneration) => {
let start_token = let start_token = send_start_acceptance(
send_start_acceptance(vr, stamp); &mut self.tm_args.verif_reporter,
self.stamp_helper.stamp(),
);
self.event_request_tx self.event_request_tx
.send(EventRequestWithToken { .send(EventRequestWithToken {
request: EventRequest::Enable(event_id), request: EventRequest::Enable(event_id),
@ -340,8 +349,10 @@ impl PusReceiver {
.expect("Sending event request failed"); .expect("Sending event request failed");
} }
Ok(event::Subservice::TcDisableEventGeneration) => { Ok(event::Subservice::TcDisableEventGeneration) => {
let start_token = let start_token = send_start_acceptance(
send_start_acceptance(vr, stamp); &mut self.tm_args.verif_reporter,
self.stamp_helper.stamp(),
);
self.event_request_tx self.event_request_tx
.send(EventRequestWithToken { .send(EventRequestWithToken {
request: EventRequest::Disable(event_id), request: EventRequest::Disable(event_id),
@ -351,8 +362,8 @@ impl PusReceiver {
} }
_ => { _ => {
send_start_failure( send_start_failure(
vr, &mut self.tm_args.verif_reporter,
stamp, self.stamp_helper.stamp(),
&tmtc_err::INVALID_PUS_SUBSERVICE, &tmtc_err::INVALID_PUS_SUBSERVICE,
None, None,
); );
@ -361,16 +372,16 @@ impl PusReceiver {
} }
fn handle_scheduled_tc(&mut self, pus_tc: &PusTc, token: VerificationToken<TcStateAccepted>) { fn handle_scheduled_tc(&mut self, pus_tc: &PusTc, token: VerificationToken<TcStateAccepted>) {
let (vr, stamp) = self.vr_and_stamp();
let subservice = match pus_11_generic_tc_check(pus_tc) { let subservice = match pus_11_generic_tc_check(pus_tc) {
Ok(subservice) => subservice, Ok(subservice) => subservice,
Err(e) => match e { Err(e) => match e {
GenericTcCheckError::NotEnoughAppData => { GenericTcCheckError::NotEnoughAppData => {
vr self.tm_args
.verif_reporter
.start_failure( .start_failure(
token, token,
FailParams::new( FailParams::new(
Some(stamp), Some(self.stamp_helper.stamp()),
&tmtc_err::NOT_ENOUGH_APP_DATA, &tmtc_err::NOT_ENOUGH_APP_DATA,
None, None,
), ),
@ -379,10 +390,12 @@ impl PusReceiver {
return; return;
} }
GenericTcCheckError::InvalidSubservice => { GenericTcCheckError::InvalidSubservice => {
vr.start_failure( self.tm_args
.verif_reporter
.start_failure(
token, token,
FailParams::new( FailParams::new(
Some(stamp), Some(self.stamp_helper.stamp()),
&tmtc_err::INVALID_PUS_SUBSERVICE, &tmtc_err::INVALID_PUS_SUBSERVICE,
None, None,
), ),
@ -394,39 +407,46 @@ impl PusReceiver {
}; };
match subservice { match subservice {
scheduling::Subservice::TcEnableScheduling => { scheduling::Subservice::TcEnableScheduling => {
let start_token = let start_token = self
vr .tm_args
.start_success(token, Some(stamp)) .verif_reporter
.start_success(token, Some(self.stamp_helper.stamp()))
.expect("Error sending start success"); .expect("Error sending start success");
let mut scheduler = self.scheduler.borrow_mut(); let mut scheduler = self.scheduler.borrow_mut();
scheduler.enable(); scheduler.enable();
if scheduler.is_enabled() { if scheduler.is_enabled() {
vr self.tm_args
.completion_success(start_token, Some(stamp)) .verif_reporter
.completion_success(start_token, Some(self.stamp_helper.stamp()))
.expect("Error sending completion success"); .expect("Error sending completion success");
} else { } else {
panic!("Failed to enable scheduler"); panic!("Failed to enable scheduler");
} }
} }
scheduling::Subservice::TcDisableScheduling => { scheduling::Subservice::TcDisableScheduling => {
let start_token =vr let start_token = self
.start_success(token, Some(stamp)) .tm_args
.verif_reporter
.start_success(token, Some(self.stamp_helper.stamp()))
.expect("Error sending start success"); .expect("Error sending start success");
let mut scheduler = self.scheduler.borrow_mut(); let mut scheduler = self.scheduler.borrow_mut();
scheduler.disable(); scheduler.disable();
if !scheduler.is_enabled() { if !scheduler.is_enabled() {
vr self.tm_args
.completion_success(start_token, Some(stamp)) .verif_reporter
.completion_success(start_token, Some(self.stamp_helper.stamp()))
.expect("Error sending completion success"); .expect("Error sending completion success");
} else { } else {
panic!("Failed to disable scheduler"); panic!("Failed to disable scheduler");
} }
} }
scheduling::Subservice::TcResetScheduling => { scheduling::Subservice::TcResetScheduling => {
let start_token = vr let start_token = self
.start_success(token, Some(stamp)) .tm_args
.verif_reporter
.start_success(token, Some(self.stamp_helper.stamp()))
.expect("Error sending start success"); .expect("Error sending start success");
let mut pool = self let mut pool = self
@ -442,12 +462,16 @@ impl PusReceiver {
.expect("Error resetting TC Pool"); .expect("Error resetting TC Pool");
drop(scheduler); drop(scheduler);
vr.completion_success(start_token, Some(stamp)) self.tm_args
.verif_reporter
.completion_success(start_token, Some(self.stamp_helper.stamp()))
.expect("Error sending completion success"); .expect("Error sending completion success");
} }
scheduling::Subservice::TcInsertActivity => { scheduling::Subservice::TcInsertActivity => {
let start_token = vr let start_token = self
.start_success(token, Some(stamp)) .tm_args
.verif_reporter
.start_success(token, Some(self.stamp_helper.stamp()))
.expect("error sending start success"); .expect("error sending start success");
let mut pool = self let mut pool = self
@ -462,8 +486,9 @@ impl PusReceiver {
.expect("insertion of activity into pool failed"); .expect("insertion of activity into pool failed");
drop(scheduler); drop(scheduler);
vr self.tm_args
.completion_success(start_token, Some(stamp)) .verif_reporter
.completion_success(start_token, Some(self.stamp_helper.stamp()))
.expect("sending completion success failed"); .expect("sending completion success failed");
} }
_ => {} _ => {}
@ -471,19 +496,20 @@ impl PusReceiver {
} }
fn handle_mode_service(&mut self, pus_tc: &PusTc, token: VerificationToken<TcStateAccepted>) { fn handle_mode_service(&mut self, pus_tc: &PusTc, token: VerificationToken<TcStateAccepted>) {
let (vr, stamp) = self.vr_and_stamp();
let mut app_data_len = 0; let mut app_data_len = 0;
let app_data = pus_tc.user_data(); let app_data = pus_tc.user_data();
if app_data.is_some() { if app_data.is_some() {
app_data_len = pus_tc.user_data().unwrap().len(); app_data_len = pus_tc.user_data().unwrap().len();
} }
if app_data_len < 4 { if app_data_len < 4 {
vr self.tm_args
.verif_reporter
.start_failure( .start_failure(
token, token,
FailParams::new( FailParams::new(
Some(stamp), &tmtc_err::NOT_ENOUGH_APP_DATA, Some(self.stamp_helper.stamp()),
Some(format!("expected {} bytes, found {}", 4, app_data_len).as_bytes()) &tmtc_err::NOT_ENOUGH_APP_DATA,
Some(format!("expected {} bytes, found {}", 4, app_data_len).as_bytes()),
), ),
) )
.expect("Sending start failure TM failed"); .expect("Sending start failure TM failed");
@ -496,22 +522,40 @@ impl PusReceiver {
let target_id = u32::from_be_bytes(app_data[0..4].try_into().unwrap()); let target_id = u32::from_be_bytes(app_data[0..4].try_into().unwrap());
let min_len = ModeAndSubmode::raw_len() + 4; let min_len = ModeAndSubmode::raw_len() + 4;
if app_data_len < min_len { if app_data_len < min_len {
vr.start_failure( self.tm_args
.verif_reporter
.start_failure(
token, token,
FailParams::new( FailParams::new(
Some(stamp), &tmtc_err::NOT_ENOUGH_APP_DATA, Some(self.stamp_helper.stamp()),
Some(format!("expected {} bytes, found {}", min_len, app_data_len).as_bytes()) &tmtc_err::NOT_ENOUGH_APP_DATA,
Some(
format!(
"expected {} bytes, found {}",
min_len, app_data_len
)
.as_bytes(),
),
), ),
) )
.expect("Sending start failure TM failed"); .expect("Sending start failure TM failed");
} }
// Should never fail after size check // Should never fail after size check
let mode_submode = ModeAndSubmode::from_be_bytes(app_data[4..4 + ModeAndSubmode::raw_len()].try_into().unwrap()).unwrap(); let mode_submode = ModeAndSubmode::from_be_bytes(
let mode_request = Request::ModeRequest(ModeRequest::SetMode(ModeCommand::new(target_id, mode_submode))); app_data[4..4 + ModeAndSubmode::raw_len()]
.try_into()
.unwrap(),
)
.unwrap();
let mode_request = Request::ModeRequest(ModeRequest::SetMode(
ModeCommand::new(target_id, mode_submode),
));
match self.request_map.get(&target_id) { match self.request_map.get(&target_id) {
None => {} None => {}
Some(sender_to_recipient) => { Some(sender_to_recipient) => {
sender_to_recipient.send(RequestWithToken(mode_request, token)).expect("sending mode request failed"); sender_to_recipient
.send(RequestWithToken(mode_request, token))
.expect("sending mode request failed");
} }
} }
} }
@ -523,11 +567,14 @@ impl PusReceiver {
Subservice::TmWrongModeReply => {} Subservice::TmWrongModeReply => {}
} }
} else { } else {
vr.start_failure( self.tm_args
.verif_reporter
.start_failure(
token, token,
FailParams::new( FailParams::new(
Some(stamp), &tmtc_err::INVALID_PUS_SUBSERVICE, Some(self.stamp_helper.stamp()),
Some(&[PusPacket::subservice(pus_tc)]) &tmtc_err::INVALID_PUS_SUBSERVICE,
Some(&[PusPacket::subservice(pus_tc)]),
), ),
) )
.expect("Sending start failure TM failed"); .expect("Sending start failure TM failed");

3
satrs-example/src/requests.rs
View File

@ -3,9 +3,10 @@ use satrs_core::mode::ModeRequest;
use satrs_core::pus::verification::{TcStateAccepted, VerificationToken}; use satrs_core::pus::verification::{TcStateAccepted, VerificationToken};
#[derive(Copy, Clone, Eq, PartialEq, Debug)] #[derive(Copy, Clone, Eq, PartialEq, Debug)]
#[non_exhaustive]
pub enum Request { pub enum Request {
HkRequest(HkRequest), HkRequest(HkRequest),
ModeRequest(ModeRequest) ModeRequest(ModeRequest),
} }
#[derive(Copy, Clone, Eq, PartialEq, Debug)] #[derive(Copy, Clone, Eq, PartialEq, Debug)]