this is really annoying

fsrc-core/Cargo.toml

@@ -11,6 +11,11 @@ bus = "2.2.3"
 num = "0.4"
 spacepackets = { path = "../spacepackets"}
 
+[dev-dependencies]
+postcard = { version = "1.0.1", features = ["use-std"] }
+serde = "1.0.143"
+zerocopy = "0.6.1"
+
 [features]
 default = ["use_std"]
 use_std = []

fsrc-core/src/pool.rs

@@ -23,7 +23,7 @@
 //!     // Add new data to the pool
 //!     let mut example_data = [0; 4];
 //!     example_data[0] = 42;
-//!     let res = local_pool.add(example_data);
+//!     let res = local_pool.add(&example_data);
 //!     assert!(res.is_ok());
 //!     addr = res.unwrap();
 //! }

fsrc-core/src/tmtc/ccsds_distrib.rs

@@ -1,26 +1,25 @@
 use crate::error::FsrcErrorHandler;
-use crate::tmtc::{
-    ReceivesCcsds, ReceivesTc, FROM_BYTES_SLICE_TOO_SMALL_ERROR, FROM_BYTES_ZEROCOPY_ERROR,
-};
+use crate::tmtc::{ReceivesTc, FROM_BYTES_SLICE_TOO_SMALL_ERROR, FROM_BYTES_ZEROCOPY_ERROR};
 use spacepackets::{CcsdsPacket, PacketError, SpHeader};
 
 pub trait HandlesPacketForApid {
-    fn get_apid_handler(&mut self, apid: u16) -> Option<&mut Box<dyn ReceivesCcsds>>;
+    fn valid_apids(&self) -> &'static [u16];
+    fn handle_known_apid(&mut self, sp_header: &SpHeader, tc_raw: &[u8]);
     fn handle_unknown_apid(&mut self, sp_header: &SpHeader, tc_raw: &[u8]);
 }
 
 pub struct CcsdsDistributor {
-    apid_handlers: Box<dyn HandlesPacketForApid>,
+    apid_handler: Box<dyn HandlesPacketForApid>,
     error_handler: Box<dyn FsrcErrorHandler>,
 }
 
-impl CcsdsDistributor {
+impl<'a> CcsdsDistributor {
     pub fn new(
-        apid_handlers: Box<dyn HandlesPacketForApid>,
+        apid_handler: Box<dyn HandlesPacketForApid>,
         error_handler: Box<dyn FsrcErrorHandler>,
     ) -> Self {
         CcsdsDistributor {
-            apid_handlers,
+            apid_handler,
             error_handler,
         }
     }
@@ -50,13 +49,12 @@ impl ReceivesTc for CcsdsDistributor {
             }
         };
         let apid = sp_header.apid();
-        match self.apid_handlers.get_apid_handler(apid) {
-            None => {
-                self.apid_handlers.handle_unknown_apid(&sp_header, tm_raw);
-            }
-            Some(handler) => {
-                handler.pass_ccsds(&sp_header, tm_raw).ok();
+        let valid_apids = self.apid_handler.valid_apids();
+        for &valid_apid in valid_apids {
+            if valid_apid == apid {
+                self.apid_handler.handle_known_apid(&sp_header, tm_raw);
             }
         }
+        self.apid_handler.handle_unknown_apid(&sp_header, tm_raw);
     }
 }

fsrc-core/src/tmtc/mod.rs

@@ -29,11 +29,11 @@ pub trait ReceivesTc {
     fn pass_tc(&mut self, tc_raw: &[u8]);
 }
 
-pub trait ReceivesCcsds {
-    fn pass_ccsds(&mut self, header: &SpHeader, tm_raw: &[u8]) -> Result<(), PacketError>;
+pub trait ReceivesCcsdsTc {
+    fn pass_ccsds(&mut self, header: &SpHeader, tc_raw: &[u8]) -> Result<(), PacketError>;
 }
 
-pub trait ReceivesPus {
+pub trait ReceivesPusTc {
     fn pass_pus(&mut self, pus_tc: &PusTc) -> Result<(), PusError>;
 }
 
@@ -43,54 +43,61 @@ mod tests {
     use crate::error::SimpleStdErrorHandler;
     use crate::tmtc::ccsds_distrib::{CcsdsDistributor, HandlesPacketForApid};
     use spacepackets::CcsdsPacket;
-    use std::collections::HashMap;
+    use std::collections::VecDeque;
+    use std::sync::{Arc, Mutex};
 
-    #[derive(Copy, Clone)]
-    struct DummyCcsdsHandler {}
-
-    impl ReceivesCcsds for DummyCcsdsHandler {
-        fn pass_ccsds(&mut self, header: &SpHeader, tm_raw: &[u8]) -> Result<(), PacketError> {
-            println!("CCSDS packet with header {:?} received", header);
-            println!("Raw data with len {}: {:x?}", tm_raw.len(), tm_raw);
-            Ok(())
-        }
-    }
+    #[derive(Default)]
     struct ApidHandler {
-        handler_map: HashMap<u16, Box<dyn ReceivesCcsds>>,
+        known_packet_queue: Arc<Mutex<VecDeque<(u16, Vec<u8>)>>>,
+        unknown_packet_queue: Arc<Mutex<VecDeque<(u16, Vec<u8>)>>>,
     }
 
-    impl ApidHandler {
-        pub fn add_ccsds_handler(&mut self, apid: u16, ccsds_receiver: Box<dyn ReceivesCcsds>) {
-            // TODO: Error handling
-            self.handler_map.insert(apid, ccsds_receiver);
-        }
-    }
     impl HandlesPacketForApid for ApidHandler {
-        fn get_apid_handler(&mut self, apid: u16) -> Option<&mut Box<dyn ReceivesCcsds>> {
-            self.handler_map.get_mut(&apid)
+        fn valid_apids(&self) -> &'static [u16] {
+            &[0x000, 0x002]
+        }
+
+        fn handle_known_apid(&mut self, sp_header: &SpHeader, tc_raw: &[u8]) {
+            let mut vec = Vec::new();
+            vec.extend_from_slice(tc_raw);
+            self.known_packet_queue
+                .lock()
+                .unwrap()
+                .push_back((sp_header.apid(), vec));
         }
 
         fn handle_unknown_apid(&mut self, sp_header: &SpHeader, tc_raw: &[u8]) {
-            println!("Packet with unknown APID {} received", sp_header.apid());
-            println!("Packet with len {}: {:x?}", tc_raw.len(), tc_raw);
+            let mut vec = Vec::new();
+            vec.extend_from_slice(tc_raw);
+            self.unknown_packet_queue
+                .lock()
+                .unwrap()
+                .push_back((sp_header.apid(), vec));
         }
     }
+
     #[test]
-    fn test_distribs() {
-        let ccsds_handler = DummyCcsdsHandler {};
-        let mut apid_handler = ApidHandler {
-            handler_map: HashMap::new(),
+    fn test_distribs_known_apid() {
+        let known_packet_queue = Arc::new(Mutex::default());
+        let unknown_packet_queue = Arc::new(Mutex::default());
+        let apid_handler = ApidHandler {
+            known_packet_queue: known_packet_queue.clone(),
+            unknown_packet_queue: unknown_packet_queue.clone(),
         };
         let error_handler = SimpleStdErrorHandler {};
-        apid_handler.add_ccsds_handler(0, Box::new(ccsds_handler));
         let mut ccsds_distrib =
             CcsdsDistributor::new(Box::new(apid_handler), Box::new(error_handler));
-        let mut sph = SpHeader::tc(0, 0x34, 0).unwrap();
+        let mut sph = SpHeader::tc(0x002, 0x34, 0).unwrap();
         let pus_tc = PusTc::new_simple(&mut sph, 17, 1, None, true);
         let mut test_buf: [u8; 32] = [0; 32];
         pus_tc
             .write_to(test_buf.as_mut_slice())
             .expect("Error writing TC to buffer");
         ccsds_distrib.pass_tc(&test_buf);
+        let recvd = known_packet_queue.lock().unwrap().pop_front();
+        assert!(recvd.is_some());
+        let (apid, packet) = recvd.unwrap();
+        assert_eq!(apid, 0x002);
+        assert_eq!(packet.as_slice(), test_buf);
     }
 }

fsrc-core/src/tmtc/pus_distrib.rs

@@ -1,12 +1,12 @@
 use crate::error::FsrcErrorHandler;
-use crate::tmtc::{ReceivesCcsds, ReceivesPus, ReceivesTc};
+use crate::tmtc::{ReceivesCcsdsTc, ReceivesPusTc, ReceivesTc};
 use spacepackets::ecss::{PusError, PusPacket};
 use spacepackets::tc::PusTc;
 use spacepackets::{CcsdsPacket, PacketError, SpHeader};
 
 pub trait PusServiceProvider {
     fn get_apid(&self, service: u8) -> u16;
-    fn get_service_handler(&self, service: u8, subservice: u8) -> Box<dyn ReceivesPus>;
+    fn get_service_handler(&self, service: u8, subservice: u8) -> Box<dyn ReceivesPusTc>;
 }
 
 pub struct PusDistributor {
@@ -22,7 +22,7 @@ impl ReceivesTc for PusDistributor {
     }
 }
 
-impl ReceivesCcsds for PusDistributor {
+impl ReceivesCcsdsTc for PusDistributor {
     fn pass_ccsds(&mut self, _header: &SpHeader, tm_raw: &[u8]) -> Result<(), PacketError> {
         // TODO: Better error handling
         let (tc, _) = match PusTc::new_from_raw_slice(tm_raw) {