start gettign rid of generics

satrs-example/src/acs/mgm.rs

@@ -15,7 +15,7 @@ use std::sync::{Arc, Mutex};
 use std::time::Duration;
 
 use satrs::mode::{
-    ModeAndSubmode, ModeError, ModeProvider, ModeReply, ModeRequest, ModeRequestHandler,
+    ModeAndSubmode, ModeError, ModeProvider, ModeReply, ModeRequestHandler,
     ModeRequestHandlerMpscBounded,
 };
 use satrs::pus::{EcssTmSender, PusTmVariant};
@@ -25,6 +25,7 @@ use satrs_example::config::components::{NO_SENDER, PUS_MODE_SERVICE};
 use crate::hk::PusHkHelper;
 use crate::pus::hk::{HkReply, HkReplyVariant};
 use crate::requests::CompositeRequest;
+use crate::tm_sender::TmSender;
 
 use serde::{Deserialize, Serialize};
 
@@ -130,13 +131,6 @@ pub struct MgmData {
     pub z: f32,
 }
 
-pub struct MpscModeLeafInterface {
-    pub request_rx: mpsc::Receiver<GenericMessage<ModeRequest>>,
-    pub reply_to_pus_tx: mpsc::Sender<GenericMessage<ModeReply>>,
-    #[allow(dead_code)]
-    pub reply_to_parent_tx: mpsc::SyncSender<GenericMessage<ModeReply>>,
-}
-
 #[derive(Default)]
 pub struct BufWrapper {
     tx_buf: [u8; 32],
@@ -166,8 +160,6 @@ impl Default for ModeHelpers {
 #[derive(new)]
 #[allow(clippy::too_many_arguments)]
 pub struct MgmHandlerLis3Mdl<
-    ComInterface: SpiInterface,
-    TmSender: EcssTmSender,
     SwitchHelper: PowerSwitchInfo<PcduSwitch> + PowerSwitcherCommandSender<PcduSwitch>,
 > {
     id: UniqueApidTargetId,
@@ -177,7 +169,7 @@ pub struct MgmHandlerLis3Mdl<
     hk_reply_tx: mpsc::Sender<GenericMessage<HkReply>>,
     switch_helper: SwitchHelper,
     tm_sender: TmSender,
-    pub com_interface: ComInterface,
+    pub com_interface: SpiSimInterfaceWrapper,
     shared_mgm_set: Arc<Mutex<MgmData>>,
     #[new(value = "PusHkHelper::new(id)")]
     hk_helper: PusHkHelper,
@@ -189,11 +181,8 @@ pub struct MgmHandlerLis3Mdl<
     stamp_helper: TimestampHelper,
 }
 
-impl<
+impl<SwitchHelper: PowerSwitchInfo<PcduSwitch> + PowerSwitcherCommandSender<PcduSwitch>>
-        ComInterface: SpiInterface,
+    MgmHandlerLis3Mdl<SwitchHelper>
-        TmSender: EcssTmSender,
-        SwitchHelper: PowerSwitchInfo<PcduSwitch> + PowerSwitcherCommandSender<PcduSwitch>,
-    > MgmHandlerLis3Mdl<ComInterface, TmSender, SwitchHelper>
 {
     pub fn periodic_operation(&mut self) {
         self.stamp_helper.update_from_now();
@@ -367,22 +356,16 @@ impl<
     }
 }
 
-impl<
+impl<SwitchHelper: PowerSwitchInfo<PcduSwitch> + PowerSwitcherCommandSender<PcduSwitch>>
-        ComInterface: SpiInterface,
+    ModeProvider for MgmHandlerLis3Mdl<SwitchHelper>
-        TmSender: EcssTmSender,
-        SwitchHelper: PowerSwitchInfo<PcduSwitch> + PowerSwitcherCommandSender<PcduSwitch>,
-    > ModeProvider for MgmHandlerLis3Mdl<ComInterface, TmSender, SwitchHelper>
 {
     fn mode_and_submode(&self) -> ModeAndSubmode {
         self.mode_helpers.current
     }
 }
 
-impl<
+impl<SwitchHelper: PowerSwitchInfo<PcduSwitch> + PowerSwitcherCommandSender<PcduSwitch>>
-        ComInterface: SpiInterface,
+    ModeRequestHandler for MgmHandlerLis3Mdl<SwitchHelper>
-        TmSender: EcssTmSender,
-        SwitchHelper: PowerSwitchInfo<PcduSwitch> + PowerSwitcherCommandSender<PcduSwitch>,
-    > ModeRequestHandler for MgmHandlerLis3Mdl<ComInterface, TmSender, SwitchHelper>
 {
     type Error = ModeError;
 
@@ -469,10 +452,8 @@ impl<
 }
 
 impl<
-        ComInterface: SpiInterface,
-        TmSender: EcssTmSender,
         SwitchHelper: PowerSwitchInfo<PcduSwitch> + PowerSwitcherCommandSender<PcduSwitch>,
-    > ModeNode for MgmHandlerLis3Mdl<ComInterface, TmSender, SwitchHelper>
+    > ModeNode for MgmHandlerLis3Mdl<SwitchHelper>
 {
     fn id(&self) -> satrs::ComponentId {
         self.id.into()
@@ -480,10 +461,8 @@ impl<
 }
 
 impl<
-        ComInterface: SpiInterface,
-        TmSender: EcssTmSender,
         SwitchHelper: PowerSwitchInfo<PcduSwitch> + PowerSwitcherCommandSender<PcduSwitch>,
-    > ModeChild for MgmHandlerLis3Mdl<ComInterface, TmSender, SwitchHelper>
+    > ModeChild for MgmHandlerLis3Mdl<SwitchHelper>
 {
     type Sender = mpsc::SyncSender<GenericMessage<ModeReply>>;
 
@@ -535,6 +514,7 @@ mod tests {
         }
     }
 
+    #[allow(dead_code)]
     pub struct MgmTestbench {
         pub mode_request_tx: mpsc::SyncSender<GenericMessage<ModeRequest>>,
         pub mode_reply_rx_to_pus: mpsc::Receiver<GenericMessage<ModeReply>>,
@@ -542,8 +522,7 @@ mod tests {
         pub composite_request_tx: mpsc::Sender<GenericMessage<CompositeRequest>>,
         pub hk_reply_rx: mpsc::Receiver<GenericMessage<HkReply>>,
         pub tm_rx: mpsc::Receiver<PacketAsVec>,
-        pub handler:
+        pub handler: MgmHandlerLis3Mdl<TestSwitchHelper>,
-            MgmHandlerLis3Mdl<TestSpiInterface, mpsc::Sender<PacketAsVec>, TestSwitchHelper>,
     }
 
     #[derive(Default)]
@@ -593,7 +572,8 @@ mod tests {
             let mode_node = ModeRequestHandlerMpscBounded::new(id.into(), request_rx);
             let (composite_request_tx, composite_request_rx) = mpsc::channel();
             let (hk_reply_tx, hk_reply_rx) = mpsc::channel();
-            let (tm_tx, tm_rx) = mpsc::channel::<PacketAsVec>();
+            let (tm_tx, tm_rx) = mpsc::channel();
+            let tm_sender = TmSender::new_heap(tm_tx);
             let shared_mgm_set = Arc::default();
             let mut handler = MgmHandlerLis3Mdl::new(
                 id,
@@ -602,7 +582,7 @@ mod tests {
                 composite_request_rx,
                 hk_reply_tx,
                 TestSwitchHelper::default(),
-                tm_tx,
+                tm_sender,
                 TestSpiInterface::default(),
                 shared_mgm_set,
             );

satrs-example/src/main.rs

@@ -1,5 +1,6 @@
 use logger::setup_logger;
 use satrs::spacepackets::time::{cds::CdsTime, TimeWriter};
+mod tm_sender;
 
 mod main_heap_tmtc;
 mod main_static_tmtc;

satrs-example/src/main_heap_tmtc.rs

@@ -1,11 +1,12 @@
 use crate::eps::pcdu::{
     PcduHandler, SerialInterfaceDummy, SerialInterfaceToSim, SerialSimInterfaceWrapper,
 };
-use crate::eps::PowerSwitchHelper;
+use crate::eps::{self, PowerSwitchHelper};
 use crate::events::EventHandler;
 use crate::interface::udp::DynamicUdpTmHandler;
 use crate::pus::stack::PusStack;
 use crate::pus::test::create_test_service_dynamic;
+use crate::tm_sender::TmSender;
 use crate::tmtc::tc_source::TcSourceTaskDynamic;
 use crate::tmtc::tm_sink::TmSinkDynamic;
 use log::info;
@@ -22,8 +23,7 @@ use satrs_example::config::{OBSW_SERVER_ADDR, PACKET_ID_VALIDATOR, SERVER_PORT};
 use satrs_example::DeviceMode;
 
 use crate::acs::mgm::{
-    MgmHandlerLis3Mdl, MpscModeLeafInterface, SpiDummyInterface, SpiSimInterface,
+    MgmHandlerLis3Mdl, SpiDummyInterface, SpiSimInterface, SpiSimInterfaceWrapper,
-    SpiSimInterfaceWrapper,
 };
 use crate::interface::sim_client_udp::create_sim_client;
 use crate::interface::tcp::{SyncTcpTmSource, TcpTask};
@@ -94,7 +94,7 @@ pub fn main_with_heap_backed_tmtc_pool() {
 
     let (_pus_action_reply_tx, pus_action_reply_rx) = mpsc::channel();
     let (pus_hk_reply_tx, pus_hk_reply_rx) = mpsc::channel();
-    let (pus_mode_reply_tx, pus_mode_reply_rx) = mpsc::channel();
+    let (pus_mode_reply_tx, pus_mode_reply_rx) = mpsc::sync_channel(10);
 
     let pus_router = PusTcMpscRouter {
         test_tc_sender: pus_test_tx,
@@ -202,7 +202,7 @@ pub fn main_with_heap_backed_tmtc_pool() {
         mgm_handler_composite_rx,
         pus_hk_reply_tx.clone(),
         switch_helper.clone(),
-        tm_sink_tx.clone(),
+        TmSender::Heap(tm_sink_tx.clone()),
         mgm_spi_interface,
         shared_mgm_set,
     );
@@ -213,13 +213,8 @@ pub fn main_with_heap_backed_tmtc_pool() {
         mgm_handler_mode_reply_to_parent_tx,
     );
 
-    let (pcdu_handler_mode_reply_to_parent_tx, _pcdu_handler_mode_reply_to_parent_rx) =
+    let pcdu_mode_node =
-        mpsc::sync_channel(10);
+        ModeRequestHandlerMpscBounded::new(PCDU_HANDLER.into(), pcdu_handler_mode_rx);
-    let pcdu_mode_leaf_interface = MpscModeLeafInterface {
-        request_rx: pcdu_handler_mode_rx,
-        reply_to_pus_tx: pus_mode_reply_tx,
-        reply_to_parent_tx: pcdu_handler_mode_reply_to_parent_tx,
-    };
     let pcdu_serial_interface = if let Some(sim_client) = opt_sim_client.as_mut() {
         sim_client.add_reply_recipient(satrs_minisim::SimComponent::Pcdu, pcdu_sim_reply_tx);
         SerialSimInterfaceWrapper::Sim(SerialInterfaceToSim::new(
@@ -232,7 +227,7 @@ pub fn main_with_heap_backed_tmtc_pool() {
     let mut pcdu_handler = PcduHandler::new(
         PCDU_HANDLER,
         "PCDU",
-        pcdu_mode_leaf_interface,
+        pcdu_mode_node,
         pcdu_handler_composite_rx,
         pus_hk_reply_tx,
         switch_request_rx,
@@ -240,6 +235,13 @@ pub fn main_with_heap_backed_tmtc_pool() {
         pcdu_serial_interface,
         shared_switch_set,
     );
+    connect_mode_nodes(
+        &mut pus_stack.mode_srv,
+        pcdu_handler_mode_tx.clone(),
+        &mut pcdu_handler,
+        pus_mode_reply_tx,
+    );
+
     // The PCDU is a critical component which should be in normal mode immediately.
     pcdu_handler_mode_tx
         .send(GenericMessage::new(

satrs-example/src/tm_sender.rs

@@ -0,0 +1,41 @@
+use std::sync::mpsc;
+
+use satrs::{
+    pus::EcssTmSender,
+    queue::GenericSendError,
+    spacepackets::ecss::WritablePusPacket,
+    tmtc::{PacketAsVec, PacketSenderWithSharedPool},
+};
+
+pub enum TmSender {
+    Static(PacketSenderWithSharedPool),
+    Heap(mpsc::Sender<PacketAsVec>),
+}
+
+impl TmSender {
+    pub fn new_static(sender: PacketSenderWithSharedPool) -> Self {
+        TmSender::Static(sender)
+    }
+
+    pub fn new_heap(sender: mpsc::Sender<PacketAsVec>) -> Self {
+        TmSender::Heap(sender)
+    }
+}
+
+impl EcssTmSender for TmSender {
+    fn send_tm(
+        &self,
+        sender_id: satrs::ComponentId,
+        tm: satrs::pus::PusTmVariant,
+    ) -> Result<(), satrs::pus::EcssTmtcError> {
+        match self {
+            TmSender::Static(sync_sender) => sync_sender.send_tm(sender_id, tm),
+            TmSender::Heap(sync_sender) => match tm {
+                satrs::pus::PusTmVariant::InStore(_) => panic!("can not send TM in store"),
+                satrs::pus::PusTmVariant::Direct(pus_tm_creator) => sync_sender
+                    .send(PacketAsVec::new(sender_id, pus_tm_creator.to_vec()?))
+                    .map_err(|_| GenericSendError::RxDisconnected.into()),
+            },
+        }
+    }
+}