still less duplication than before

satrs-example/src/main.rs

@@ -71,11 +71,6 @@ use tmtc::tm_sink::TmSinkDynamic;
 #[cfg(not(feature = "heap_tmtc"))]
 use tmtc::tm_sink::TmSinkStatic;
 use tmtc::{tc_source::TcSourceTask, tm_sink::TmSink};
-mod spi;
-mod tm_sender;
-
-mod main_heap_tmtc;
-mod main_static_tmtc;
 
 mod acs;
 mod eps;
@@ -85,6 +80,8 @@ mod interface;
 mod logger;
 mod pus;
 mod requests;
+mod spi;
+mod tm_sender;
 mod tmtc;
 
 fn main() {
@@ -109,9 +106,9 @@ fn main() {
         if #[cfg(not(feature = "heap_tmtc"))] {
             let tm_sink_tx_sender =
                 PacketSenderWithSharedPool::new(tm_sink_tx.clone(), shared_tm_pool_wrapper.clone());
-            let tm_sender = TmSender::new_static(tm_sink_tx_sender.clone());
+            let tm_sender = TmSender::Static(tm_sink_tx_sender.clone());
         } else if #[cfg(feature = "heap_tmtc")] {
-            let tm_sender = TmSender::new_heap(tm_sink_tx.clone());
+            let tm_sender = TmSender::Heap(tm_sink_tx.clone());
         }
     }
 
@@ -279,7 +276,7 @@ fn main() {
         PACKET_ID_VALIDATOR.clone(),
     )
     .expect("tcp server creation failed");
- 
+
     cfg_if::cfg_if! {
         if #[cfg(not(feature = "heap_tmtc"))] {
             let mut tm_sink = TmSink::Static(TmSinkStatic::new(

satrs-example/src/main_heap_tmtc.rs

@@ -1,368 +0,0 @@
-use crate::eps::pcdu::{
-    PcduHandler, SerialInterfaceDummy, SerialInterfaceToSim, SerialSimInterfaceWrapper,
-};
-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;
-use crate::tm_sender::TmSender;
-use crate::tmtc::tc_source::{TcSourceTask, TcSourceTaskDynamic};
-use crate::tmtc::tm_sink::TmSinkDynamic;
-use log::info;
-use satrs::hal::std::tcp_server::ServerConfig;
-use satrs::hal::std::udp_server::UdpTcServer;
-use satrs::mode_tree::connect_mode_nodes;
-use satrs::pus::{EcssTcInMemConverter, EcssTcInVecConverter, HandlingStatus};
-use satrs::request::{GenericMessage, MessageMetadata};
-use satrs::tmtc::TcSender;
-use satrs_example::config::pool::create_sched_tc_pool;
-use satrs_example::config::tasks::{
-    FREQ_MS_AOCS, FREQ_MS_PUS_STACK, FREQ_MS_UDP_TMTC, SIM_CLIENT_IDLE_DELAY_MS,
-};
-use satrs_example::config::{OBSW_SERVER_ADDR, PACKET_ID_VALIDATOR, SERVER_PORT};
-use satrs_example::DeviceMode;
-
-use crate::acs::mgm::{
-    MgmHandlerLis3Mdl, SpiDummyInterface, SpiSimInterface, SpiSimInterfaceWrapper,
-};
-use crate::interface::sim_client_udp::create_sim_client;
-use crate::interface::tcp::{SyncTcpTmSource, TcpTask};
-use crate::interface::udp::UdpTmtcServer;
-use crate::pus::action::create_action_service;
-use crate::pus::event::create_event_service;
-use crate::pus::hk::create_hk_service;
-use crate::pus::mode::create_mode_service;
-use crate::pus::scheduler::{create_scheduler_service, TcReleaser};
-use crate::pus::{PusTcDistributor, PusTcMpscRouter};
-use crate::requests::GenericRequestRouter;
-use satrs::mode::{Mode, ModeAndSubmode, ModeRequest, ModeRequestHandlerMpscBounded};
-use satrs::pus::event_man::EventRequestWithToken;
-use satrs_example::config::components::{
-    MGM_HANDLER_0, NO_SENDER, PCDU_HANDLER, TCP_SERVER, UDP_SERVER,
-};
-use std::net::{IpAddr, SocketAddr};
-use std::sync::Arc;
-use std::sync::{mpsc, Mutex};
-use std::thread;
-use std::time::Duration;
-
-#[allow(dead_code)]
-pub fn main_with_heap_backed_tmtc_pool() {
-    let (tc_source_tx, tc_source_rx) = mpsc::sync_channel(50);
-    let (tm_sink_tx, tm_sink_rx) = mpsc::sync_channel(50);
-    let (tm_server_tx, tm_server_rx) = mpsc::sync_channel(50);
-
-    let (sim_request_tx, sim_request_rx) = mpsc::channel();
-    let (mgm_sim_reply_tx, mgm_sim_reply_rx) = mpsc::channel();
-    let (pcdu_sim_reply_tx, pcdu_sim_reply_rx) = mpsc::channel();
-    let mut opt_sim_client = create_sim_client(sim_request_rx);
-
-    // Some request are targetable. This map is used to retrieve sender handles based on a target ID.
-    let (mgm_handler_composite_tx, mgm_handler_composite_rx) = mpsc::sync_channel(5);
-    let (pcdu_handler_composite_tx, pcdu_handler_composite_rx) = mpsc::sync_channel(10);
-    let (mgm_handler_mode_tx, mgm_handler_mode_rx) = mpsc::sync_channel(5);
-    let (pcdu_handler_mode_tx, pcdu_handler_mode_rx) = mpsc::sync_channel(10);
-
-    // Some request are targetable. This map is used to retrieve sender handles based on a target ID.
-    let mut request_map = GenericRequestRouter::default();
-    request_map
-        .composite_router_map
-        .insert(MGM_HANDLER_0.id(), mgm_handler_composite_tx);
-    request_map
-        .composite_router_map
-        .insert(PCDU_HANDLER.id(), pcdu_handler_composite_tx);
-
-    // Create event handling components
-    // These sender handles are used to send event requests, for example to enable or disable
-    // certain events.
-    let (event_tx, event_rx) = mpsc::sync_channel(100);
-    let (event_request_tx, event_request_rx) = mpsc::channel::<EventRequestWithToken>();
-    // The event task is the core handler to perform the event routing and TM handling as specified
-    // in the sat-rs documentation.
-    let mut event_handler = EventHandler::new(tm_sink_tx.clone(), event_rx, event_request_rx);
-
-    let (pus_test_tx, pus_test_rx) = mpsc::channel();
-    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 (pus_mode_tx, pus_mode_rx) = mpsc::channel();
-
-    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::sync_channel(10);
-
-    let pus_router = PusTcMpscRouter {
-        test_tc_sender: pus_test_tx,
-        event_tc_sender: pus_event_tx,
-        sched_tc_sender: pus_sched_tx,
-        hk_tc_sender: pus_hk_tx,
-        action_tc_sender: pus_action_tx,
-        mode_tc_sender: pus_mode_tx,
-    };
-    let tm_sender = TmSender::new_heap(tm_sink_tx.clone());
-    let tc_releaser = TcReleaser::new_heap(tc_source_tx.clone());
-    let tc_in_mem_converter = EcssTcInMemConverter::new_heap(EcssTcInVecConverter::default());
-    let pus_test_service = create_test_service(
-        tm_sender.clone(),
-        tc_in_mem_converter.clone(),
-        event_tx.clone(),
-        pus_test_rx,
-    );
-    let pus_scheduler_service = create_scheduler_service(
-        tm_sender.clone(),
-        tc_in_mem_converter.clone(),
-        tc_releaser,
-        pus_sched_rx,
-        create_sched_tc_pool(),
-    );
-
-    let pus_event_service = create_event_service(
-        tm_sender.clone(),
-        tc_in_mem_converter.clone(),
-        pus_event_rx,
-        event_request_tx,
-    );
-    let pus_action_service = create_action_service(
-        tm_sender.clone(),
-        tc_in_mem_converter.clone(),
-        pus_action_rx,
-        request_map.clone(),
-        pus_action_reply_rx,
-    );
-    let pus_hk_service = create_hk_service(
-        tm_sender.clone(),
-        tc_in_mem_converter.clone(),
-        pus_hk_rx,
-        request_map.clone(),
-        pus_hk_reply_rx,
-    );
-    let pus_mode_service = create_mode_service(
-        tm_sender.clone(),
-        tc_in_mem_converter.clone(),
-        pus_mode_rx,
-        request_map,
-        pus_mode_reply_rx,
-    );
-    let mut pus_stack = PusStack::new(
-        pus_test_service,
-        pus_hk_service,
-        pus_event_service,
-        pus_action_service,
-        pus_scheduler_service,
-        pus_mode_service,
-    );
-
-    let mut tmtc_task = TcSourceTask::Heap(TcSourceTaskDynamic::new(
-        tc_source_rx,
-        PusTcDistributor::new(tm_sender.clone(), pus_router),
-    ));
-
-    let sock_addr = SocketAddr::new(IpAddr::V4(OBSW_SERVER_ADDR), SERVER_PORT);
-    let tc_sender = TcSender::HeapStore(tc_source_tx.clone());
-    let udp_tc_server = UdpTcServer::new(UDP_SERVER.id(), sock_addr, 2048, tc_sender.clone())
-        .expect("creating UDP TMTC server failed");
-    let mut udp_tmtc_server = UdpTmtcServer {
-        udp_tc_server,
-        tm_handler: DynamicUdpTmHandler {
-            tm_rx: tm_server_rx,
-        },
-    };
-
-    let tcp_server_cfg = ServerConfig::new(
-        TCP_SERVER.id(),
-        sock_addr,
-        Duration::from_millis(400),
-        4096,
-        8192,
-    );
-    let sync_tm_tcp_source = SyncTcpTmSource::new(200);
-    let mut tcp_server = TcpTask::new(
-        tcp_server_cfg,
-        sync_tm_tcp_source.clone(),
-        tc_sender.clone(),
-        PACKET_ID_VALIDATOR.clone(),
-    )
-    .expect("tcp server creation failed");
-
-    let mut tm_funnel = TmSinkDynamic::new(sync_tm_tcp_source, tm_sink_rx, tm_server_tx);
-
-    let shared_switch_set = Arc::new(Mutex::default());
-    let (switch_request_tx, switch_request_rx) = mpsc::sync_channel(20);
-    let switch_helper = PowerSwitchHelper::new(switch_request_tx, shared_switch_set.clone());
-
-    let (mgm_handler_mode_reply_to_parent_tx, _mgm_handler_mode_reply_to_parent_rx) =
-        mpsc::sync_channel(5);
-    let shared_mgm_set = Arc::default();
-    let mgm_mode_node =
-        ModeRequestHandlerMpscBounded::new(MGM_HANDLER_0.into(), mgm_handler_mode_rx);
-
-    let mgm_spi_interface = if let Some(sim_client) = opt_sim_client.as_mut() {
-        sim_client.add_reply_recipient(satrs_minisim::SimComponent::MgmLis3Mdl, mgm_sim_reply_tx);
-        SpiSimInterfaceWrapper::Sim(SpiSimInterface {
-            sim_request_tx: sim_request_tx.clone(),
-            sim_reply_rx: mgm_sim_reply_rx,
-        })
-    } else {
-        SpiSimInterfaceWrapper::Dummy(SpiDummyInterface::default())
-    };
-    let mut mgm_handler = MgmHandlerLis3Mdl::new(
-        MGM_HANDLER_0,
-        "MGM_0",
-        mgm_mode_node,
-        mgm_handler_composite_rx,
-        pus_hk_reply_tx.clone(),
-        switch_helper.clone(),
-        TmSender::Heap(tm_sink_tx.clone()),
-        mgm_spi_interface,
-        shared_mgm_set,
-    );
-    connect_mode_nodes(
-        &mut pus_stack.mode_srv,
-        mgm_handler_mode_tx,
-        &mut mgm_handler,
-        mgm_handler_mode_reply_to_parent_tx,
-    );
-
-    let pcdu_mode_node =
-        ModeRequestHandlerMpscBounded::new(PCDU_HANDLER.into(), pcdu_handler_mode_rx);
-    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(
-            sim_request_tx.clone(),
-            pcdu_sim_reply_rx,
-        ))
-    } else {
-        SerialSimInterfaceWrapper::Dummy(SerialInterfaceDummy::default())
-    };
-    let mut pcdu_handler = PcduHandler::new(
-        PCDU_HANDLER,
-        "PCDU",
-        pcdu_mode_node,
-        pcdu_handler_composite_rx,
-        pus_hk_reply_tx,
-        switch_request_rx,
-        tm_sink_tx,
-        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(
-            MessageMetadata::new(0, NO_SENDER),
-            ModeRequest::SetMode {
-                mode_and_submode: ModeAndSubmode::new(DeviceMode::Normal as Mode, 0),
-                forced: false,
-            },
-        ))
-        .expect("sending initial mode request failed");
-
-    info!("Starting TMTC and UDP task");
-    let jh_udp_tmtc = thread::Builder::new()
-        .name("sat-rs tmtc-udp".to_string())
-        .spawn(move || {
-            info!("Running UDP server on port {SERVER_PORT}");
-            loop {
-                udp_tmtc_server.periodic_operation();
-                tmtc_task.periodic_operation();
-                thread::sleep(Duration::from_millis(FREQ_MS_UDP_TMTC));
-            }
-        })
-        .unwrap();
-
-    info!("Starting TCP task");
-    let jh_tcp = thread::Builder::new()
-        .name("sat-rs tcp".to_string())
-        .spawn(move || {
-            info!("Running TCP server on port {SERVER_PORT}");
-            loop {
-                tcp_server.periodic_operation();
-            }
-        })
-        .unwrap();
-
-    info!("Starting TM funnel task");
-    let jh_tm_funnel = thread::Builder::new()
-        .name("sat-rs tm-sink".to_string())
-        .spawn(move || loop {
-            tm_funnel.operation();
-        })
-        .unwrap();
-
-    let mut opt_jh_sim_client = None;
-    if let Some(mut sim_client) = opt_sim_client {
-        info!("Starting UDP sim client task");
-        opt_jh_sim_client = Some(
-            thread::Builder::new()
-                .name("sat-rs sim adapter".to_string())
-                .spawn(move || loop {
-                    if sim_client.operation() == HandlingStatus::Empty {
-                        std::thread::sleep(Duration::from_millis(SIM_CLIENT_IDLE_DELAY_MS));
-                    }
-                })
-                .unwrap(),
-        );
-    }
-
-    info!("Starting AOCS thread");
-    let jh_aocs = thread::Builder::new()
-        .name("sat-rs aocs".to_string())
-        .spawn(move || loop {
-            mgm_handler.periodic_operation();
-            thread::sleep(Duration::from_millis(FREQ_MS_AOCS));
-        })
-        .unwrap();
-
-    info!("Starting EPS thread");
-    let jh_eps = thread::Builder::new()
-        .name("sat-rs eps".to_string())
-        .spawn(move || loop {
-            // TODO: We should introduce something like a fixed timeslot helper to allow a more
-            // declarative API. It would also be very useful for the AOCS task.
-            pcdu_handler.periodic_operation(eps::pcdu::OpCode::RegularOp);
-            thread::sleep(Duration::from_millis(50));
-            pcdu_handler.periodic_operation(eps::pcdu::OpCode::PollAndRecvReplies);
-            thread::sleep(Duration::from_millis(50));
-            pcdu_handler.periodic_operation(eps::pcdu::OpCode::PollAndRecvReplies);
-            thread::sleep(Duration::from_millis(300));
-        })
-        .unwrap();
-
-    info!("Starting PUS handler thread");
-    let jh_pus_handler = thread::Builder::new()
-        .name("sat-rs pus".to_string())
-        .spawn(move || loop {
-            pus_stack.periodic_operation();
-            event_handler.periodic_operation();
-            thread::sleep(Duration::from_millis(FREQ_MS_PUS_STACK));
-        })
-        .unwrap();
-
-    jh_udp_tmtc
-        .join()
-        .expect("Joining UDP TMTC server thread failed");
-    jh_tcp
-        .join()
-        .expect("Joining TCP TMTC server thread failed");
-    jh_tm_funnel
-        .join()
-        .expect("Joining TM Funnel thread failed");
-    if let Some(jh_sim_client) = opt_jh_sim_client {
-        jh_sim_client
-            .join()
-            .expect("Joining SIM client thread failed");
-    }
-    jh_aocs.join().expect("Joining AOCS thread failed");
-    jh_eps.join().expect("Joining EPS thread failed");
-    jh_pus_handler
-        .join()
-        .expect("Joining PUS handler thread failed");
-}

satrs-example/src/main_static_tmtc.rs

@@ -1,392 +0,0 @@
-use crate::eps::pcdu::{
-    PcduHandler, SerialInterfaceDummy, SerialInterfaceToSim, SerialSimInterfaceWrapper,
-};
-use crate::eps::PowerSwitchHelper;
-use crate::events::EventHandler;
-use crate::pus::stack::PusStack;
-use crate::tm_sender::TmSender;
-use crate::tmtc::tc_source::TcSourceTaskStatic;
-use crate::tmtc::tm_sink::TmSinkStatic;
-use log::info;
-use satrs::hal::std::tcp_server::ServerConfig;
-use satrs::hal::std::udp_server::UdpTcServer;
-use satrs::mode_tree::connect_mode_nodes;
-use satrs::pus::{EcssTcInMemConverter, EcssTcInSharedPoolConverter, HandlingStatus};
-use satrs::request::{GenericMessage, MessageMetadata};
-use satrs::tmtc::{PacketSenderWithSharedPool, SharedPacketPool, TcSender};
-use satrs_example::config::pool::{create_sched_tc_pool, create_static_pools};
-use satrs_example::config::tasks::{
-    FREQ_MS_AOCS, FREQ_MS_PUS_STACK, FREQ_MS_UDP_TMTC, SIM_CLIENT_IDLE_DELAY_MS,
-};
-use satrs_example::config::{OBSW_SERVER_ADDR, PACKET_ID_VALIDATOR, SERVER_PORT};
-use satrs_example::DeviceMode;
-
-use crate::acs::mgm::{
-    MgmHandlerLis3Mdl, SpiDummyInterface, SpiSimInterface, SpiSimInterfaceWrapper,
-};
-use crate::interface::sim_client_udp::create_sim_client;
-use crate::interface::tcp::{SyncTcpTmSource, TcpTask};
-use crate::interface::udp::{StaticUdpTmHandler, UdpTmtcServer};
-use crate::pus::action::create_action_service;
-use crate::pus::event::create_event_service;
-use crate::pus::hk::create_hk_service;
-use crate::pus::mode::create_mode_service;
-use crate::pus::scheduler::{create_scheduler_service, TcReleaser};
-use crate::pus::test::create_test_service;
-use crate::pus::{PusTcDistributor, PusTcMpscRouter};
-use crate::requests::{CompositeRequest, GenericRequestRouter};
-use satrs::mode::{Mode, ModeAndSubmode, ModeRequest, ModeRequestHandlerMpscBounded};
-use satrs::pus::event_man::EventRequestWithToken;
-use satrs_example::config::components::{
-    MGM_HANDLER_0, NO_SENDER, PCDU_HANDLER, TCP_SERVER, UDP_SERVER,
-};
-use std::net::{IpAddr, SocketAddr};
-use std::sync::{mpsc, Mutex};
-use std::sync::{Arc, RwLock};
-use std::thread;
-use std::time::Duration;
-
-#[allow(dead_code)]
-pub fn main_with_static_tmtc_pool() {
-    let (tm_pool, tc_pool) = create_static_pools();
-    let shared_tm_pool = Arc::new(RwLock::new(tm_pool));
-    let shared_tc_pool = Arc::new(RwLock::new(tc_pool));
-    let shared_tm_pool_wrapper = SharedPacketPool::new(&shared_tm_pool);
-    let shared_tc_pool_wrapper = SharedPacketPool::new(&shared_tc_pool);
-    let (tc_source_tx, tc_source_rx) = mpsc::sync_channel(50);
-    let (tm_sink_tx, tm_sink_rx) = mpsc::sync_channel(50);
-    let (tm_server_tx, tm_server_rx) = mpsc::sync_channel(50);
-
-    let tm_sink_tx_sender =
-        PacketSenderWithSharedPool::new(tm_sink_tx.clone(), shared_tm_pool_wrapper.clone());
-    let tm_sender = TmSender::new_static(tm_sink_tx_sender.clone());
-
-    let (sim_request_tx, sim_request_rx) = mpsc::channel();
-    let (mgm_sim_reply_tx, mgm_sim_reply_rx) = mpsc::channel();
-    let (pcdu_sim_reply_tx, pcdu_sim_reply_rx) = mpsc::channel();
-    let mut opt_sim_client = create_sim_client(sim_request_rx);
-
-    let (mgm_handler_composite_tx, mgm_handler_composite_rx) =
-        mpsc::sync_channel::<GenericMessage<CompositeRequest>>(10);
-    let (pcdu_handler_composite_tx, pcdu_handler_composite_rx) =
-        mpsc::sync_channel::<GenericMessage<CompositeRequest>>(30);
-
-    let (mgm_handler_mode_tx, mgm_handler_mode_rx) =
-        mpsc::sync_channel::<GenericMessage<ModeRequest>>(5);
-    let (pcdu_handler_mode_tx, pcdu_handler_mode_rx) =
-        mpsc::sync_channel::<GenericMessage<ModeRequest>>(5);
-
-    // Some request are targetable. This map is used to retrieve sender handles based on a target ID.
-    let mut request_map = GenericRequestRouter::default();
-    request_map
-        .composite_router_map
-        .insert(MGM_HANDLER_0.id(), mgm_handler_composite_tx);
-    request_map
-        .composite_router_map
-        .insert(PCDU_HANDLER.id(), pcdu_handler_composite_tx);
-
-    // This helper structure is used by all telecommand providers which need to send telecommands
-    // to the TC source.
-    let tc_source_tx_with_pool =
-        PacketSenderWithSharedPool::new(tc_source_tx, shared_tc_pool_wrapper.clone());
-    let tc_in_mem_converter =
-        EcssTcInMemConverter::new_static(EcssTcInSharedPoolConverter::new(shared_tc_pool, 4096));
-
-    // Create event handling components
-    // These sender handles are used to send event requests, for example to enable or disable
-    // certain events.
-    let (event_tx, event_rx) = mpsc::sync_channel(100);
-    let (event_request_tx, event_request_rx) = mpsc::channel::<EventRequestWithToken>();
-
-    // The event task is the core handler to perform the event routing and TM handling as specified
-    // in the sat-rs documentation.
-    let mut event_handler = EventHandler::new(tm_sink_tx.clone(), event_rx, event_request_rx);
-
-    let (pus_test_tx, pus_test_rx) = mpsc::channel();
-    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 (pus_mode_tx, pus_mode_rx) = mpsc::channel();
-
-    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::sync_channel(5);
-
-    let tc_releaser = TcReleaser::new_static(tc_source_tx_with_pool.clone());
-    let pus_router = PusTcMpscRouter {
-        test_tc_sender: pus_test_tx,
-        event_tc_sender: pus_event_tx,
-        sched_tc_sender: pus_sched_tx,
-        hk_tc_sender: pus_hk_tx,
-        action_tc_sender: pus_action_tx,
-        mode_tc_sender: pus_mode_tx,
-    };
-    let pus_test_service = create_test_service(
-        tm_sender.clone(),
-        tc_in_mem_converter.clone(),
-        event_tx.clone(),
-        pus_test_rx,
-    );
-    let pus_scheduler_service = create_scheduler_service(
-        tm_sender.clone(),
-        tc_in_mem_converter.clone(),
-        tc_releaser,
-        pus_sched_rx,
-        create_sched_tc_pool(),
-    );
-    let pus_event_service = create_event_service(
-        tm_sender.clone(),
-        tc_in_mem_converter.clone(),
-        pus_event_rx,
-        event_request_tx,
-    );
-    let pus_action_service = create_action_service(
-        tm_sender.clone(),
-        tc_in_mem_converter.clone(),
-        pus_action_rx,
-        request_map.clone(),
-        pus_action_reply_rx,
-    );
-    let pus_hk_service = create_hk_service(
-        tm_sender.clone(),
-        tc_in_mem_converter.clone(),
-        pus_hk_rx,
-        request_map.clone(),
-        pus_hk_reply_rx,
-    );
-    let pus_mode_service = create_mode_service(
-        tm_sender.clone(),
-        tc_in_mem_converter.clone(),
-        pus_mode_rx,
-        request_map,
-        pus_mode_reply_rx,
-    );
-    let mut pus_stack = PusStack::new(
-        pus_test_service,
-        pus_hk_service,
-        pus_event_service,
-        pus_action_service,
-        pus_scheduler_service,
-        pus_mode_service,
-    );
-
-    let mut tmtc_task = TcSourceTaskStatic::new(
-        shared_tc_pool_wrapper.clone(),
-        tc_source_rx,
-        PusTcDistributor::new(tm_sender.clone(), pus_router),
-    );
-
-    let tc_sender = TcSender::StaticStore(tc_source_tx_with_pool);
-    let sock_addr = SocketAddr::new(IpAddr::V4(OBSW_SERVER_ADDR), SERVER_PORT);
-    let udp_tc_server = UdpTcServer::new(UDP_SERVER.id(), sock_addr, 2048, tc_sender.clone())
-        .expect("creating UDP TMTC server failed");
-    let mut udp_tmtc_server = UdpTmtcServer {
-        udp_tc_server,
-        tm_handler: StaticUdpTmHandler {
-            tm_rx: tm_server_rx,
-            tm_store: shared_tm_pool.clone(),
-        },
-    };
-
-    let tcp_server_cfg = ServerConfig::new(
-        TCP_SERVER.id(),
-        sock_addr,
-        Duration::from_millis(400),
-        4096,
-        8192,
-    );
-    let sync_tm_tcp_source = SyncTcpTmSource::new(200);
-    let mut tcp_server = TcpTask::new(
-        tcp_server_cfg,
-        sync_tm_tcp_source.clone(),
-        tc_sender,
-        PACKET_ID_VALIDATOR.clone(),
-    )
-    .expect("tcp server creation failed");
-
-    let mut tm_sink = TmSinkStatic::new(
-        shared_tm_pool_wrapper,
-        sync_tm_tcp_source,
-        tm_sink_rx,
-        tm_server_tx,
-    );
-
-    let shared_switch_set = Arc::new(Mutex::default());
-    let (switch_request_tx, switch_request_rx) = mpsc::sync_channel(20);
-    let switch_helper = PowerSwitchHelper::new(switch_request_tx, shared_switch_set.clone());
-
-    let shared_mgm_set = Arc::default();
-    let mgm_mode_node =
-        ModeRequestHandlerMpscBounded::new(MGM_HANDLER_0.into(), mgm_handler_mode_rx);
-    let mgm_spi_interface = if let Some(sim_client) = opt_sim_client.as_mut() {
-        sim_client.add_reply_recipient(satrs_minisim::SimComponent::MgmLis3Mdl, mgm_sim_reply_tx);
-        SpiSimInterfaceWrapper::Sim(SpiSimInterface {
-            sim_request_tx: sim_request_tx.clone(),
-            sim_reply_rx: mgm_sim_reply_rx,
-        })
-    } else {
-        SpiSimInterfaceWrapper::Dummy(SpiDummyInterface::default())
-    };
-    let mut mgm_handler = MgmHandlerLis3Mdl::new(
-        MGM_HANDLER_0,
-        "MGM_0",
-        mgm_mode_node,
-        mgm_handler_composite_rx,
-        pus_hk_reply_tx.clone(),
-        switch_helper.clone(),
-        tm_sender,
-        mgm_spi_interface,
-        shared_mgm_set,
-    );
-    // Connect PUS service to device handler.
-    connect_mode_nodes(
-        &mut pus_stack.mode_srv,
-        mgm_handler_mode_tx,
-        &mut mgm_handler,
-        pus_mode_reply_tx.clone(),
-    );
-
-    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(
-            sim_request_tx.clone(),
-            pcdu_sim_reply_rx,
-        ))
-    } else {
-        SerialSimInterfaceWrapper::Dummy(SerialInterfaceDummy::default())
-    };
-    let pcdu_mode_node =
-        ModeRequestHandlerMpscBounded::new(PCDU_HANDLER.into(), pcdu_handler_mode_rx);
-    let mut pcdu_handler = PcduHandler::new(
-        PCDU_HANDLER,
-        "PCDU",
-        pcdu_mode_node,
-        pcdu_handler_composite_rx,
-        pus_hk_reply_tx,
-        switch_request_rx,
-        tm_sink_tx,
-        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(
-            MessageMetadata::new(0, NO_SENDER),
-            ModeRequest::SetMode {
-                mode_and_submode: ModeAndSubmode::new(DeviceMode::Normal as Mode, 0),
-                forced: false,
-            },
-        ))
-        .expect("sending initial mode request failed");
-
-    info!("Starting TMTC and UDP task");
-    let jh_udp_tmtc = thread::Builder::new()
-        .name("SATRS tmtc-udp".to_string())
-        .spawn(move || {
-            info!("Running UDP server on port {SERVER_PORT}");
-            loop {
-                udp_tmtc_server.periodic_operation();
-                tmtc_task.periodic_operation();
-                thread::sleep(Duration::from_millis(FREQ_MS_UDP_TMTC));
-            }
-        })
-        .unwrap();
-
-    info!("Starting TCP task");
-    let jh_tcp = thread::Builder::new()
-        .name("sat-rs tcp".to_string())
-        .spawn(move || {
-            info!("Running TCP server on port {SERVER_PORT}");
-            loop {
-                tcp_server.periodic_operation();
-            }
-        })
-        .unwrap();
-
-    info!("Starting TM funnel task");
-    let jh_tm_funnel = thread::Builder::new()
-        .name("tm sink".to_string())
-        .spawn(move || loop {
-            tm_sink.operation();
-        })
-        .unwrap();
-
-    let mut opt_jh_sim_client = None;
-    if let Some(mut sim_client) = opt_sim_client {
-        info!("Starting UDP sim client task");
-        opt_jh_sim_client = Some(
-            thread::Builder::new()
-                .name("sat-rs sim adapter".to_string())
-                .spawn(move || loop {
-                    if sim_client.operation() == HandlingStatus::Empty {
-                        std::thread::sleep(Duration::from_millis(SIM_CLIENT_IDLE_DELAY_MS));
-                    }
-                })
-                .unwrap(),
-        );
-    }
-
-    info!("Starting AOCS thread");
-    let jh_aocs = thread::Builder::new()
-        .name("sat-rs aocs".to_string())
-        .spawn(move || loop {
-            mgm_handler.periodic_operation();
-            thread::sleep(Duration::from_millis(FREQ_MS_AOCS));
-        })
-        .unwrap();
-
-    info!("Starting EPS thread");
-    let jh_eps = thread::Builder::new()
-        .name("sat-rs eps".to_string())
-        .spawn(move || loop {
-            // TODO: We should introduce something like a fixed timeslot helper to allow a more
-            // declarative API. It would also be very useful for the AOCS task.
-            //
-            // TODO: The fixed timeslot handler exists.. use it.
-            pcdu_handler.periodic_operation(crate::eps::pcdu::OpCode::RegularOp);
-            thread::sleep(Duration::from_millis(50));
-            pcdu_handler.periodic_operation(crate::eps::pcdu::OpCode::PollAndRecvReplies);
-            thread::sleep(Duration::from_millis(50));
-            pcdu_handler.periodic_operation(crate::eps::pcdu::OpCode::PollAndRecvReplies);
-            thread::sleep(Duration::from_millis(300));
-        })
-        .unwrap();
-
-    info!("Starting PUS handler thread");
-    let jh_pus_handler = thread::Builder::new()
-        .name("sat-rs pus".to_string())
-        .spawn(move || loop {
-            event_handler.periodic_operation();
-            pus_stack.periodic_operation();
-            thread::sleep(Duration::from_millis(FREQ_MS_PUS_STACK));
-        })
-        .unwrap();
-
-    jh_udp_tmtc
-        .join()
-        .expect("Joining UDP TMTC server thread failed");
-    jh_tcp
-        .join()
-        .expect("Joining TCP TMTC server thread failed");
-    jh_tm_funnel
-        .join()
-        .expect("Joining TM Funnel thread failed");
-    if let Some(jh_sim_client) = opt_jh_sim_client {
-        jh_sim_client
-            .join()
-            .expect("Joining SIM client thread failed");
-    }
-    jh_aocs.join().expect("Joining AOCS thread failed");
-    jh_eps.join().expect("Joining EPS thread failed");
-    jh_pus_handler
-        .join()
-        .expect("Joining PUS handler thread failed");
-}

satrs-example/src/pus/scheduler.rs

@@ -65,20 +65,12 @@ impl TcReleaseProvider for mpsc::SyncSender<PacketAsVec> {
     }
 }
 
+#[allow(dead_code)]
 pub enum TcReleaser {
     Static(PacketSenderWithSharedPool),
     Heap(mpsc::SyncSender<PacketAsVec>),
 }
 
-impl TcReleaser {
-    pub fn new_static(sender: PacketSenderWithSharedPool) -> Self {
-        Self::Static(sender)
-    }
-    pub fn new_heap(sender: mpsc::SyncSender<PacketAsVec>) -> Self {
-        Self::Heap(sender)
-    }
-}
-
 impl TcReleaseProvider for TcReleaser {
     fn release(&mut self, sender_id: ComponentId, enabled: bool, info: &TcInfo, tc: &[u8]) -> bool {
         match self {

satrs-example/src/tm_sender.rs

@@ -7,22 +7,13 @@ use satrs::{
     tmtc::{PacketAsVec, PacketSenderWithSharedPool},
 };
 
+#[allow(dead_code)]
 #[derive(Debug, Clone)]
 pub enum TmSender {
     Static(PacketSenderWithSharedPool),
     Heap(mpsc::SyncSender<PacketAsVec>),
 }
 
-impl TmSender {
-    pub fn new_static(sender: PacketSenderWithSharedPool) -> Self {
-        TmSender::Static(sender)
-    }
-
-    pub fn new_heap(sender: mpsc::SyncSender<PacketAsVec>) -> Self {
-        TmSender::Heap(sender)
-    }
-}
-
 impl EcssTmSender for TmSender {
     fn send_tm(
         &self,

satrs-example/src/tmtc/tc_source.rs

@@ -15,6 +15,7 @@ pub struct TcSourceTaskStatic {
     pus_distributor: PusTcDistributor,
 }
 
+#[allow(dead_code)]
 impl TcSourceTaskStatic {
     pub fn new(
         shared_tc_pool: SharedPacketPool,
@@ -68,6 +69,7 @@ pub struct TcSourceTaskDynamic {
     pus_distributor: PusTcDistributor,
 }
 
+#[allow(dead_code)]
 impl TcSourceTaskDynamic {
     pub fn new(tc_receiver: mpsc::Receiver<PacketAsVec>, pus_receiver: PusTcDistributor) -> Self {
         Self {

satrs-example/src/tmtc/tm_sink.rs

@@ -89,6 +89,7 @@ pub struct TmSinkStatic {
     tm_server_tx: mpsc::SyncSender<PacketInPool>,
 }
 
+#[allow(dead_code)]
 impl TmSinkStatic {
     pub fn new(
         shared_tm_store: SharedPacketPool,
@@ -135,6 +136,7 @@ pub struct TmSinkDynamic {
     tm_server_tx: mpsc::SyncSender<PacketAsVec>,
 }
 
+#[allow(dead_code)]
 impl TmSinkDynamic {
     pub fn new(
         sync_tm_tcp_source: SyncTcpTmSource,