try to make it compile again

Author: robamu

satrs-example/src/eps/pcdu.rs

@@ -32,12 +32,7 @@ use satrs_minisim::{
 };
 use serde::{Deserialize, Serialize};
 
-use crate::{
-    hk::PusHkHelper,
-    //pus::hk::{HkReply, HkReplyVariant},
-    requests::CompositeRequest,
-    tmtc::sender::TmTcSender,
-};
+use crate::{hk::PusHkHelper, requests::CompositeRequest};
 
 pub trait SerialInterface {
     type Error: core::fmt::Debug;
@@ -213,7 +208,7 @@ pub struct PcduHandler<ComInterface: SerialInterface> {
     //hk_reply_tx: mpsc::SyncSender<GenericMessage<HkReply>>,
     hk_tx: std::sync::mpsc::SyncSender<CcsdsTmPacketOwned>,
     switch_request_rx: mpsc::Receiver<GenericMessage<SwitchRequest>>,
-    tm_sender: TmTcSender,
+    tm_tx: mpsc::SyncSender<CcsdsTmPacketOwned>,
     pub com_interface: ComInterface,
     shared_switch_map: Arc<Mutex<SwitchSet>>,
     #[new(value = "PusHkHelper::new(id)")]
@@ -274,7 +269,7 @@ impl<ComInterface: SerialInterface> PcduHandler<ComInterface> {
         }
     }
 
-    pub fn handle_hk_request(&mut self, requestor_info: &MessageMetadata, hk_request: &HkRequest) {
+    pub fn handle_hk_request(&mut self, _requestor_info: &MessageMetadata, hk_request: &HkRequest) {
         match hk_request.variant {
             HkRequestVariant::OneShot => {
                 if hk_request.unique_id == SetId::SwitcherSet as u32 {
@@ -301,11 +296,11 @@ impl<ComInterface: SerialInterface> PcduHandler<ComInterface> {
                         },
                         &mut self.tm_buf,
                     ) {
-                        self.tm_sender
-                            .send_tm(self.id.id(), PusTmVariant::Direct(hk_tm))
-                            .expect("failed to send HK TM");
                         // TODO: Fix
                         /*
+                        self.tm_sender
+                            .send(self.id.id(), PusTmVariant::Direct(hk_tm))
+                            .expect("failed to send HK TM");
                         self.hk_reply_tx
                             .send(GenericMessage::new(
                                 *requestor_info,
@@ -511,9 +506,7 @@ mod tests {
     use std::sync::mpsc;
 
     use arbitrary_int::u21;
-    use satrs::{
-        mode::ModeRequest, power::SwitchStateBinary, request::GenericMessage, tmtc::PacketAsVec,
-    };
+    use satrs::{mode::ModeRequest, power::SwitchStateBinary, request::GenericMessage};
     use satrs_example::ids::{self, Apid};
     use satrs_minisim::eps::SwitchMapBinary;
 
@@ -561,7 +554,7 @@ mod tests {
         pub composite_request_tx: mpsc::Sender<GenericMessage<CompositeRequest>>,
         //pub hk_reply_rx: mpsc::Receiver<GenericMessage<HkReply>>,
         pub hk_rx: std::sync::mpsc::Receiver<CcsdsTmPacketOwned>,
-        pub tm_rx: mpsc::Receiver<PacketAsVec>,
+        pub tm_rx: mpsc::Receiver<CcsdsTmPacketOwned>,
         pub switch_request_tx: mpsc::Sender<GenericMessage<SwitchRequest>>,
         pub handler: PcduHandler<SerialInterfaceTest>,
     }
@@ -574,7 +567,7 @@ mod tests {
             let mode_node = ModeRequestHandlerMpscBounded::new(PCDU.into(), mode_request_rx);
             let (composite_request_tx, composite_request_rx) = mpsc::channel();
             let (hk_tx, hk_rx) = mpsc::sync_channel(10);
-            let (tm_tx, tm_rx) = mpsc::sync_channel::<PacketAsVec>(5);
+            let (tm_tx, tm_rx) = mpsc::sync_channel(5);
             let (switch_request_tx, switch_reqest_rx) = mpsc::channel();
             let shared_switch_map = Arc::new(Mutex::new(SwitchSet::default()));
             let mut handler = PcduHandler::new(
@@ -584,7 +577,8 @@ mod tests {
                 composite_request_rx,
                 hk_tx,
                 switch_reqest_rx,
-                TmTcSender::Heap(tm_tx.clone()),
+                tm_tx.clone(),
+                //TmTcSender::Normal(tm_tx.clone()),
                 SerialInterfaceTest::default(),
                 shared_switch_map,
             );

satrs-example/src/events.rs

@@ -1,6 +1,6 @@
 use std::sync::mpsc::{self};
 
-use crate::pus::create_verification_reporter;
+//use crate::pus::create_verification_reporter;
 use arbitrary_int::traits::Integer as _;
 use arbitrary_int::u11;
 use satrs::event_man_legacy::{EventMessageU32, EventRoutingError};
@@ -34,6 +34,7 @@ impl EventTmHook for EventApidSetter {
     }
 }
 
+/*
 /// The PUS event handler subscribes for all events and converts them into ECSS PUS 5 event
 /// packets. It also handles the verification completion of PUS event service requests.
 pub struct PusEventHandler<TmSender: EcssTmSender> {
@@ -292,3 +293,4 @@ mod tests {
         // TODO: Add test.
     }
 }
+*/

satrs-example/src/interface/udp.rs

@@ -1,22 +1,22 @@
 #![allow(dead_code)]
+use std::collections::VecDeque;
 use std::net::{SocketAddr, UdpSocket};
-use std::sync::mpsc;
+use std::sync::{mpsc, Arc, Mutex};
 
 use log::{info, warn};
 use satrs::hal::std::udp_server::{ReceiveResult, UdpTcServer};
 use satrs::pus::HandlingStatus;
 use satrs::queue::GenericSendError;
-use satrs::tmtc::PacketAsVec;
 
-use satrs::pool::{PoolProviderWithGuards, SharedStaticMemoryPool};
-use satrs::tmtc::PacketInPool;
+use satrs_example::CcsdsTmPacketOwned;
 
 use crate::tmtc::sender::TmTcSender;
 
-pub trait UdpTmHandler {
+pub trait UdpTmHandlerProvider {
     fn send_tm_to_udp_client(&mut self, socket: &UdpSocket, recv_addr: &SocketAddr);
 }
 
+/*
 pub struct StaticUdpTmHandler {
     pub tm_rx: mpsc::Receiver<PacketInPool>,
     pub tm_store: SharedStaticMemoryPool,
@@ -45,35 +45,67 @@ impl UdpTmHandler for StaticUdpTmHandler {
         }
     }
 }
+*/
 
-pub struct DynamicUdpTmHandler {
-    pub tm_rx: mpsc::Receiver<PacketAsVec>,
+pub struct UdpTmHandlerWithChannel {
+    pub tm_rx: mpsc::Receiver<CcsdsTmPacketOwned>,
 }
 
-impl UdpTmHandler for DynamicUdpTmHandler {
+impl UdpTmHandlerProvider for UdpTmHandlerWithChannel {
     fn send_tm_to_udp_client(&mut self, socket: &UdpSocket, recv_addr: &SocketAddr) {
         while let Ok(tm) = self.tm_rx.try_recv() {
-            if tm.packet.len() > 9 {
-                let service = tm.packet[7];
-                let subservice = tm.packet[8];
-                info!("Sending PUS TM[{service},{subservice}]")
-            } else {
-                info!("Sending PUS TM");
-            }
-            let result = socket.send_to(&tm.packet, recv_addr);
+            info!("Sending PUS TM with header {:?}", tm.tm_header);
+            let result = socket.send_to(&tm.to_vec(), recv_addr);
             if let Err(e) = result {
                 warn!("Sending TM with UDP socket failed: {e}")
             }
         }
     }
 }
 
-pub struct UdpTmtcServer<TmHandler: UdpTmHandler> {
+#[derive(Default, Debug, Clone)]
+pub struct TestTmHandler {
+    addrs_to_send_to: Arc<Mutex<VecDeque<SocketAddr>>>,
+}
+
+impl UdpTmHandlerProvider for TestTmHandler {
+    fn send_tm_to_udp_client(&mut self, _socket: &UdpSocket, recv_addr: &SocketAddr) {
+        self.addrs_to_send_to.lock().unwrap().push_back(*recv_addr);
+    }
+}
+
+pub enum UdpTmHandler {
+    Normal(UdpTmHandlerWithChannel),
+    Test(TestTmHandler),
+}
+
+impl From<UdpTmHandlerWithChannel> for UdpTmHandler {
+    fn from(handler: UdpTmHandlerWithChannel) -> Self {
+        UdpTmHandler::Normal(handler)
+    }
+}
+
+impl From<TestTmHandler> for UdpTmHandler {
+    fn from(handler: TestTmHandler) -> Self {
+        UdpTmHandler::Test(handler)
+    }
+}
+
+impl UdpTmHandlerProvider for UdpTmHandler {
+    fn send_tm_to_udp_client(&mut self, socket: &UdpSocket, recv_addr: &SocketAddr) {
+        match self {
+            UdpTmHandler::Normal(handler) => handler.send_tm_to_udp_client(socket, recv_addr),
+            UdpTmHandler::Test(handler) => handler.send_tm_to_udp_client(socket, recv_addr),
+        }
+    }
+}
+
+pub struct UdpTmtcServer {
     pub udp_tc_server: UdpTcServer<TmTcSender, GenericSendError>,
-    pub tm_handler: TmHandler,
+    pub tm_handler: UdpTmHandler,
 }
 
-impl<TmHandler: UdpTmHandler> UdpTmtcServer<TmHandler> {
+impl UdpTmtcServer {
     pub fn periodic_operation(&mut self) {
         loop {
             if self.poll_tc_server() == HandlingStatus::Empty {
@@ -107,12 +139,8 @@ impl<TmHandler: UdpTmHandler> UdpTmtcServer<TmHandler> {
 
 #[cfg(test)]
 mod tests {
+    use std::net::IpAddr;
     use std::net::Ipv4Addr;
-    use std::{
-        collections::VecDeque,
-        net::IpAddr,
-        sync::{Arc, Mutex},
-    };
 
     use arbitrary_int::traits::Integer as _;
     use arbitrary_int::u14;
@@ -127,23 +155,12 @@ mod tests {
     use satrs_example::config::OBSW_SERVER_ADDR;
     use satrs_example::ids;
 
-    use crate::tmtc::sender::{MockSender, TmTcSender};
+    use crate::tmtc::sender::MockSender;
 
     use super::*;
 
     const UDP_SERVER_ID: ComponentId = 0x05;
 
-    #[derive(Default, Debug, Clone)]
-    pub struct TestTmHandler {
-        addrs_to_send_to: Arc<Mutex<VecDeque<SocketAddr>>>,
-    }
-
-    impl UdpTmHandler for TestTmHandler {
-        fn send_tm_to_udp_client(&mut self, _socket: &UdpSocket, recv_addr: &SocketAddr) {
-            self.addrs_to_send_to.lock().unwrap().push_back(*recv_addr);
-        }
-    }
-
     #[test]
     fn test_basic() {
         let sock_addr = SocketAddr::new(IpAddr::V4(OBSW_SERVER_ADDR), 0);
@@ -154,7 +171,7 @@ mod tests {
         let tm_handler_calls = tm_handler.addrs_to_send_to.clone();
         let mut udp_dyn_server = UdpTmtcServer {
             udp_tc_server,
-            tm_handler,
+            tm_handler: tm_handler.into(),
         };
         udp_dyn_server.periodic_operation();
         let queue = udp_dyn_server
@@ -179,7 +196,7 @@ mod tests {
         let tm_handler_calls = tm_handler.addrs_to_send_to.clone();
         let mut udp_dyn_server = UdpTmtcServer {
             udp_tc_server,
-            tm_handler,
+            tm_handler: tm_handler.into(),
         };
         let sph = SpHeader::new_for_unseg_tc(ids::Apid::GenericPus.raw_value(), u14::ZERO, 0);
         let ping_tc = PusTcCreator::new_simple(

satrs-example/src/lib.rs

@@ -42,6 +42,20 @@ pub struct CcsdsTmPacketOwned {
     pub payload: alloc::vec::Vec<u8>,
 }
 
+/// Simple type modelling packet stored in the heap. This structure is intended to
+/// be used when sending a packet via a message queue, so it also contains the sender ID.
+#[derive(Debug, PartialEq, Eq, Clone)]
+pub struct PacketAsVec {
+    pub sender_id: ComponentId,
+    pub packet: Vec<u8>,
+}
+
+impl PacketAsVec {
+    pub fn new(sender_id: ComponentId, packet: Vec<u8>) -> Self {
+        Self { sender_id, packet }
+    }
+}
+
 #[derive(Debug, thiserror::Error)]
 pub enum CcsdsCreationError {
     #[error("CCSDS packet creation error: {0}")]
@@ -76,11 +90,11 @@ impl CcsdsTmPacketOwned {
         .unwrap()
     }
 
-    pub fn to_vec(&self) -> Result<alloc::vec::Vec<u8>, CcsdsCreationError> {
+    pub fn to_vec(&self) -> alloc::vec::Vec<u8> {
         let mut buf = alloc::vec![0u8; self.len_written()];
-        let len = self.write_to_bytes(&mut buf)?;
+        let len = self.write_to_bytes(&mut buf).unwrap();
         buf.truncate(len);
-        Ok(buf)
+        buf
     }
 }