added pus components and ping

src/main.rs

@@ -13,37 +13,113 @@ use satrs::{
     hal::std::{tcp_server::ServerConfig, udp_server::UdpTcServer},
     tmtc::CcsdsDistributor,
 };
+use ops_sat_rs::config::tasks::FREQ_MS_PUS_STACK;
 
 use crate::{
     ccsds::CcsdsReceiver,
     logger::setup_logger,
-    tcp::{SyncTcpTmSource, TcpTask},
+    interface::tcp::{SyncTcpTmSource, TcpTask},
     tmtc::PusTcSourceProviderDynamic,
-    udp::{DynamicUdpTmHandler, UdpTmtcServer},
+    interface::udp::{DynamicUdpTmHandler, UdpTmtcServer},
 };
+use crate::pus::{PusReceiver, PusTcMpscRouter};
+use crate::pus::stack::PusStack;
+use crate::pus::test::create_test_service_dynamic;
+use crate::requests::GenericRequestRouter;
+use crate::tm_funnel::TmFunnelDynamic;
+use crate::tmtc::TcSourceTaskDynamic;
 
 mod ccsds;
 mod logger;
-mod tcp;
 mod tmtc;
-mod udp;
+mod requests;
+mod pus;
+mod tm_funnel;
+mod interface;
 
+#[allow(dead_code)]
 fn main() {
     setup_logger().expect("setting up logging with fern failed");
     println!("OPS-SAT Rust experiment OBSW");
 
     let (tc_source_tx, tc_source_rx) = mpsc::channel();
+    let (tm_funnel_tx, tm_funnel_rx) = mpsc::channel();
     let (tm_server_tx, tm_server_rx) = mpsc::channel();
 
     let tc_source = PusTcSourceProviderDynamic(tc_source_tx);
 
+    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::channel();
+
+    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_dynamic(
+        tm_funnel_tx.clone(),
+        // event_handler.clone_event_sender(),
+        pus_test_rx,
+    );
+    // let pus_scheduler_service = create_scheduler_service_dynamic(
+    //     tm_funnel_tx.clone(),
+    //     tc_source.0.clone(),
+    //     pus_sched_rx,
+    //     create_sched_tc_pool(),
+    // );
+    //
+    // let pus_event_service =
+    //     create_event_service_dynamic(tm_funnel_tx.clone(), pus_event_rx, event_request_tx);
+    // let pus_action_service = create_action_service_dynamic(
+    //     tm_funnel_tx.clone(),
+    //     pus_action_rx,
+    //     request_map.clone(),
+    //     pus_action_reply_rx,
+    // );
+    // let pus_hk_service = create_hk_service_dynamic(
+    //     tm_funnel_tx.clone(),
+    //     pus_hk_rx,
+    //     request_map.clone(),
+    //     pus_hk_reply_rx,
+    // );
+    // let pus_mode_service = create_mode_service_dynamic(
+    //     tm_funnel_tx.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 ccsds_receiver = CcsdsReceiver { tc_source };
 
+    let mut tmtc_task = TcSourceTaskDynamic::new(
+        tc_source_rx,
+        PusReceiver::new(tm_funnel_tx.clone(), pus_router),
+    );
+
     let sock_addr = SocketAddr::new(IpAddr::V4(OBSW_SERVER_ADDR), SERVER_PORT);
     let udp_ccsds_distributor = CcsdsDistributor::new(ccsds_receiver.clone());
     let udp_tc_server = UdpTcServer::new(sock_addr, 2048, Box::new(udp_ccsds_distributor))
         .expect("creating UDP TMTC server failed");
-
     let mut udp_tmtc_server = UdpTmtcServer {
         udp_tc_server,
         tm_handler: DynamicUdpTmHandler {
@@ -60,7 +136,9 @@ fn main() {
         tcp_ccsds_distributor,
         PACKET_ID_VALIDATOR.clone(),
     )
-    .expect("tcp server creation failed");
+        .expect("tcp server creation failed");
+
+    let mut tm_funnel = TmFunnelDynamic::new(sync_tm_tcp_source, tm_funnel_rx, tm_server_tx);
 
     info!("Starting TMTC and UDP task");
     let jh_udp_tmtc = thread::Builder::new()
@@ -69,7 +147,7 @@ fn main() {
             info!("Running UDP server on port {SERVER_PORT}");
             loop {
                 udp_tmtc_server.periodic_operation();
-                // tmtc_task.periodic_operation();
+                tmtc_task.periodic_operation();
                 thread::sleep(Duration::from_millis(FREQ_MS_UDP_TMTC));
             }
         })
@@ -86,10 +164,33 @@ fn main() {
         })
         .unwrap();
 
+    info!("Starting TM funnel task");
+    let jh_tm_funnel = thread::Builder::new()
+        .name("TM Funnel".to_string())
+        .spawn(move || loop {
+            tm_funnel.operation();
+        })
+        .unwrap();
+
+    info!("Starting PUS handler thread");
+    let jh_pus_handler = thread::Builder::new()
+        .name("PUS".to_string())
+        .spawn(move || loop {
+            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");
+    jh_pus_handler
+        .join()
+        .expect("Joining PUS handler thread failed");
+}