cleaned up code and bumped sat-rs

src/tmtc/tc_source.rs

@@ -1,33 +1,23 @@
-use satrs::{pool::PoolProvider, tmtc::tc_helper::SharedTcPool};
 use std::sync::mpsc::{self, TryRecvError};
 
-use satrs::{
-    pool::StoreAddr,
-    pus::{MpscTmAsVecSender, MpscTmInSharedPoolSenderBounded},
-    spacepackets::ecss::{tc::PusTcReader, PusPacket},
-};
+use satrs::pus::{MpscTmAsVecSender, PacketAsVec};
 
 use crate::pus::PusTcDistributor;
 
-// TC source components where static pools are the backing memory of the received telecommands.
-pub struct TcSourceTaskStatic {
-    shared_tc_pool: SharedTcPool,
-    tc_receiver: mpsc::Receiver<StoreAddr>,
-    tc_buf: [u8; 4096],
-    pus_receiver: PusTcDistributor<MpscTmInSharedPoolSenderBounded>,
+// TC source components where the heap is the backing memory of the received telecommands.
+pub struct TcSourceTaskDynamic {
+    pub tc_receiver: mpsc::Receiver<PacketAsVec>,
+    pus_distrib: PusTcDistributor<MpscTmAsVecSender>,
 }
 
-impl TcSourceTaskStatic {
+impl TcSourceTaskDynamic {
     pub fn new(
-        shared_tc_pool: SharedTcPool,
-        tc_receiver: mpsc::Receiver<StoreAddr>,
-        pus_receiver: PusTcDistributor<MpscTmInSharedPoolSenderBounded>,
+        tc_receiver: mpsc::Receiver<PacketAsVec>,
+        pus_receiver: PusTcDistributor<MpscTmAsVecSender>,
     ) -> Self {
         Self {
-            shared_tc_pool,
             tc_receiver,
-            tc_buf: [0; 4096],
-            pus_receiver,
+            pus_distrib: pus_receiver,
         }
     }
 
@@ -36,33 +26,14 @@ impl TcSourceTaskStatic {
     }
 
     pub fn poll_tc(&mut self) -> bool {
+        // Right now, we only expect PUS packets. If any other protocols like CFDP are added at
+        // a later stage, we probably need to check for the APID before routing the packet.
         match self.tc_receiver.try_recv() {
-            Ok(addr) => {
-                let pool = self
-                    .shared_tc_pool
-                    .0
-                    .read()
-                    .expect("locking tc pool failed");
-                pool.read(&addr, &mut self.tc_buf)
-                    .expect("reading pool failed");
-                drop(pool);
-                match PusTcReader::new(&self.tc_buf) {
-                    Ok((pus_tc, _)) => {
-                        self.pus_receiver
-                            .handle_tc_packet(
-                                satrs::pus::TcInMemory::StoreAddr(addr),
-                                pus_tc.service(),
-                                &pus_tc,
-                            )
-                            .ok();
-                        true
-                    }
-                    Err(e) => {
-                        log::warn!("error creating PUS TC from raw data: {e}");
-                        log::warn!("raw data: {:x?}", self.tc_buf);
-                        true
-                    }
-                }
+            Ok(packet_with_sender) => {
+                self.pus_distrib
+                    .handle_tc_packet(packet_with_sender.sender_id, packet_with_sender.packet)
+                    .ok();
+                true
             }
             Err(e) => match e {
                 TryRecvError::Empty => false,
@@ -74,55 +45,3 @@ impl TcSourceTaskStatic {
         }
     }
 }
-
-// TC source components where the heap is the backing memory of the received telecommands.
-pub struct TcSourceTaskDynamic {
-    pub tc_receiver: mpsc::Receiver<Vec<u8>>,
-    pus_receiver: PusTcDistributor<MpscTmAsVecSender>,
-}
-
-impl TcSourceTaskDynamic {
-    pub fn new(
-        tc_receiver: mpsc::Receiver<Vec<u8>>,
-        pus_receiver: PusTcDistributor<MpscTmAsVecSender>,
-    ) -> Self {
-        Self {
-            tc_receiver,
-            pus_receiver,
-        }
-    }
-
-    pub fn periodic_operation(&mut self) {
-        self.poll_tc();
-    }
-
-    pub fn poll_tc(&mut self) -> bool {
-        // Right now, we only expect PUS packets.
-        match self.tc_receiver.try_recv() {
-            Ok(tc) => match PusTcReader::new(&tc) {
-                Ok((pus_tc, _)) => {
-                    self.pus_receiver
-                        .handle_tc_packet(
-                            satrs::pus::TcInMemory::Vec(tc.clone()),
-                            pus_tc.service(),
-                            &pus_tc,
-                        )
-                        .ok();
-                    true
-                }
-                Err(e) => {
-                    log::warn!("error creating PUS TC from raw data: {e}");
-                    log::warn!("raw data: {:x?}", tc);
-                    true
-                }
-            },
-            Err(e) => match e {
-                TryRecvError::Empty => false,
-                TryRecvError::Disconnected => {
-                    log::warn!("tmtc thread: sender disconnected");
-                    false
-                }
-            },
-        }
-    }
-}

src/tmtc/tm_sink.rs

@@ -4,7 +4,7 @@ use std::{collections::HashMap, sync::mpsc, time::Duration};
 
 use log::info;
 use ops_sat_rs::config::tasks::STOP_CHECK_FREQUENCY;
-use satrs::pus::PusTmAsVec;
+use satrs::pus::PacketAsVec;
 use satrs::{
     seq_count::{CcsdsSimpleSeqCountProvider, SequenceCountProviderCore},
     spacepackets::{
@@ -76,16 +76,16 @@ impl TmFunnelCommon {
 
 pub struct TmFunnelDynamic {
     common: TmFunnelCommon,
-    tm_funnel_rx: mpsc::Receiver<PusTmAsVec>,
-    tm_server_tx: mpsc::Sender<PusTmAsVec>,
+    tm_funnel_rx: mpsc::Receiver<PacketAsVec>,
+    tm_server_tx: mpsc::Sender<PacketAsVec>,
     stop_signal: Arc<AtomicBool>,
 }
 
 impl TmFunnelDynamic {
     pub fn new(
         sync_tm_tcp_source: SyncTcpTmSource,
-        tm_funnel_rx: mpsc::Receiver<PusTmAsVec>,
-        tm_server_tx: mpsc::Sender<PusTmAsVec>,
+        tm_funnel_rx: mpsc::Receiver<PacketAsVec>,
+        tm_server_tx: mpsc::Sender<PacketAsVec>,
         stop_signal: Arc<AtomicBool>,
     ) -> Self {
         Self {