diff --git a/satrs-example/src/pus/mod.rs b/satrs-example/src/pus/mod.rs index a545b6b..08c2bf4 100644 --- a/satrs-example/src/pus/mod.rs +++ b/satrs-example/src/pus/mod.rs @@ -9,6 +9,7 @@ use satrs_core::spacepackets::time::TimeWriter; use satrs_example::{tmtc_err, CustomPusServiceId}; use std::sync::mpsc::Sender; +pub mod stack; pub mod action; pub mod event; pub mod hk; diff --git a/satrs-example/src/pus/stack.rs b/satrs-example/src/pus/stack.rs new file mode 100644 index 0000000..ead8273 --- /dev/null +++ b/satrs-example/src/pus/stack.rs @@ -0,0 +1,221 @@ +// Prototyping software. +/* +use std::{collections::HashMap, sync::mpsc, time::Duration}; + +use satrs_core::{ + events::EventU32, + params::Params, + pool::{SharedStaticMemoryPool, StaticMemoryPool, StoreAddr}, + pus::{ + event_man::EventRequestWithToken, event_srv::PusService5EventHandler, + scheduler::PusScheduler, scheduler_srv::PusService11SchedHandler, + test::PusService17TestHandler, verification::VerificationReporterWithSender, + EcssTcAndToken, EcssTcInSharedStoreConverter, MpscTcReceiver, MpscTmInStoreSender, + PusServiceHelper, + }, + tmtc::tm_helper::SharedTmStore, + ChannelId, +}; +use satrs_example::{TargetIdWithApid, TcReceiverId, TmSenderId, PUS_APID}; + +use crate::{requests::RequestWithToken, tmtc::PusTcSource}; + +use super::{ + action::{Pus8Wrapper, PusService8ActionHandler}, + event::Pus5Wrapper, + hk::{Pus3Wrapper, PusService3HkHandler}, + scheduler::Pus11Wrapper, + test::Service17CustomWrapper, + PusTcMpscRouter, +}; + +pub struct PusStack { + event_srv: Pus5Wrapper, + hk_srv: Pus3Wrapper, + action_srv: Pus8Wrapper, + schedule_srv: Pus11Wrapper, + test_srv: Service17CustomWrapper, +} + +impl PusStack { + pub fn test_service( + shared_tm_store: SharedTmStore, + tm_funnel_tx: mpsc::Sender, + verif_reporter: VerificationReporterWithSender, + tc_pool: SharedStaticMemoryPool, + event_sender: mpsc::Sender<(EventU32, Option)>, + ) -> (Service17CustomWrapper, mpsc::Sender) { + let (pus_test_tx, pus_test_rx) = mpsc::channel(); + let test_srv_tm_sender = MpscTmInStoreSender::new( + TmSenderId::PusTest as ChannelId, + "PUS_17_TM_SENDER", + shared_tm_store.clone(), + tm_funnel_tx.clone(), + ); + let test_srv_receiver = MpscTcReceiver::new( + TcReceiverId::PusTest as ChannelId, + "PUS_17_TC_RECV", + pus_test_rx, + ); + let pus17_handler = PusService17TestHandler::new(PusServiceHelper::new( + Box::new(test_srv_receiver), + Box::new(test_srv_tm_sender), + PUS_APID, + verif_reporter.clone(), + EcssTcInSharedStoreConverter::new(tc_pool, 2048), + )); + ( + Service17CustomWrapper { + pus17_handler, + test_srv_event_sender: event_sender, + }, + pus_test_tx, + ) + } + + pub fn new( + shared_tm_store: SharedTmStore, + tm_funnel_tx: mpsc::Sender, + sched_tc_pool: StaticMemoryPool, + tc_source_wrapper: PusTcSource, + verif_reporter: VerificationReporterWithSender, + event_sender: mpsc::Sender<(EventU32, Option)>, + event_request_tx: mpsc::Sender, + request_map: HashMap>, + ) -> (Self, PusTcMpscRouter) { + let (pus_event_tx, pus_event_rx) = mpsc::channel(); + let (pus_sched_tx, pus_sched_rx) = mpsc::channel(); + let (pus_hk_tx, pus_hk_rx) = mpsc::channel(); + let (pus_action_tx, pus_action_rx) = mpsc::channel(); + let tc_pool = tc_source_wrapper.clone_backing_pool(); + let pus_router = PusTcMpscRouter { + test_service_receiver: pus_test_tx, + event_service_receiver: pus_event_tx, + sched_service_receiver: pus_sched_tx, + hk_service_receiver: pus_hk_tx, + action_service_receiver: pus_action_tx, + }; + + let sched_srv_tm_sender = MpscTmInStoreSender::new( + TmSenderId::PusSched as ChannelId, + "PUS_11_TM_SENDER", + shared_tm_store.clone(), + tm_funnel_tx.clone(), + ); + let sched_srv_receiver = MpscTcReceiver::new( + TcReceiverId::PusSched as ChannelId, + "PUS_11_TC_RECV", + pus_sched_rx, + ); + let scheduler = PusScheduler::new_with_current_init_time(Duration::from_secs(5)) + .expect("Creating PUS Scheduler failed"); + let pus_11_handler = PusService11SchedHandler::new( + PusServiceHelper::new( + Box::new(sched_srv_receiver), + Box::new(sched_srv_tm_sender), + PUS_APID, + verif_reporter.clone(), + EcssTcInSharedStoreConverter::new(tc_source_wrapper.clone_backing_pool(), 2048), + ), + scheduler, + ); + let pus_11_wrapper = Pus11Wrapper { + pus_11_handler, + sched_tc_pool, + tc_source_wrapper, + }; + + let event_srv_tm_sender = MpscTmInStoreSender::new( + TmSenderId::PusEvent as ChannelId, + "PUS_5_TM_SENDER", + shared_tm_store.clone(), + tm_funnel_tx.clone(), + ); + let event_srv_receiver = MpscTcReceiver::new( + TcReceiverId::PusEvent as ChannelId, + "PUS_5_TC_RECV", + pus_event_rx, + ); + let pus_5_handler = PusService5EventHandler::new( + PusServiceHelper::new( + Box::new(event_srv_receiver), + Box::new(event_srv_tm_sender), + PUS_APID, + verif_reporter.clone(), + EcssTcInSharedStoreConverter::new(tc_pool.clone(), 2048), + ), + event_request_tx, + ); + let pus_5_wrapper = Pus5Wrapper { pus_5_handler }; + + let action_srv_tm_sender = MpscTmInStoreSender::new( + TmSenderId::PusAction as ChannelId, + "PUS_8_TM_SENDER", + shared_tm_store.clone(), + tm_funnel_tx.clone(), + ); + let action_srv_receiver = MpscTcReceiver::new( + TcReceiverId::PusAction as ChannelId, + "PUS_8_TC_RECV", + pus_action_rx, + ); + let pus_8_handler = PusService8ActionHandler::new( + Box::new(action_srv_receiver), + Box::new(action_srv_tm_sender), + PUS_APID, + verif_reporter.clone(), + EcssTcInSharedStoreConverter::new(tc_pool.clone(), 2048), + request_map.clone(), + ); + let pus_8_wrapper = Pus8Wrapper { pus_8_handler }; + + let hk_srv_tm_sender = MpscTmInStoreSender::new( + TmSenderId::PusHk as ChannelId, + "PUS_3_TM_SENDER", + shared_tm_store.clone(), + tm_funnel_tx.clone(), + ); + let hk_srv_receiver = + MpscTcReceiver::new(TcReceiverId::PusHk as ChannelId, "PUS_8_TC_RECV", pus_hk_rx); + let pus_3_handler = PusService3HkHandler::new( + Box::new(hk_srv_receiver), + Box::new(hk_srv_tm_sender), + PUS_APID, + verif_reporter.clone(), + EcssTcInSharedStoreConverter::new(tc_pool, 2048), + request_map, + ); + let pus_3_wrapper = Pus3Wrapper { pus_3_handler }; + ( + Self { + event_srv: pus_5_wrapper, + hk_srv: pus_3_wrapper, + action_srv: pus_8_wrapper, + schedule_srv: pus_11_wrapper, + test_srv: pus_17_wrapper, + }, + pus_router, + ) + } + + pub fn periodic_operation(&mut self) { + self.schedule_srv.release_tcs(); + loop { + let mut all_queues_empty = true; + let mut is_srv_finished = |srv_handler_finished: bool| { + if !srv_handler_finished { + all_queues_empty = false; + } + }; + is_srv_finished(self.test_srv.handle_next_packet()); + is_srv_finished(self.schedule_srv.handle_next_packet()); + is_srv_finished(self.event_srv.handle_next_packet()); + is_srv_finished(self.action_srv.handle_next_packet()); + is_srv_finished(self.hk_srv.handle_next_packet()); + if all_queues_empty { + break; + } + } + } +} +*/ diff --git a/satrs-example/src/tmtc.rs b/satrs-example/src/tmtc.rs index 9bbe1ba..99b7477 100644 --- a/satrs-example/src/tmtc.rs +++ b/satrs-example/src/tmtc.rs @@ -59,6 +59,13 @@ pub struct PusTcSource { pub tc_store: TcStore, } +impl PusTcSource { + #[allow(dead_code)] + pub fn clone_backing_pool(&self) -> SharedStaticMemoryPool { + self.tc_store.pool.clone() + } +} + impl ReceivesEcssPusTc for PusTcSource { type Error = MpscStoreAndSendError;