rust/sat-rs
rust/sat-rs
5
1
Fork 0
Code Issues 9 Pull Requests Projects Releases 22 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::pool::{SharedPool, StoreAddr};
use crate::pool::{PoolGuard, SharedPool, StoreAddr};
use crate::pus::event_man::{EventRequest, EventRequestWithToken};
use crate::pus::verification::{
StdVerifReporterWithSender, TcStateAccepted, TcStateToken, VerificationToken,
@ -44,22 +44,16 @@ impl PusServiceHandler for PusService5EventHandler {
fn handle_one_tc(
&mut self,
tc_in_store_with_token: ReceivedTcWrapper,
tc: PusTc,
_tc_guard: PoolGuard,
token: VerificationToken<TcStateAccepted>,
) -> 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 srv = Subservice::try_from(subservice);
if srv.is_err() {
return Ok(PusPacketHandlerResult::CustomSubservice(
tc.subservice(),
token,
token.into(),
));
}
let handle_enable_disable_request = |enable: bool, stamp: [u8; 7]| {
@ -74,7 +68,7 @@ impl PusServiceHandler for PusService5EventHandler {
.psb
.verification_handler
.borrow_mut()
.start_success(accepted_token, Some(&stamp))
.start_success(token, Some(&stamp))
.map_err(|_| PartialPusHandlingError::Verification);
let partial_error = start_token.clone().err();
let mut token: TcStateToken = token.into();
@ -121,7 +115,8 @@ impl PusServiceHandler for PusService5EventHandler {
}
Subservice::TcReportDisabledList | Subservice::TmDisabledEventsReport => {
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")]
pub mod std_mod {
use crate::pool::{SharedPool, StoreAddr};
use crate::pool::{PoolGuard, SharedPool, StoreAddr};
use crate::pus::verification::{
StdVerifReporterWithSender, TcStateAccepted, TcStateToken, VerificationToken,
};
@ -394,11 +394,12 @@ pub mod std_mod {
TryRecvError::Empty => GenericRecvError::Empty,
TryRecvError::Disconnected => GenericRecvError::TxDisconnected,
})?;
let shared_tc_pool = self
let mut shared_tc_pool = self
.shared_tc_pool
.read()
.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() {
return Err(
PusError::ByteConversion(ByteConversionError::ToSliceTooSmall(SizeMissmatch {
@ -410,7 +411,11 @@ pub mod std_mod {
}
buf[..tc_raw.len()].copy_from_slice(tc_raw);
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),
#[error("generic ECSS tmtc error: {0}")]
EcssTmtc(#[from] EcssTmtcError),
#[error("invalid verification token")]
InvalidVerificationToken,
#[error("other error {0}")]
Other(String),
}
@ -564,30 +571,31 @@ pub mod std_mod {
fn psb(&self) -> &PusServiceBase;
fn handle_one_tc(
&mut self,
tc_in_store_with_token: ReceivedTcWrapper,
tc: PusTc,
tc_guard: PoolGuard,
token: VerificationToken<TcStateAccepted>,
) -> 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> {
match self.psb().tc_receiver.recv_tc()? {
Ok((addr, token)) => self.handle_one_tc(addr, token),
match self.psb().tc_receiver.recv_tc(&mut self.psb_mut().pus_buf) {
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 {
TryRecvError::Empty => Ok(PusPacketHandlerResult::Empty),
TryRecvError::Disconnected => Err(PusPacketHandlingError::EcssTmtc(
EcssTmtcError::Recv(GenericRecvError::TxDisconnected),
)),
EcssTmtcError::StoreLock => {}
EcssTmtcError::Store(_) => {}
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::verification::{StdVerifReporterWithSender, TcStateAccepted, VerificationToken};
use crate::pus::{
@ -21,6 +21,7 @@ use std::sync::mpsc::Receiver;
/// telecommands when applicable.
pub struct PusService11SchedHandler {
psb: PusServiceBase,
shared_tc_store: SharedPool,
scheduler: PusScheduler,
}
@ -30,10 +31,12 @@ impl PusService11SchedHandler {
tm_sender: Box<dyn EcssTmSender>,
tm_apid: u16,
verification_handler: StdVerifReporterWithSender,
shared_tc_store: SharedPool,
scheduler: PusScheduler,
) -> Self {
Self {
psb: PusServiceBase::new(tc_receiver, tm_sender, tm_apid, verification_handler),
shared_tc_store,
scheduler,
}
}
@ -57,18 +60,15 @@ impl PusServiceHandler for PusService11SchedHandler {
fn handle_one_tc(
&mut self,
tc_in_store_with_token: ReceivedTcWrapper,
tc: PusTc,
tc_guard: PoolGuard,
token: VerificationToken<TcStateAccepted>,
) -> Result<PusPacketHandlerResult, PusPacketHandlingError> {
let ReceivedTcWrapper {
tc,
pool_guard,
token,
} = tc_in_store_with_token;
let std_service = scheduling::Subservice::try_from(tc.subservice());
if std_service.is_err() {
return Ok(PusPacketHandlerResult::CustomSubservice(
tc.subservice(),
token,
token.into(),
));
}
let mut partial_error = None;
@ -120,7 +120,7 @@ impl PusServiceHandler for PusService11SchedHandler {
.start_success(token, Some(&time_stamp))
.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
.reset(pool.as_mut())
@ -140,7 +140,7 @@ impl PusServiceHandler for PusService11SchedHandler {
.start_success(token, Some(&time_stamp))
.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
.insert_wrapped_tc::<TimeProvider>(&tc, pool.as_mut())
.expect("insertion of activity into pool failed");
@ -154,7 +154,7 @@ impl PusServiceHandler for PusService11SchedHandler {
_ => {
return Ok(PusPacketHandlerResult::CustomSubservice(
tc.subservice(),
token,
token.into(),
));
}
}
@ -165,7 +165,7 @@ impl PusServiceHandler for PusService11SchedHandler {
}
Ok(PusPacketHandlerResult::CustomSubservice(
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::{
AcceptedTc, EcssTmSender, PartialPusHandlingError, PusPacketHandlerResult,
AcceptedTc, EcssTcReceiver, EcssTmSender, PartialPusHandlingError, PusPacketHandlerResult,
PusPacketHandlingError, PusServiceBase, PusServiceHandler, PusTmWrapper, ReceivedTcWrapper,
};
use spacepackets::ecss::PusPacket;
@ -19,14 +19,13 @@ pub struct PusService17TestHandler {
impl PusService17TestHandler {
pub fn new(
receiver: Receiver<AcceptedTc>,
tc_pool: SharedPool,
tc_receiver: Box<dyn EcssTcReceiver>,
tm_sender: Box<dyn EcssTmSender>,
tm_apid: u16,
verification_handler: StdVerifReporterWithSender,
) -> 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(
&mut self,
tc_in_store_with_token: ReceivedTcWrapper,
tc: PusTc,
_tc_guard: PoolGuard,
token: VerificationToken<TcStateAccepted>,
) -> Result<PusPacketHandlerResult, PusPacketHandlingError> {
let ReceivedTcWrapper {
tc,
pool_guard,
token,
} = tc_in_store_with_token;
if tc.service() != 17 {
return Err(PusPacketHandlingError::WrongService(tc.service()));
}
@ -99,7 +95,7 @@ impl PusServiceHandler for PusService17TestHandler {
}
Ok(PusPacketHandlerResult::CustomSubservice(
tc.subservice(),
token,
token.into(),
))
}
}