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

continue mode tree feature

Browse Source
This commit is contained in:
Robin Müller 2024-12-02 16:37:28 +01:00
parent a27e1e308d
commit 51e723a45f
5 changed files with 288 additions and 152 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

217
satrs/src/mode.rs
View File

@ -336,26 +336,51 @@ pub mod alloc_mod {
} }
impl< impl<
REQUEST, Request,
S0: MessageSenderProvider<REQUEST>, ReqSender: MessageSenderProvider<Request>,
R0: MessageReceiverProvider<ModeReply>, ReqReceiver: MessageReceiverProvider<Request>,
S1: MessageSenderProvider<ModeReply>, ReqSenderStore: MessageSenderStoreProvider<Request, ReqSender>,
R1: MessageReceiverProvider<REQUEST>, Reply,
> RequestAndReplySenderAndReceiver<REQUEST, ModeReply, S0, R0, S1, R1> ReplySender: MessageSenderProvider<Reply>,
ReplyReceiver: MessageReceiverProvider<Reply>,
ReplySenderStore: MessageSenderStoreProvider<Reply, ReplySender>,
>
RequestAndReplySenderAndReceiver<
Request,
ReqSender,
ReqReceiver,
ReqSenderStore,
Reply,
ReplySender,
ReplyReceiver,
ReplySenderStore,
>
{ {
pub fn add_reply_target(&mut self, target_id: ComponentId, reply_sender: S1) { pub fn add_reply_target(&mut self, target_id: ComponentId, reply_sender: ReplySender) {
self.reply_sender_map self.reply_sender_store
.add_message_target(target_id, reply_sender) .add_message_target(target_id, reply_sender)
} }
} }
impl< impl<
REQUEST, Request,
S0: MessageSenderProvider<REQUEST>, ReqSender: MessageSenderProvider<Request>,
R0: MessageReceiverProvider<ModeReply>, ReqReceiver: MessageReceiverProvider<Request>,
S1: MessageSenderProvider<ModeReply>, ReqSenderStore: MessageSenderStoreProvider<Request, ReqSender>,
R1: MessageReceiverProvider<REQUEST>, ReplySender: MessageSenderProvider<ModeReply>,
> ModeReplySender for RequestAndReplySenderAndReceiver<REQUEST, ModeReply, S0, R0, S1, R1> ReplyReceiver: MessageReceiverProvider<ModeReply>,
ReplySenderStore: MessageSenderStoreProvider<ModeReply, ReplySender>,
> ModeReplySender
for RequestAndReplySenderAndReceiver<
Request,
ReqSender,
ReqReceiver,
ReqSenderStore,
ModeReply,
ReplySender,
ReplyReceiver,
ReplySenderStore,
>
{ {
fn local_channel_id(&self) -> ComponentId { fn local_channel_id(&self) -> ComponentId {
self.local_channel_id_generic() self.local_channel_id_generic()
@ -364,24 +389,35 @@ pub mod alloc_mod {
fn send_mode_reply( fn send_mode_reply(
&self, &self,
requestor_info: MessageMetadata, requestor_info: MessageMetadata,
request: ModeReply, reply: ModeReply,
) -> Result<(), GenericTargetedMessagingError> { ) -> Result<(), GenericTargetedMessagingError> {
self.reply_sender_map.send_mode_reply( self.reply_sender_store.send_message(
MessageMetadata::new(requestor_info.request_id(), self.local_channel_id()), MessageMetadata::new(requestor_info.request_id(), self.local_channel_id()),
requestor_info.sender_id(), requestor_info.sender_id(),
request, reply,
) )
} }
} }
impl< impl<
REQUEST, Request,
S0: MessageSenderProvider<REQUEST>, ReqSender: MessageSenderProvider<Request>,
R0: MessageReceiverProvider<ModeReply>, ReqReceiver: MessageReceiverProvider<Request>,
S1: MessageSenderProvider<ModeReply>, ReqSenderStore: MessageSenderStoreProvider<Request, ReqSender>,
R1: MessageReceiverProvider<REQUEST>, ReplySender: MessageSenderProvider<ModeReply>,
ReplyReceiver: MessageReceiverProvider<ModeReply>,
ReplySenderStore: MessageSenderStoreProvider<ModeReply, ReplySender>,
> ModeReplyReceiver > ModeReplyReceiver
for RequestAndReplySenderAndReceiver<REQUEST, ModeReply, S0, R0, S1, R1> for RequestAndReplySenderAndReceiver<
Request,
ReqSender,
ReqReceiver,
ReqSenderStore,
ModeReply,
ReplySender,
ReplyReceiver,
ReplySenderStore,
>
{ {
fn try_recv_mode_reply( fn try_recv_mode_reply(
&self, &self,
@ -448,8 +484,23 @@ pub mod alloc_mod {
/// Helper type defintion for a mode handler object which can both send mode requests and /// Helper type defintion for a mode handler object which can both send mode requests and
/// process mode requests. /// process mode requests.
pub type ModeInterface<S0, R0, S1, R1> = pub type ModeInterface<
RequestAndReplySenderAndReceiver<ModeRequest, ModeReply, S0, R0, S1, R1>; ReqSender,
ReqReceiver,
ReqSenderStore,
ReplySender,
ReplyReceiver,
ReplySenderStore,
> = RequestAndReplySenderAndReceiver<
ModeRequest,
ReqSender,
ReqReceiver,
ReqSenderStore,
ModeReply,
ReplySender,
ReplyReceiver,
ReplySenderStore,
>;
impl<S: MessageSenderProvider<ModeRequest>> MessageSenderMap<ModeRequest, S> { impl<S: MessageSenderProvider<ModeRequest>> MessageSenderMap<ModeRequest, S> {
pub fn send_mode_request( pub fn send_mode_request(
@ -508,27 +559,50 @@ pub mod alloc_mod {
} }
impl< impl<
REPLY, ReqSender: MessageSenderProvider<ModeRequest>,
S0: MessageSenderProvider<ModeRequest>, ReqReceiver: MessageReceiverProvider<ModeRequest>,
R0: MessageReceiverProvider<REPLY>, ReqSenderStore: MessageSenderStoreProvider<ModeRequest, ReqSender>,
S1: MessageSenderProvider<REPLY>, Reply,
R1: MessageReceiverProvider<ModeRequest>, ReplySender: MessageSenderProvider<Reply>,
> RequestAndReplySenderAndReceiver<ModeRequest, REPLY, S0, R0, S1, R1> ReplyReceiver: MessageReceiverProvider<Reply>,
ReplySenderStore: MessageSenderStoreProvider<Reply, ReplySender>,
>
RequestAndReplySenderAndReceiver<
ModeRequest,
ReqSender,
ReqReceiver,
ReqSenderStore,
Reply,
ReplySender,
ReplyReceiver,
ReplySenderStore,
>
{ {
pub fn add_request_target(&mut self, target_id: ComponentId, request_sender: S0) { pub fn add_request_target(&mut self, target_id: ComponentId, request_sender: ReqSender) {
self.request_sender_map self.request_sender_store
.add_message_target(target_id, request_sender) .add_message_target(target_id, request_sender)
} }
} }
impl< impl<
REPLY, ReqSender: MessageSenderProvider<ModeRequest>,
S0: MessageSenderProvider<ModeRequest>, ReqReceiver: MessageReceiverProvider<ModeRequest>,
R0: MessageReceiverProvider<REPLY>, ReqSenderStore: MessageSenderStoreProvider<ModeRequest, ReqSender>,
S1: MessageSenderProvider<REPLY>, Reply,
R1: MessageReceiverProvider<ModeRequest>, ReplySender: MessageSenderProvider<Reply>,
ReplyReceiver: MessageReceiverProvider<Reply>,
ReplySenderStore: MessageSenderStoreProvider<Reply, ReplySender>,
> ModeRequestSender > ModeRequestSender
for RequestAndReplySenderAndReceiver<ModeRequest, REPLY, S0, R0, S1, R1> for RequestAndReplySenderAndReceiver<
ModeRequest,
ReqSender,
ReqReceiver,
ReqSenderStore,
Reply,
ReplySender,
ReplyReceiver,
ReplySenderStore,
>
{ {
fn local_channel_id(&self) -> ComponentId { fn local_channel_id(&self) -> ComponentId {
self.local_channel_id_generic() self.local_channel_id_generic()
@ -540,7 +614,7 @@ pub mod alloc_mod {
target_id: ComponentId, target_id: ComponentId,
request: ModeRequest, request: ModeRequest,
) -> Result<(), GenericTargetedMessagingError> { ) -> Result<(), GenericTargetedMessagingError> {
self.request_sender_map.send_mode_request( self.request_sender_store.send_message(
MessageMetadata::new(request_id, self.local_channel_id()), MessageMetadata::new(request_id, self.local_channel_id()),
target_id, target_id,
request, request,
@ -549,13 +623,24 @@ pub mod alloc_mod {
} }
impl< impl<
REPLY, ReqSender: MessageSenderProvider<ModeRequest>,
S0: MessageSenderProvider<ModeRequest>, ReqReceiver: MessageReceiverProvider<ModeRequest>,
R0: MessageReceiverProvider<REPLY>, ReqSenderStore: MessageSenderStoreProvider<ModeRequest, ReqSender>,
S1: MessageSenderProvider<REPLY>, Reply,
R1: MessageReceiverProvider<ModeRequest>, ReplySender: MessageSenderProvider<Reply>,
ReplyReceiver: MessageReceiverProvider<Reply>,
ReplySenderStore: MessageSenderStoreProvider<Reply, ReplySender>,
> ModeRequestReceiver > ModeRequestReceiver
for RequestAndReplySenderAndReceiver<ModeRequest, REPLY, S0, R0, S1, R1> for RequestAndReplySenderAndReceiver<
ModeRequest,
ReqSender,
ReqReceiver,
ReqSenderStore,
Reply,
ReplySender,
ReplyReceiver,
ReplySenderStore,
>
{ {
fn try_recv_mode_request( fn try_recv_mode_request(
&self, &self,
@ -573,15 +658,15 @@ pub mod std_mod {
use super::*; use super::*;
pub type ModeRequestHandlerOneParentMpsc = ModeRequestHandlerInterface< pub type ModeRequestHandlerMpsc = ModeRequestHandlerInterface<
mpsc::Sender<GenericMessage<ModeReply>>, mpsc::Sender<GenericMessage<ModeReply>>,
mpsc::Receiver<GenericMessage<ModeRequest>>, mpsc::Receiver<GenericMessage<ModeRequest>>,
OneMessageSender<ModeReply, mpsc::Sender<GenericMessage<ModeReply>>>, MessageSenderList<ModeReply, mpsc::Sender<GenericMessage<ModeReply>>>,
>; >;
pub type ModeRequestHandlerOneParentMpscBounded = ModeRequestHandlerInterface< pub type ModeRequestHandlerMpscBounded = ModeRequestHandlerInterface<
mpsc::SyncSender<GenericMessage<ModeReply>>, mpsc::SyncSender<GenericMessage<ModeReply>>,
mpsc::Receiver<GenericMessage<ModeRequest>>, mpsc::Receiver<GenericMessage<ModeRequest>>,
OneMessageSender<ModeReply, mpsc::SyncSender<GenericMessage<ModeReply>>>, MessageSenderList<ModeReply, mpsc::SyncSender<GenericMessage<ModeReply>>>,
>; >;
pub type ModeRequestorOneChildMpsc = ModeRequestorInterface< pub type ModeRequestorOneChildMpsc = ModeRequestorInterface<
@ -592,36 +677,34 @@ pub mod std_mod {
pub type ModeRequestorOneChildBoundedMpsc = ModeRequestorInterface< pub type ModeRequestorOneChildBoundedMpsc = ModeRequestorInterface<
mpsc::SyncSender<GenericMessage<ModeRequest>>, mpsc::SyncSender<GenericMessage<ModeRequest>>,
mpsc::Receiver<GenericMessage<ModeReply>>, mpsc::Receiver<GenericMessage<ModeReply>>,
OneMessageSender< OneMessageSender<ModeRequest, mpsc::SyncSender<GenericMessage<ModeRequest>>>,
ModeRequest,
mpsc::SyncSender<GenericMessage<ModeRequest>>,
>,
>; >;
pub type ModeRequestorMultiChildListMpsc = ModeRequestorInterface< pub type ModeRequestorChildListMpsc = ModeRequestorInterface<
mpsc::Sender<GenericMessage<ModeRequest>>, mpsc::Sender<GenericMessage<ModeRequest>>,
mpsc::Receiver<GenericMessage<ModeReply>>, mpsc::Receiver<GenericMessage<ModeReply>>,
MessageSenderList<ModeRequest, mpsc::Sender<GenericMessage<ModeRequest>>>, MessageSenderList<ModeRequest, mpsc::Sender<GenericMessage<ModeRequest>>>,
>; >;
pub type ModeRequestorMultiChildListBoundedMpsc = ModeRequestorInterface< pub type ModeRequestorChildListBoundedMpsc = ModeRequestorInterface<
mpsc::SyncSender<GenericMessage<ModeRequest>>, mpsc::SyncSender<GenericMessage<ModeRequest>>,
mpsc::Receiver<GenericMessage<ModeReply>>, mpsc::Receiver<GenericMessage<ModeReply>>,
MessageSenderList< MessageSenderList<ModeRequest, mpsc::SyncSender<GenericMessage<ModeRequest>>>,
ModeRequest,
mpsc::SyncSender<GenericMessage<ModeRequest>>,
>,
>; >;
pub type ModeRequestorAndHandlerOneParentMpsc = ModeInterface< pub type ModeRequestorAndHandlerMpsc = ModeInterface<
mpsc::Sender<GenericMessage<ModeRequest>>, mpsc::Sender<GenericMessage<ModeRequest>>,
mpsc::Receiver<GenericMessage<ModeReply>>, mpsc::Receiver<GenericMessage<ModeRequest>>,
MessageSenderList<ModeRequest, mpsc::Sender<GenericMessage<ModeRequest>>>,
mpsc::Sender<GenericMessage<ModeReply>>, mpsc::Sender<GenericMessage<ModeReply>>,
mpsc::Receiver<GenericMessage<ModeRequest>>,
>;
pub type ModeRequestorAndHandlerOneParentMpscBounded = ModeInterface<
mpsc::SyncSender<GenericMessage<ModeRequest>>,
mpsc::Receiver<GenericMessage<ModeReply>>, mpsc::Receiver<GenericMessage<ModeReply>>,
mpsc::SyncSender<GenericMessage<ModeReply>>, MessageSenderList<ModeReply, mpsc::Sender<GenericMessage<ModeReply>>>,
>;
pub type ModeRequestorAndHandlerMpscBounded = ModeInterface<
mpsc::SyncSender<GenericMessage<ModeRequest>>,
mpsc::Receiver<GenericMessage<ModeRequest>>, mpsc::Receiver<GenericMessage<ModeRequest>>,
MessageSenderList<ModeRequest, mpsc::SyncSender<GenericMessage<ModeRequest>>>,
mpsc::SyncSender<GenericMessage<ModeReply>>,
mpsc::Receiver<GenericMessage<ModeReply>>,
MessageSenderList<ModeReply, mpsc::SyncSender<GenericMessage<ModeReply>>>,
>; >;
} }

3
satrs/src/pus/mode.rs
View File

@ -52,7 +52,8 @@ mod tests {
fn test_simple_mode_requestor() { fn test_simple_mode_requestor() {
let (reply_sender, reply_receiver) = mpsc::channel(); let (reply_sender, reply_receiver) = mpsc::channel();
let (request_sender, request_receiver) = mpsc::channel(); let (request_sender, request_receiver) = mpsc::channel();
let mut mode_requestor = ModeRequestorOneChildMpsc::new(TEST_COMPONENT_ID_0, reply_receiver); let mut mode_requestor =
ModeRequestorOneChildMpsc::new(TEST_COMPONENT_ID_0, reply_receiver);
mode_requestor.add_message_target(TEST_COMPONENT_ID_1, request_sender); mode_requestor.add_message_target(TEST_COMPONENT_ID_1, request_sender);
// Send a request and verify it arrives at the receiver. // Send a request and verify it arrives at the receiver.

87
satrs/src/request.rs
View File

@ -149,9 +149,9 @@ pub trait MessageReceiverProvider<MSG> {
fn try_recv(&self) -> Result<Option<GenericMessage<MSG>>, GenericTargetedMessagingError>; fn try_recv(&self) -> Result<Option<GenericMessage<MSG>>, GenericTargetedMessagingError>;
} }
pub struct MessageWithSenderIdReceiver<MSG, R: MessageReceiverProvider<MSG>>( pub struct MessageWithSenderIdReceiver<Msg, Receiver: MessageReceiverProvider<Msg>>(
pub R, pub Receiver,
PhantomData<MSG>, PhantomData<Msg>,
); );
impl<MSG, R: MessageReceiverProvider<MSG>> From<R> for MessageWithSenderIdReceiver<MSG, R> { impl<MSG, R: MessageReceiverProvider<MSG>> From<R> for MessageWithSenderIdReceiver<MSG, R> {
@ -208,6 +208,7 @@ pub trait MessageSenderStoreProvider<Message, Sender>: Default {
#[cfg(feature = "alloc")] #[cfg(feature = "alloc")]
pub mod alloc_mod { pub mod alloc_mod {
use crate::queue::GenericSendError; use crate::queue::GenericSendError;
use std::convert::From;
use super::*; use super::*;
use hashbrown::HashMap; use hashbrown::HashMap;
@ -226,10 +227,10 @@ pub mod alloc_mod {
} }
} }
impl<Msg, S: MessageSenderProvider<Msg>> MessageSenderStoreProvider<Msg, S> impl<Msg, Sender: MessageSenderProvider<Msg>> MessageSenderStoreProvider<Msg, Sender>
for OneMessageSender<Msg, S> for OneMessageSender<Msg, Sender>
{ {
fn add_message_target(&mut self, target_id: ComponentId, message_sender: S) { fn add_message_target(&mut self, target_id: ComponentId, message_sender: Sender) {
if self.id_and_sender.is_some() { if self.id_and_sender.is_some() {
return; return;
} }
@ -263,10 +264,10 @@ pub mod alloc_mod {
} }
} }
impl<MSG, S: MessageSenderProvider<MSG>> MessageSenderStoreProvider<MSG, S> impl<Msg, Sender: MessageSenderProvider<Msg>> MessageSenderStoreProvider<Msg, Sender>
for MessageSenderList<MSG, S> for MessageSenderList<Msg, Sender>
{ {
fn add_message_target(&mut self, target_id: ComponentId, message_sender: S) { fn add_message_target(&mut self, target_id: ComponentId, message_sender: Sender) {
self.0.push((target_id, message_sender)); self.0.push((target_id, message_sender));
} }
@ -274,7 +275,7 @@ pub mod alloc_mod {
&self, &self,
requestor_info: MessageMetadata, requestor_info: MessageMetadata,
target_channel_id: ComponentId, target_channel_id: ComponentId,
message: MSG, message: Msg,
) -> Result<(), GenericTargetedMessagingError> { ) -> Result<(), GenericTargetedMessagingError> {
for (current_id, sender) in &self.0 { for (current_id, sender) in &self.0 {
if *current_id == target_channel_id { if *current_id == target_channel_id {
@ -297,10 +298,10 @@ pub mod alloc_mod {
} }
} }
impl<MSG, S: MessageSenderProvider<MSG>> MessageSenderStoreProvider<MSG, S> impl<Msg, Sender: MessageSenderProvider<Msg>> MessageSenderStoreProvider<Msg, Sender>
for MessageSenderMap<MSG, S> for MessageSenderMap<Msg, Sender>
{ {
fn add_message_target(&mut self, target_id: ComponentId, message_sender: S) { fn add_message_target(&mut self, target_id: ComponentId, message_sender: Sender) {
self.0.insert(target_id, message_sender); self.0.insert(target_id, message_sender);
} }
@ -308,7 +309,7 @@ pub mod alloc_mod {
&self, &self,
requestor_info: MessageMetadata, requestor_info: MessageMetadata,
target_channel_id: ComponentId, target_channel_id: ComponentId,
message: MSG, message: Msg,
) -> Result<(), GenericTargetedMessagingError> { ) -> Result<(), GenericTargetedMessagingError> {
if self.0.contains_key(&target_channel_id) { if self.0.contains_key(&target_channel_id) {
return self return self
@ -383,42 +384,58 @@ pub mod alloc_mod {
} }
pub struct RequestAndReplySenderAndReceiver< pub struct RequestAndReplySenderAndReceiver<
REQUEST, Request,
REPLY, ReqSender: MessageSenderProvider<Request>,
S0: MessageSenderProvider<REQUEST>, ReqReceiver: MessageReceiverProvider<Request>,
R0: MessageReceiverProvider<REPLY>, ReqSenderStore: MessageSenderStoreProvider<Request, ReqSender>,
S1: MessageSenderProvider<REPLY>, Reply,
R1: MessageReceiverProvider<REQUEST>, ReplySender: MessageSenderProvider<Reply>,
ReplyReceiver: MessageReceiverProvider<Reply>,
ReplySenderStore: MessageSenderStoreProvider<Reply, ReplySender>,
> { > {
pub local_channel_id: ComponentId, pub local_channel_id: ComponentId,
// These 2 are a functional group. // These 2 are a functional group.
pub request_sender_map: MessageSenderMap<REQUEST, S0>, pub request_sender_store: ReqSenderStore,
pub reply_receiver: MessageWithSenderIdReceiver<REPLY, R0>, pub reply_receiver: MessageWithSenderIdReceiver<Reply, ReplyReceiver>,
// These 2 are a functional group. // These 2 are a functional group.
pub request_receiver: MessageWithSenderIdReceiver<REQUEST, R1>, pub request_receiver: MessageWithSenderIdReceiver<Request, ReqReceiver>,
pub reply_sender_map: MessageSenderMap<REPLY, S1>, pub reply_sender_store: ReplySenderStore,
phantom: PhantomData<(ReqSender, ReplySender)>,
} }
impl< impl<
REQUEST, Request,
REPLY, ReqSender: MessageSenderProvider<Request>,
S0: MessageSenderProvider<REQUEST>, ReqReceiver: MessageReceiverProvider<Request>,
R0: MessageReceiverProvider<REPLY>, ReqSenderStore: MessageSenderStoreProvider<Request, ReqSender>,
S1: MessageSenderProvider<REPLY>, Reply,
R1: MessageReceiverProvider<REQUEST>, ReplySender: MessageSenderProvider<Reply>,
> RequestAndReplySenderAndReceiver<REQUEST, REPLY, S0, R0, S1, R1> ReplyReceiver: MessageReceiverProvider<Reply>,
ReplySenderStore: MessageSenderStoreProvider<Reply, ReplySender>,
>
RequestAndReplySenderAndReceiver<
Request,
ReqSender,
ReqReceiver,
ReqSenderStore,
Reply,
ReplySender,
ReplyReceiver,
ReplySenderStore,
>
{ {
pub fn new( pub fn new(
local_channel_id: ComponentId, local_channel_id: ComponentId,
request_receiver: R1, request_receiver: ReqReceiver,
reply_receiver: R0, reply_receiver: ReplyReceiver,
) -> Self { ) -> Self {
Self { Self {
local_channel_id, local_channel_id,
request_receiver: request_receiver.into(), request_receiver: request_receiver.into(),
reply_receiver: reply_receiver.into(), reply_receiver: reply_receiver.into(),
request_sender_map: Default::default(), request_sender_store: Default::default(),
reply_sender_map: Default::default(), reply_sender_store: Default::default(),
phantom: PhantomData,
} }
} }

24
satrs/src/tmtc/tm_helper.rs
View File

@ -17,37 +17,37 @@ impl PusTmWithCdsShortHelper {
} }
#[cfg(feature = "std")] #[cfg(feature = "std")]
pub fn create_pus_tm_timestamp_now<'a>( pub fn create_pus_tm_timestamp_now<'time, 'src_data>(
&'a mut self, &'time mut self,
service: u8, service: u8,
subservice: u8, subservice: u8,
source_data: &'a [u8], source_data: &'src_data [u8],
seq_count: u16, seq_count: u16,
) -> PusTmCreator { ) -> PusTmCreator<'time, 'src_data> {
let time_stamp = CdsTime::now_with_u16_days().unwrap(); let time_stamp = CdsTime::now_with_u16_days().unwrap();
time_stamp.write_to_bytes(&mut self.cds_short_buf).unwrap(); time_stamp.write_to_bytes(&mut self.cds_short_buf).unwrap();
self.create_pus_tm_common(service, subservice, source_data, seq_count) self.create_pus_tm_common(service, subservice, source_data, seq_count)
} }
pub fn create_pus_tm_with_stamper<'a>( pub fn create_pus_tm_with_stamper<'time, 'src_data>(
&'a mut self, &'time mut self,
service: u8, service: u8,
subservice: u8, subservice: u8,
source_data: &'a [u8], source_data: &'src_data [u8],
stamper: &CdsTime, stamper: &CdsTime,
seq_count: u16, seq_count: u16,
) -> PusTmCreator { ) -> PusTmCreator<'time, 'src_data> {
stamper.write_to_bytes(&mut self.cds_short_buf).unwrap(); stamper.write_to_bytes(&mut self.cds_short_buf).unwrap();
self.create_pus_tm_common(service, subservice, source_data, seq_count) self.create_pus_tm_common(service, subservice, source_data, seq_count)
} }
fn create_pus_tm_common<'a>( fn create_pus_tm_common<'time, 'src_data>(
&'a self, &'time self,
service: u8, service: u8,
subservice: u8, subservice: u8,
source_data: &'a [u8], source_data: &'src_data [u8],
seq_count: u16, seq_count: u16,
) -> PusTmCreator { ) -> PusTmCreator<'time, 'src_data> {
let reply_header = SpHeader::new_for_unseg_tm(self.apid, seq_count, 0); let reply_header = SpHeader::new_for_unseg_tm(self.apid, seq_count, 0);
let tc_header = PusTmSecondaryHeader::new_simple(service, subservice, &self.cds_short_buf); let tc_header = PusTmSecondaryHeader::new_simple(service, subservice, &self.cds_short_buf);
PusTmCreator::new(reply_header, tc_header, source_data, true) PusTmCreator::new(reply_header, tc_header, source_data, true)

109
satrs/tests/mode_tree.rs
View File

@ -1,8 +1,12 @@
use core::cell::Cell; use core::cell::Cell;
use satrs::mode::{Mode, ModeError, ModeProvider, ModeReplyReceiver, ModeReplySender, ModeRequestHandler, ModeRequestHandlerOneParentMpscBounded, ModeRequestReceiver, ModeRequestSender, ModeRequestorAndHandlerOneParentMpscBounded, ModeRequestorOneChildBoundedMpsc}; use satrs::mode::{
Mode, ModeError, ModeProvider, ModeReplyReceiver, ModeReplySender, ModeRequestHandler,
ModeRequestHandlerMpscBounded, ModeRequestReceiver, ModeRequestorAndHandlerMpscBounded,
ModeRequestorOneChildBoundedMpsc,
};
use satrs::mode_tree::{ use satrs::mode_tree::{
connect_mode_nodes, ModeChild, ModeNode, ModeParent, ModeStoreProvider, SequenceTableMapTable, connect_mode_nodes, ModeChild, ModeNode, ModeParent, ModeStoreProvider, SequenceTableEntry,
TargetTableEntry, SequenceTableMapTable, TargetTableEntry,
}; };
use satrs::mode_tree::{ use satrs::mode_tree::{
ModeStoreVec, SequenceModeTables, SequenceTablesMapValue, TargetModeTables, ModeStoreVec, SequenceModeTables, SequenceTablesMapValue, TargetModeTables,
@ -187,17 +191,17 @@ impl ModeParent for PusModeService {
} }
struct AcsSubsystem { struct AcsSubsystem {
pub mode_node: ModeRequestorAndHandlerOneParentMpscBounded, pub mode_node: ModeRequestorAndHandlerMpscBounded,
pub mode_requestor_info: Option<MessageMetadata>, pub mode_requestor_info: Option<MessageMetadata>,
pub mode_and_submode: ModeAndSubmode, pub mode_and_submode: ModeAndSubmode,
pub target_mode_and_submode: Option<ModeAndSubmode>, pub target_mode_and_submode: Option<ModeAndSubmode>,
pub subsystem_helper: SubsystemHelper, pub subsystem_helper: SubsystemHelper,
pub mode_req_handler_mock: ModeRequestHandlerMock, pub mode_req_handler_mock: ModeRequestHandlerMock,
pub mode_msgs_recvd: u32, pub mode_req_recvd: u32,
} }
impl AcsSubsystem { impl AcsSubsystem {
pub fn new(mode_node: ModeRequestorAndHandlerOneParentMpscBounded) -> Self { pub fn new(mode_node: ModeRequestorAndHandlerMpscBounded) -> Self {
Self { Self {
mode_node, mode_node,
mode_requestor_info: None, mode_requestor_info: None,
@ -205,23 +209,23 @@ impl AcsSubsystem {
target_mode_and_submode: None, target_mode_and_submode: None,
subsystem_helper: Default::default(), subsystem_helper: Default::default(),
mode_req_handler_mock: Default::default(), mode_req_handler_mock: Default::default(),
mode_msgs_recvd: 0, mode_req_recvd: 0,
} }
} }
pub fn get_and_clear_num_mode_msgs(&mut self) -> u32 { pub fn get_and_clear_num_mode_requests(&mut self) -> u32 {
let tmp = self.mode_msgs_recvd; let tmp = self.mode_req_recvd;
self.mode_msgs_recvd = 0; self.mode_req_recvd = 0;
tmp tmp
} }
pub fn run(&mut self) { pub fn run(&mut self) {
if let Some(request) = self.mode_node.try_recv_mode_request().unwrap() { if let Some(request) = self.mode_node.try_recv_mode_request().unwrap() {
self.mode_msgs_recvd += 1; self.mode_req_recvd += 1;
self.handle_mode_request(request) self.handle_mode_request(request)
.expect("mode messaging error"); .expect("mode messaging error");
} }
if let Some(_reply) = self.mode_node.try_recv_mode_reply().unwrap(){ if let Some(_reply) = self.mode_node.try_recv_mode_reply().unwrap() {
// TODO: Implementation. // TODO: Implementation.
} }
} }
@ -298,7 +302,7 @@ impl ModeRequestHandler for AcsSubsystem {
} }
let request_id = requestor_info.map_or(0, |info| info.request_id()); let request_id = requestor_info.map_or(0, |info| info.request_id());
self.mode_node self.mode_node
.request_sender_map .request_sender_store
.0 .0
.iter() .iter()
.for_each(|(_, sender)| { .for_each(|(_, sender)| {
@ -354,7 +358,7 @@ impl ModeRequestHandler for AcsSubsystem {
} }
struct MgmAssembly { struct MgmAssembly {
pub mode_node: ModeRequestorAndHandlerOneParentMpscBounded, pub mode_node: ModeRequestorAndHandlerMpscBounded,
pub mode_requestor_info: Option<MessageMetadata>, pub mode_requestor_info: Option<MessageMetadata>,
pub mode_and_submode: ModeAndSubmode, pub mode_and_submode: ModeAndSubmode,
pub target_mode_and_submode: Option<ModeAndSubmode>, pub target_mode_and_submode: Option<ModeAndSubmode>,
@ -363,7 +367,7 @@ struct MgmAssembly {
} }
impl MgmAssembly { impl MgmAssembly {
pub fn new(mode_node: ModeRequestorAndHandlerOneParentMpscBounded) -> Self { pub fn new(mode_node: ModeRequestorAndHandlerMpscBounded) -> Self {
Self { Self {
mode_node, mode_node,
mode_requestor_info: None, mode_requestor_info: None,
@ -386,6 +390,7 @@ impl MgmAssembly {
pub fn check_mode_requests(&mut self) -> Result<(), GenericTargetedMessagingError> { pub fn check_mode_requests(&mut self) -> Result<(), GenericTargetedMessagingError> {
if let Some(request) = self.mode_node.try_recv_mode_request()? { if let Some(request) = self.mode_node.try_recv_mode_request()? {
self.mode_msgs_recvd += 1;
self.handle_mode_request(request).unwrap(); self.handle_mode_request(request).unwrap();
} }
Ok(()) Ok(())
@ -469,7 +474,7 @@ impl ModeRequestHandler for MgmAssembly {
} }
let request_id = requestor_info.map_or(0, |info| info.request_id()); let request_id = requestor_info.map_or(0, |info| info.request_id());
self.mode_node self.mode_node
.request_sender_map .request_sender_store
.0 .0
.iter() .iter()
.for_each(|(_, sender)| { .for_each(|(_, sender)| {
@ -524,17 +529,17 @@ impl ModeRequestHandler for MgmAssembly {
struct DeviceManager { struct DeviceManager {
name: &'static str, name: &'static str,
pub id: ComponentId, pub id: ComponentId,
pub mode_node: ModeRequestorAndHandlerOneParentMpscBounded, pub mode_node: ModeRequestorAndHandlerMpscBounded,
pub mode_and_submode: ModeAndSubmode, pub mode_and_submode: ModeAndSubmode,
pub mode_req_mock: ModeRequestHandlerMock, pub mode_req_mock: ModeRequestHandlerMock,
pub mode_msgs_recvd: u32, pub mode_req_recvd: u32,
} }
impl DeviceManager { impl DeviceManager {
pub fn new( pub fn new(
name: &'static str, name: &'static str,
id: ComponentId, id: ComponentId,
mode_node: ModeRequestorAndHandlerOneParentMpscBounded, mode_node: ModeRequestorAndHandlerMpscBounded,
) -> Self { ) -> Self {
Self { Self {
name, name,
@ -542,13 +547,13 @@ impl DeviceManager {
mode_node, mode_node,
mode_and_submode: UNKNOWN_MODE, mode_and_submode: UNKNOWN_MODE,
mode_req_mock: Default::default(), mode_req_mock: Default::default(),
mode_msgs_recvd: 0, mode_req_recvd: 0,
} }
} }
pub fn get_and_clear_num_mode_msgs(&mut self) -> u32 { pub fn get_and_clear_num_mode_requests(&mut self) -> u32 {
let tmp = self.mode_msgs_recvd; let tmp = self.mode_req_recvd;
self.mode_msgs_recvd = 0; self.mode_req_recvd = 0;
tmp tmp
} }
@ -558,6 +563,7 @@ impl DeviceManager {
pub fn check_mode_requests(&mut self) -> Result<(), ModeError> { pub fn check_mode_requests(&mut self) -> Result<(), ModeError> {
if let Some(request) = self.mode_node.try_recv_mode_request()? { if let Some(request) = self.mode_node.try_recv_mode_request()? {
self.mode_req_recvd += 1;
self.handle_mode_request(request)? self.handle_mode_request(request)?
} }
Ok(()) Ok(())
@ -619,7 +625,7 @@ impl ModeRequestHandler for DeviceManager {
} }
let request_id = requestor_info.map_or(0, |info| info.request_id()); let request_id = requestor_info.map_or(0, |info| info.request_id());
self.mode_node self.mode_node
.request_sender_map .request_sender_store
.0 .0
.iter() .iter()
.for_each(|(_, sender)| { .for_each(|(_, sender)| {
@ -674,7 +680,7 @@ impl ModeRequestHandler for DeviceManager {
struct CommonDevice { struct CommonDevice {
name: &'static str, name: &'static str,
pub id: ComponentId, pub id: ComponentId,
pub mode_node: ModeRequestHandlerOneParentMpscBounded, pub mode_node: ModeRequestHandlerMpscBounded,
pub mode_and_submode: ModeAndSubmode, pub mode_and_submode: ModeAndSubmode,
pub mode_req_mock: ModeRequestHandlerMock, pub mode_req_mock: ModeRequestHandlerMock,
pub num_mode_msgs_recvd: u32, pub num_mode_msgs_recvd: u32,
@ -684,7 +690,7 @@ impl CommonDevice {
pub fn new( pub fn new(
name: &'static str, name: &'static str,
id: ComponentId, id: ComponentId,
mode_node: ModeRequestHandlerOneParentMpscBounded, mode_node: ModeRequestHandlerMpscBounded,
) -> Self { ) -> Self {
Self { Self {
name, name,
@ -804,7 +810,7 @@ pub struct AnnounceModeInfo {
} }
pub struct AcsController { pub struct AcsController {
pub mode_node: ModeRequestHandlerOneParentMpscBounded, pub mode_node: ModeRequestHandlerMpscBounded,
pub mode_and_submode: ModeAndSubmode, pub mode_and_submode: ModeAndSubmode,
pub announce_mode_queue: RefCell<VecDeque<AnnounceModeInfo>>, pub announce_mode_queue: RefCell<VecDeque<AnnounceModeInfo>>,
pub mode_req_mock: ModeRequestHandlerMock, pub mode_req_mock: ModeRequestHandlerMock,
@ -953,36 +959,36 @@ impl TreeTestbench {
); );
// Mode requestors and handlers. // Mode requestors and handlers.
let mgm_assy_node = ModeRequestorAndHandlerOneParentMpscBounded::new( let mgm_assy_node = ModeRequestorAndHandlerMpscBounded::new(
TestComponentId::MagnetometerAssembly as ComponentId, TestComponentId::MagnetometerAssembly as ComponentId,
request_receiver_mgm_assy, request_receiver_mgm_assy,
reply_receiver_mgm_assy, reply_receiver_mgm_assy,
); );
let mgt_dev_mgmt_node = ModeRequestorAndHandlerOneParentMpscBounded::new( let mgt_dev_mgmt_node = ModeRequestorAndHandlerMpscBounded::new(
TestComponentId::MgtDevManager as ComponentId, TestComponentId::MgtDevManager as ComponentId,
request_receiver_mgt_man, request_receiver_mgt_man,
reply_receiver_mgt_man, reply_receiver_mgt_man,
); );
let acs_subsystem_node = ModeRequestorAndHandlerOneParentMpscBounded::new( let acs_subsystem_node = ModeRequestorAndHandlerMpscBounded::new(
TestComponentId::AcsSubsystem as ComponentId, TestComponentId::AcsSubsystem as ComponentId,
request_receiver_acs_subsystem, request_receiver_acs_subsystem,
reply_receiver_acs_subsystem, reply_receiver_acs_subsystem,
); );
// Request handlers only. // Request handlers only.
let mgm_dev_node_0 = ModeRequestHandlerOneParentMpscBounded::new( let mgm_dev_node_0 = ModeRequestHandlerMpscBounded::new(
TestComponentId::MagnetometerDevice0 as ComponentId, TestComponentId::MagnetometerDevice0 as ComponentId,
request_receiver_mgm_dev_0, request_receiver_mgm_dev_0,
); );
let mgm_dev_node_1 = ModeRequestHandlerOneParentMpscBounded::new( let mgm_dev_node_1 = ModeRequestHandlerMpscBounded::new(
TestComponentId::MagnetometerDevice1 as ComponentId, TestComponentId::MagnetometerDevice1 as ComponentId,
request_receiver_mgm_dev_1, request_receiver_mgm_dev_1,
); );
let mgt_dev_node = ModeRequestHandlerOneParentMpscBounded::new( let mgt_dev_node = ModeRequestHandlerMpscBounded::new(
TestComponentId::MagnetorquerDevice as ComponentId, TestComponentId::MagnetorquerDevice as ComponentId,
request_receiver_mgt_dev, request_receiver_mgt_dev,
); );
let acs_ctrl_node = ModeRequestHandlerOneParentMpscBounded::new( let acs_ctrl_node = ModeRequestHandlerMpscBounded::new(
TestComponentId::AcsController as ComponentId, TestComponentId::AcsController as ComponentId,
request_receiver_acs_ctrl, request_receiver_acs_ctrl,
); );
@ -1036,9 +1042,35 @@ impl TreeTestbench {
ModeAndSubmode::new(DefaultMode::NORMAL as u32, 0), ModeAndSubmode::new(DefaultMode::NORMAL as u32, 0),
true, true,
)); ));
let sequence_tbl_safe_0 = SequenceTableMapTable::new("SAFE_SEQ_0_TBL"); target_table_safe.add_entry(TargetTableEntry::new_with_precise_submode(
let sequence_tbl_safe_1 = SequenceTableMapTable::new("SAFE_SEQ_1_TBL"); "MGT_MAN_NML",
let sequence_tbl_safe = SequenceTablesMapValue::new("SAFE_SEQ_TBL"); TestComponentId::MgtDevManager as u64,
ModeAndSubmode::new(DefaultMode::NORMAL as u32, 0),
true,
));
let mut sequence_tbl_safe_0 = SequenceTableMapTable::new("SAFE_SEQ_0_TBL");
sequence_tbl_safe_0.add_entry(SequenceTableEntry::new(
"SAFE_SEQ_0_MGM_A",
TestComponentId::MagnetometerAssembly as u64,
ModeAndSubmode::new(DefaultMode::NORMAL as Mode, 0),
false,
));
sequence_tbl_safe_0.add_entry(SequenceTableEntry::new(
"SAFE_SEQ_0_MGT_MAN",
TestComponentId::MgtDevManager as u64,
ModeAndSubmode::new(DefaultMode::NORMAL as Mode, 0),
false,
));
let mut sequence_tbl_safe_1 = SequenceTableMapTable::new("SAFE_SEQ_1_TBL");
sequence_tbl_safe_1.add_entry(SequenceTableEntry::new(
"SAFE_SEQ_1_ACS_CTRL",
TestComponentId::AcsController as u64,
ModeAndSubmode::new(AcsMode::IDLE as Mode, 0),
false,
));
let mut sequence_tbl_safe = SequenceTablesMapValue::new("SAFE_SEQ_TBL");
sequence_tbl_safe.add_sequence_table(sequence_tbl_safe_0);
sequence_tbl_safe.add_sequence_table(sequence_tbl_safe_1);
acs_subsystem.add_target_and_sequence_table( acs_subsystem.add_target_and_sequence_table(
AcsMode::SAFE as u32, AcsMode::SAFE as u32,
target_table_safe, target_table_safe,
@ -1154,6 +1186,7 @@ fn announce_recursively() {
tb.mgm_devs[1].run(); tb.mgm_devs[1].run();
tb.mgt_dev.run(); tb.mgt_dev.run();
} }
assert_eq!(tb.subsystem.get_and_clear_num_mode_requests(), 1);
let mut announces = tb let mut announces = tb
.subsystem .subsystem
.mode_req_handler_mock .mode_req_handler_mock
@ -1164,6 +1197,7 @@ fn announce_recursively() {
assert_eq!(tb.ctrl.mode_req_mock.start_transition_calls.len(), 0); assert_eq!(tb.ctrl.mode_req_mock.start_transition_calls.len(), 0);
assert_eq!(tb.ctrl.mode_and_submode(), UNKNOWN_MODE); assert_eq!(tb.ctrl.mode_and_submode(), UNKNOWN_MODE);
assert_eq!(announces.len(), 1); assert_eq!(announces.len(), 1);
assert_eq!(tb.mgm_assy.get_and_clear_num_mode_msgs(), 1);
announces = tb.mgm_assy.mode_req_mock.announce_mode_calls.borrow_mut(); announces = tb.mgm_assy.mode_req_mock.announce_mode_calls.borrow_mut();
assert_eq!(tb.mgm_assy.mode_req_mock.start_transition_calls.len(), 0); assert_eq!(tb.mgm_assy.mode_req_mock.start_transition_calls.len(), 0);
assert_eq!(tb.mgm_assy.mode_and_submode(), UNKNOWN_MODE); assert_eq!(tb.mgm_assy.mode_and_submode(), UNKNOWN_MODE);
@ -1181,6 +1215,7 @@ fn announce_recursively() {
assert_eq!(tb.mgt_dev.mode_req_mock.start_transition_calls.len(), 0); assert_eq!(tb.mgt_dev.mode_req_mock.start_transition_calls.len(), 0);
assert_eq!(tb.mgt_dev.mode_and_submode(), UNKNOWN_MODE); assert_eq!(tb.mgt_dev.mode_and_submode(), UNKNOWN_MODE);
assert_eq!(announces.len(), 1); assert_eq!(announces.len(), 1);
assert_eq!(tb.mgt_manager.get_and_clear_num_mode_requests(), 1);
announces = tb announces = tb
.mgt_manager .mgt_manager
.mode_req_mock .mode_req_mock