this is a big refactoring

Author: robamu

satrs-example/Cargo.toml

@@ -23,6 +23,7 @@ derive-new = "0.7"
 cfg-if = "1"
 arbitrary-int = "2"
 bitbybit = "1.4"
+postcard = "1"
 serde = { version = "1", features = ["derive"] }
 serde_json = "1"
 
@@ -31,8 +32,8 @@ satrs-minisim = { path = "../satrs-minisim" }
 satrs-mib = { path = "../satrs-mib" }
 
 [features]
-default = ["heap_tmtc"]
-heap_tmtc = []
+# default = ["heap_tmtc"]
+# heap_tmtc = []
 
 [dev-dependencies]
 env_logger = "0.11"

satrs-example/src/acs/mgm.rs

@@ -1,3 +1,4 @@
+/*
 use derive_new::new;
 use satrs::hk::{HkRequest, HkRequestVariant};
 use satrs::mode_tree::{ModeChild, ModeNode};
@@ -717,3 +718,4 @@ mod tests {
         assert!(mgm_set.valid);
     }
 }
+*/

satrs-example/src/eps/pcdu.rs

@@ -22,7 +22,7 @@ use satrs::{
 use satrs_example::{
     config::components::NO_SENDER,
     ids::{eps::PCDU, generic_pus::PUS_MODE},
-    DeviceMode, TimestampHelper,
+    CcsdsTmPacketOwned, DeviceMode, TimestampHelper,
 };
 use satrs_minisim::{
     eps::{
@@ -34,7 +34,7 @@ use serde::{Deserialize, Serialize};
 
 use crate::{
     hk::PusHkHelper,
-    pus::hk::{HkReply, HkReplyVariant},
+    //pus::hk::{HkReply, HkReplyVariant},
     requests::CompositeRequest,
     tmtc::sender::TmTcSender,
 };
@@ -210,7 +210,8 @@ pub struct PcduHandler<ComInterface: SerialInterface> {
     dev_str: &'static str,
     mode_node: ModeRequestHandlerMpscBounded,
     composite_request_rx: mpsc::Receiver<GenericMessage<CompositeRequest>>,
-    hk_reply_tx: mpsc::SyncSender<GenericMessage<HkReply>>,
+    //hk_reply_tx: mpsc::SyncSender<GenericMessage<HkReply>>,
+    hk_tx: std::sync::mpsc::SyncSender<CcsdsTmPacketOwned>,
     switch_request_rx: mpsc::Receiver<GenericMessage<SwitchRequest>>,
     tm_sender: TmTcSender,
     pub com_interface: ComInterface,
@@ -303,12 +304,15 @@ impl<ComInterface: SerialInterface> PcduHandler<ComInterface> {
                         self.tm_sender
                             .send_tm(self.id.id(), PusTmVariant::Direct(hk_tm))
                             .expect("failed to send HK TM");
+                        // TODO: Fix
+                        /*
                         self.hk_reply_tx
                             .send(GenericMessage::new(
                                 *requestor_info,
                                 HkReply::new(hk_request.unique_id, HkReplyVariant::Ack),
                             ))
                             .expect("failed to send HK reply");
+                        */
                     }
                 }
             }
@@ -555,7 +559,8 @@ mod tests {
         pub mode_reply_rx_to_pus: mpsc::Receiver<GenericMessage<ModeReply>>,
         pub mode_reply_rx_to_parent: mpsc::Receiver<GenericMessage<ModeReply>>,
         pub composite_request_tx: mpsc::Sender<GenericMessage<CompositeRequest>>,
-        pub hk_reply_rx: mpsc::Receiver<GenericMessage<HkReply>>,
+        //pub hk_reply_rx: mpsc::Receiver<GenericMessage<HkReply>>,
+        pub hk_rx: std::sync::mpsc::Receiver<CcsdsTmPacketOwned>,
         pub tm_rx: mpsc::Receiver<PacketAsVec>,
         pub switch_request_tx: mpsc::Sender<GenericMessage<SwitchRequest>>,
         pub handler: PcduHandler<SerialInterfaceTest>,
@@ -568,7 +573,7 @@ mod tests {
             let (mode_reply_tx_to_parent, mode_reply_rx_to_parent) = mpsc::sync_channel(5);
             let mode_node = ModeRequestHandlerMpscBounded::new(PCDU.into(), mode_request_rx);
             let (composite_request_tx, composite_request_rx) = mpsc::channel();
-            let (hk_reply_tx, hk_reply_rx) = mpsc::sync_channel(10);
+            let (hk_tx, hk_rx) = mpsc::sync_channel(10);
             let (tm_tx, tm_rx) = mpsc::sync_channel::<PacketAsVec>(5);
             let (switch_request_tx, switch_reqest_rx) = mpsc::channel();
             let shared_switch_map = Arc::new(Mutex::new(SwitchSet::default()));
@@ -577,7 +582,7 @@ mod tests {
                 "TEST_PCDU",
                 mode_node,
                 composite_request_rx,
-                hk_reply_tx,
+                hk_tx,
                 switch_reqest_rx,
                 TmTcSender::Heap(tm_tx.clone()),
                 SerialInterfaceTest::default(),
@@ -590,7 +595,7 @@ mod tests {
                 mode_reply_rx_to_pus,
                 mode_reply_rx_to_parent,
                 composite_request_tx,
-                hk_reply_rx,
+                hk_rx,
                 tm_rx,
                 switch_request_tx,
                 handler,

satrs-example/src/lib.rs

@@ -1,8 +1,115 @@
-use satrs::spacepackets::time::cds::CdsTime;
+extern crate alloc;
+
+use satrs::spacepackets::{
+    ccsds_packet_len_for_user_data_len_with_checksum, time::cds::CdsTime, CcsdsPacketCreationError,
+    CcsdsPacketCreatorWithReservedData, CcsdsPacketIdAndPsc, SpacePacketHeader,
+};
 
 pub mod config;
 pub mod ids;
 
+#[derive(
+    Debug,
+    Copy,
+    Clone,
+    PartialEq,
+    Eq,
+    Hash,
+    serde::Serialize,
+    serde::Deserialize,
+    num_enum::TryFromPrimitive,
+    num_enum::IntoPrimitive,
+)]
+#[repr(u64)]
+pub enum ComponentId {
+    Pcdu,
+}
+
+#[derive(Debug, Copy, Clone, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
+pub enum MessageType {
+    Ping,
+    Mode,
+    Hk,
+    Action,
+    Verification,
+}
+
+/// Unserialized owned TM packet which can be cloned and sent around.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct CcsdsTmPacketOwned {
+    pub sp_header: SpacePacketHeader,
+    pub tm_header: TmHeader,
+    pub payload: alloc::vec::Vec<u8>,
+}
+
+#[derive(Debug, thiserror::Error)]
+pub enum CcsdsCreationError {
+    #[error("CCSDS packet creation error: {0}")]
+    CcsdsPacketCreation(#[from] CcsdsPacketCreationError),
+    #[error("postcard error: {0}")]
+    Postcard(#[from] postcard::Error),
+    #[error("timestamp generation error")]
+    Time,
+}
+
+impl CcsdsTmPacketOwned {
+    pub fn write_to_bytes(&self, buf: &mut [u8]) -> Result<usize, CcsdsCreationError> {
+        let response_len =
+            postcard::experimental::serialized_size(&self.tm_header)? + self.payload.len();
+        let mut ccsds_tm = CcsdsPacketCreatorWithReservedData::new_tm_with_checksum(
+            self.sp_header,
+            response_len,
+            buf,
+        )?;
+        let user_data = ccsds_tm.packet_data_mut();
+        let ser_len = postcard::to_slice(&self.tm_header, user_data)?.len();
+        user_data[ser_len..ser_len + self.payload.len()].copy_from_slice(&self.payload);
+        let ccsds_packet_len = ccsds_tm.finish();
+        Ok(ccsds_packet_len)
+    }
+
+    pub fn len_written(&self) -> usize {
+        ccsds_packet_len_for_user_data_len_with_checksum(
+            postcard::experimental::serialized_size(&self.tm_header).unwrap() as usize
+                + postcard::experimental::serialized_size(&self.payload).unwrap() as usize,
+        )
+        .unwrap()
+    }
+
+    pub fn to_vec(&self) -> Result<alloc::vec::Vec<u8>, CcsdsCreationError> {
+        let mut buf = alloc::vec![0u8; self.len_written()];
+        let len = self.write_to_bytes(&mut buf)?;
+        buf.truncate(len);
+        Ok(buf)
+    }
+}
+
+#[derive(Debug, Copy, Clone, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
+#[non_exhaustive]
+pub struct TmHeader {
+    pub sender_id: ComponentId,
+    pub target_id: ComponentId,
+    pub message_type: MessageType,
+    /// Telemetry can either be sent unsolicited, or as a response to telecommands.
+    pub tc_id: Option<CcsdsPacketIdAndPsc>,
+    /// Raw CDS short timestamp.
+    pub timestamp: Option<[u8; 7]>,
+}
+
+#[derive(Debug, Copy, Clone, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
+#[non_exhaustive]
+pub struct TcHeader {
+    pub target_id: ComponentId,
+    pub request_type: MessageType,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct CcsdsTcPacketOwned {
+    pub sp_header: SpacePacketHeader,
+    pub tc_header: TcHeader,
+    pub payload: alloc::vec::Vec<u8>,
+}
+
 #[derive(Debug, PartialEq, Eq, Copy, Clone)]
 pub enum DeviceMode {
     Off = 0,