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

im done

Browse Source
This commit is contained in:
Robin Müller 2023-07-09 20:19:53 +02:00
parent e46b88384f
commit 92147a00b3
Signed by: muellerr
GPG Key ID: A649FB78196E3849
4 changed files with 60 additions and 61 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

21
satrs-core/src/pus/event_srv.rs
View File

@ -1,5 +1,5 @@
use crate::events::EventU32; use crate::events::EventU32;
use crate::pool::{SharedPool, StoreAddr}; use crate::pool::{PoolGuard, SharedPool, StoreAddr};
use crate::pus::event_man::{EventRequest, EventRequestWithToken}; use crate::pus::event_man::{EventRequest, EventRequestWithToken};
use crate::pus::verification::{ use crate::pus::verification::{
StdVerifReporterWithSender, TcStateAccepted, TcStateToken, VerificationToken, StdVerifReporterWithSender, TcStateAccepted, TcStateToken, VerificationToken,
@ -44,22 +44,16 @@ impl PusServiceHandler for PusService5EventHandler {
fn handle_one_tc( fn handle_one_tc(
&mut self, &mut self,
tc_in_store_with_token: ReceivedTcWrapper, tc: PusTc,
_tc_guard: PoolGuard,
token: VerificationToken<TcStateAccepted>,
) -> Result<PusPacketHandlerResult, PusPacketHandlingError> { ) -> Result<PusPacketHandlerResult, PusPacketHandlingError> {
let ReceivedTcWrapper {
tc,
token,
pool_guard,
} = tc_in_store_with_token;
// TODO: Better token handling..
let token = token.expect("invalid token");
let accepted_token = VerificationToken::<TcStateAccepted>::try_from(token).unwrap();
let subservice = tc.subservice(); let subservice = tc.subservice();
let srv = Subservice::try_from(subservice); let srv = Subservice::try_from(subservice);
if srv.is_err() { if srv.is_err() {
return Ok(PusPacketHandlerResult::CustomSubservice( return Ok(PusPacketHandlerResult::CustomSubservice(
tc.subservice(), tc.subservice(),
token, token.into(),
)); ));
} }
let handle_enable_disable_request = |enable: bool, stamp: [u8; 7]| { let handle_enable_disable_request = |enable: bool, stamp: [u8; 7]| {
@ -74,7 +68,7 @@ impl PusServiceHandler for PusService5EventHandler {
.psb .psb
.verification_handler .verification_handler
.borrow_mut() .borrow_mut()
.start_success(accepted_token, Some(&stamp)) .start_success(token, Some(&stamp))
.map_err(|_| PartialPusHandlingError::Verification); .map_err(|_| PartialPusHandlingError::Verification);
let partial_error = start_token.clone().err(); let partial_error = start_token.clone().err();
let mut token: TcStateToken = token.into(); let mut token: TcStateToken = token.into();
@ -121,7 +115,8 @@ impl PusServiceHandler for PusService5EventHandler {
} }
Subservice::TcReportDisabledList | Subservice::TmDisabledEventsReport => { Subservice::TcReportDisabledList | Subservice::TmDisabledEventsReport => {
return Ok(PusPacketHandlerResult::SubserviceNotImplemented( return Ok(PusPacketHandlerResult::SubserviceNotImplemented(
subservice, token, subservice,
token.into(),
)); ));
} }
} }

56
satrs-core/src/pus/mod.rs
View File

@ -282,7 +282,7 @@ mod alloc_mod {
#[cfg(feature = "std")] #[cfg(feature = "std")]
pub mod std_mod { pub mod std_mod {
use crate::pool::{SharedPool, StoreAddr}; use crate::pool::{PoolGuard, SharedPool, StoreAddr};
use crate::pus::verification::{ use crate::pus::verification::{
StdVerifReporterWithSender, TcStateAccepted, TcStateToken, VerificationToken, StdVerifReporterWithSender, TcStateAccepted, TcStateToken, VerificationToken,
}; };
@ -394,11 +394,12 @@ pub mod std_mod {
TryRecvError::Empty => GenericRecvError::Empty, TryRecvError::Empty => GenericRecvError::Empty,
TryRecvError::Disconnected => GenericRecvError::TxDisconnected, TryRecvError::Disconnected => GenericRecvError::TxDisconnected,
})?; })?;
let shared_tc_pool = self let mut shared_tc_pool = self
.shared_tc_pool .shared_tc_pool
.read() .read()
.map_err(|_| EcssTmtcError::StoreLock)?; .map_err(|_| EcssTmtcError::StoreLock)?;
let tc_raw = shared_tc_pool.read(&addr)?; let pool_guard = shared_tc_pool.read_with_guard(addr);
let tc_raw = pool_guard.read()?;
if buf.len() < tc_raw.len() { if buf.len() < tc_raw.len() {
return Err( return Err(
PusError::ByteConversion(ByteConversionError::ToSliceTooSmall(SizeMissmatch { PusError::ByteConversion(ByteConversionError::ToSliceTooSmall(SizeMissmatch {
@ -410,7 +411,11 @@ pub mod std_mod {
} }
buf[..tc_raw.len()].copy_from_slice(tc_raw); buf[..tc_raw.len()].copy_from_slice(tc_raw);
let (tc, _) = PusTc::from_bytes(buf)?; let (tc, _) = PusTc::from_bytes(buf)?;
Ok((tc, token)) Ok((ReceivedTcWrapper {
tc,
pool_guard,
token: Some(token),
}))
} }
} }
@ -474,6 +479,8 @@ pub mod std_mod {
InvalidAppData(String), InvalidAppData(String),
#[error("generic ECSS tmtc error: {0}")] #[error("generic ECSS tmtc error: {0}")]
EcssTmtc(#[from] EcssTmtcError), EcssTmtc(#[from] EcssTmtcError),
#[error("invalid verification token")]
InvalidVerificationToken,
#[error("other error {0}")] #[error("other error {0}")]
Other(String), Other(String),
} }
@ -564,30 +571,31 @@ pub mod std_mod {
fn psb(&self) -> &PusServiceBase; fn psb(&self) -> &PusServiceBase;
fn handle_one_tc( fn handle_one_tc(
&mut self, &mut self,
tc_in_store_with_token: ReceivedTcWrapper, tc: PusTc,
tc_guard: PoolGuard,
token: VerificationToken<TcStateAccepted>,
) -> Result<PusPacketHandlerResult, PusPacketHandlingError>; ) -> Result<PusPacketHandlerResult, PusPacketHandlingError>;
fn copy_tc_to_buf(&mut self, addr: StoreAddr) -> Result<(), PusPacketHandlingError> {
// Keep locked section as short as possible.
let psb_mut = self.psb_mut();
let mut tc_pool = psb_mut
.tc_store
.write()
.map_err(|_| PusPacketHandlingError::EcssTmtc(EcssTmtcError::StoreLock))?;
let tc_guard = tc_pool.read_with_guard(addr);
let tc_raw = tc_guard.read().unwrap();
psb_mut.pus_buf[0..tc_raw.len()].copy_from_slice(tc_raw);
Ok(())
}
fn handle_next_packet(&mut self) -> Result<PusPacketHandlerResult, PusPacketHandlingError> { fn handle_next_packet(&mut self) -> Result<PusPacketHandlerResult, PusPacketHandlingError> {
match self.psb().tc_receiver.recv_tc()? { match self.psb().tc_receiver.recv_tc(&mut self.psb_mut().pus_buf) {
Ok((addr, token)) => self.handle_one_tc(addr, token), Ok(ReceivedTcWrapper {
tc,
pool_guard,
token,
}) => {
if token.is_none() {
return Err(PusPacketHandlingError::InvalidVerificationToken);
}
let token = token.unwrap();
self.handle_one_tc(tc, pool_guard, token.try_into().unwrap())
}
Err(e) => match e { Err(e) => match e {
TryRecvError::Empty => Ok(PusPacketHandlerResult::Empty), EcssTmtcError::StoreLock => {}
TryRecvError::Disconnected => Err(PusPacketHandlingError::EcssTmtc( EcssTmtcError::Store(_) => {}
EcssTmtcError::Recv(GenericRecvError::TxDisconnected), EcssTmtcError::Pus(_) => {}
)), EcssTmtcError::CantSendAddr(_) => {}
EcssTmtcError::Send(_) => {}
EcssTmtcError::Recv(_) => {}
}, },
} }
} }

24
satrs-core/src/pus/scheduler_srv.rs
View File

@ -1,4 +1,4 @@
use crate::pool::{SharedPool, StoreAddr}; use crate::pool::{PoolGuard, SharedPool, StoreAddr};
use crate::pus::scheduler::PusScheduler; use crate::pus::scheduler::PusScheduler;
use crate::pus::verification::{StdVerifReporterWithSender, TcStateAccepted, VerificationToken}; use crate::pus::verification::{StdVerifReporterWithSender, TcStateAccepted, VerificationToken};
use crate::pus::{ use crate::pus::{
@ -21,6 +21,7 @@ use std::sync::mpsc::Receiver;
/// telecommands when applicable. /// telecommands when applicable.
pub struct PusService11SchedHandler { pub struct PusService11SchedHandler {
psb: PusServiceBase, psb: PusServiceBase,
shared_tc_store: SharedPool,
scheduler: PusScheduler, scheduler: PusScheduler,
} }
@ -30,10 +31,12 @@ impl PusService11SchedHandler {
tm_sender: Box<dyn EcssTmSender>, tm_sender: Box<dyn EcssTmSender>,
tm_apid: u16, tm_apid: u16,
verification_handler: StdVerifReporterWithSender, verification_handler: StdVerifReporterWithSender,
shared_tc_store: SharedPool,
scheduler: PusScheduler, scheduler: PusScheduler,
) -> Self { ) -> Self {
Self { Self {
psb: PusServiceBase::new(tc_receiver, tm_sender, tm_apid, verification_handler), psb: PusServiceBase::new(tc_receiver, tm_sender, tm_apid, verification_handler),
shared_tc_store,
scheduler, scheduler,
} }
} }
@ -57,18 +60,15 @@ impl PusServiceHandler for PusService11SchedHandler {
fn handle_one_tc( fn handle_one_tc(
&mut self, &mut self,
tc_in_store_with_token: ReceivedTcWrapper, tc: PusTc,
tc_guard: PoolGuard,
token: VerificationToken<TcStateAccepted>,
) -> Result<PusPacketHandlerResult, PusPacketHandlingError> { ) -> Result<PusPacketHandlerResult, PusPacketHandlingError> {
let ReceivedTcWrapper {
tc,
pool_guard,
token,
} = tc_in_store_with_token;
let std_service = scheduling::Subservice::try_from(tc.subservice()); let std_service = scheduling::Subservice::try_from(tc.subservice());
if std_service.is_err() { if std_service.is_err() {
return Ok(PusPacketHandlerResult::CustomSubservice( return Ok(PusPacketHandlerResult::CustomSubservice(
tc.subservice(), tc.subservice(),
token, token.into(),
)); ));
} }
let mut partial_error = None; let mut partial_error = None;
@ -120,7 +120,7 @@ impl PusServiceHandler for PusService11SchedHandler {
.start_success(token, Some(&time_stamp)) .start_success(token, Some(&time_stamp))
.expect("Error sending start success"); .expect("Error sending start success");
let mut pool = self.psb.tc_store.write().expect("Locking pool failed"); let mut pool = self.shared_tc_store.write().expect("Locking pool failed");
self.scheduler self.scheduler
.reset(pool.as_mut()) .reset(pool.as_mut())
@ -140,7 +140,7 @@ impl PusServiceHandler for PusService11SchedHandler {
.start_success(token, Some(&time_stamp)) .start_success(token, Some(&time_stamp))
.expect("error sending start success"); .expect("error sending start success");
let mut pool = self.psb.tc_store.write().expect("locking pool failed"); let mut pool = self.shared_tc_store.write().expect("locking pool failed");
self.scheduler self.scheduler
.insert_wrapped_tc::<TimeProvider>(&tc, pool.as_mut()) .insert_wrapped_tc::<TimeProvider>(&tc, pool.as_mut())
.expect("insertion of activity into pool failed"); .expect("insertion of activity into pool failed");
@ -154,7 +154,7 @@ impl PusServiceHandler for PusService11SchedHandler {
_ => { _ => {
return Ok(PusPacketHandlerResult::CustomSubservice( return Ok(PusPacketHandlerResult::CustomSubservice(
tc.subservice(), tc.subservice(),
token, token.into(),
)); ));
} }
} }
@ -165,7 +165,7 @@ impl PusServiceHandler for PusService11SchedHandler {
} }
Ok(PusPacketHandlerResult::CustomSubservice( Ok(PusPacketHandlerResult::CustomSubservice(
tc.subservice(), tc.subservice(),
token, token.into(),
)) ))
} }
} }

20
satrs-core/src/pus/test.rs
View File

@ -1,7 +1,7 @@
use crate::pool::{SharedPool, StoreAddr}; use crate::pool::{PoolGuard, SharedPool, StoreAddr};
use crate::pus::verification::{StdVerifReporterWithSender, TcStateAccepted, VerificationToken}; use crate::pus::verification::{StdVerifReporterWithSender, TcStateAccepted, VerificationToken};
use crate::pus::{ use crate::pus::{
AcceptedTc, EcssTmSender, PartialPusHandlingError, PusPacketHandlerResult, AcceptedTc, EcssTcReceiver, EcssTmSender, PartialPusHandlingError, PusPacketHandlerResult,
PusPacketHandlingError, PusServiceBase, PusServiceHandler, PusTmWrapper, ReceivedTcWrapper, PusPacketHandlingError, PusServiceBase, PusServiceHandler, PusTmWrapper, ReceivedTcWrapper,
}; };
use spacepackets::ecss::PusPacket; use spacepackets::ecss::PusPacket;
@ -19,14 +19,13 @@ pub struct PusService17TestHandler {
impl PusService17TestHandler { impl PusService17TestHandler {
pub fn new( pub fn new(
receiver: Receiver<AcceptedTc>, tc_receiver: Box<dyn EcssTcReceiver>,
tc_pool: SharedPool,
tm_sender: Box<dyn EcssTmSender>, tm_sender: Box<dyn EcssTmSender>,
tm_apid: u16, tm_apid: u16,
verification_handler: StdVerifReporterWithSender, verification_handler: StdVerifReporterWithSender,
) -> Self { ) -> Self {
Self { Self {
psb: PusServiceBase::new(receiver, tc_pool, tm_sender, tm_apid, verification_handler), psb: PusServiceBase::new(tc_receiver, tm_sender, tm_apid, verification_handler),
} }
} }
} }
@ -41,13 +40,10 @@ impl PusServiceHandler for PusService17TestHandler {
fn handle_one_tc( fn handle_one_tc(
&mut self, &mut self,
tc_in_store_with_token: ReceivedTcWrapper, tc: PusTc,
_tc_guard: PoolGuard,
token: VerificationToken<TcStateAccepted>,
) -> Result<PusPacketHandlerResult, PusPacketHandlingError> { ) -> Result<PusPacketHandlerResult, PusPacketHandlingError> {
let ReceivedTcWrapper {
tc,
pool_guard,
token,
} = tc_in_store_with_token;
if tc.service() != 17 { if tc.service() != 17 {
return Err(PusPacketHandlingError::WrongService(tc.service())); return Err(PusPacketHandlingError::WrongService(tc.service()));
} }
@ -99,7 +95,7 @@ impl PusServiceHandler for PusService17TestHandler {
} }
Ok(PusPacketHandlerResult::CustomSubservice( Ok(PusPacketHandlerResult::CustomSubservice(
tc.subservice(), tc.subservice(),
token, token.into(),
)) ))
} }
} }