this is complicated

fsrc-example/Cargo.toml

@@ -6,6 +6,7 @@ authors = ["Robin Mueller <muellerr@irs.uni-stuttgart.de>"]
 
 [dependencies]
 crossbeam-channel = "0.5"
+delegate = "0.8"
 
 [dependencies.spacepackets]
 path = "../spacepackets"

fsrc-example/src/bin/obsw/main.rs

@@ -2,13 +2,16 @@ mod ccsds;
 mod pus;
 mod tmtc;
 
-use crate::tmtc::{core_tmtc_task, TmStore};
+use crate::tmtc::{core_tmtc_task, TmStore, PUS_APID};
 use fsrc_core::hal::host::udp_server::UdpTcServer;
-use fsrc_core::pool::{LocalPool, PoolCfg, StoreAddr};
+use fsrc_core::pool::{LocalPool, PoolCfg, SharedPool, StoreAddr};
+use fsrc_core::pus::verification::{
+    MpscVerifSender, VerificationReporterCfg, VerificationReporterWithSender,
+};
 use fsrc_core::tmtc::CcsdsError;
 use fsrc_example::{OBSW_SERVER_ADDR, SERVER_PORT};
 use std::net::{IpAddr, SocketAddr};
-use std::sync::{mpsc, Arc, Mutex};
+use std::sync::{mpsc, Arc, Mutex, RwLock};
 use std::thread;
 
 struct TmFunnel {
@@ -19,7 +22,7 @@ struct TmFunnel {
 struct UdpTmtcServer {
     udp_tc_server: UdpTcServer<CcsdsError<()>>,
     tm_rx: mpsc::Receiver<StoreAddr>,
-    tm_store: Arc<Mutex<TmStore>>,
+    tm_store: SharedPool,
 }
 
 unsafe impl Send for UdpTmtcServer {}
@@ -28,13 +31,27 @@ fn main() {
     println!("Running OBSW example");
     let pool_cfg = PoolCfg::new(vec![(8, 32), (4, 64), (2, 128)]);
     let tm_pool = LocalPool::new(pool_cfg);
-    let tm_store = Arc::new(Mutex::new(TmStore { pool: tm_pool }));
+    let tm_store: SharedPool = Arc::new(RwLock::new(Box::new(tm_pool)));
+    let tm_store_helper = TmStore {
+        pool: tm_store.clone(),
+    };
     let addr = SocketAddr::new(IpAddr::V4(OBSW_SERVER_ADDR), SERVER_PORT);
-    let (tm_creator_tx, tm_funnel_rx) = mpsc::channel();
+    let (tm_funnel_tx, tm_funnel_rx) = mpsc::channel();
     let (tm_server_tx, tm_server_rx) = mpsc::channel();
-
+    let sender = MpscVerifSender::new(tm_store.clone(), tm_funnel_tx.clone());
+    let verif_cfg = VerificationReporterCfg::new(PUS_APID, 1, 2, 8);
+    let reporter_with_sender_0 = Arc::new(Mutex::new(VerificationReporterWithSender::new(
+        verif_cfg,
+        Box::new(sender),
+    )));
     let jh0 = thread::spawn(move || {
-        core_tmtc_task(tm_creator_tx.clone(), tm_server_rx, tm_store.clone(), addr);
+        core_tmtc_task(
+            tm_funnel_tx.clone(),
+            tm_server_rx,
+            tm_store_helper.clone(),
+            addr,
+            reporter_with_sender_0,
+        );
     });
 
     let jh1 = thread::spawn(move || {

fsrc-example/src/bin/obsw/pus.rs

@@ -1,23 +1,31 @@
-use crate::TmStore;
+use crate::tmtc::TmStore;
 use fsrc_core::pool::StoreAddr;
+use fsrc_core::pus::verification::SharedStdVerifReporterWithSender;
 use fsrc_core::tmtc::tm_helper::PusTmWithCdsShortHelper;
 use fsrc_core::tmtc::PusServiceProvider;
 use spacepackets::tc::{PusTc, PusTcSecondaryHeaderT};
 use spacepackets::SpHeader;
-use std::sync::{mpsc, Arc, Mutex};
+use std::sync::mpsc;
 
 pub struct PusReceiver {
     pub tm_helper: PusTmWithCdsShortHelper,
     pub tm_tx: mpsc::Sender<StoreAddr>,
-    pub tm_store: Arc<Mutex<TmStore>>,
+    pub tm_store: TmStore,
+    pub verif_reporter: SharedStdVerifReporterWithSender,
 }
 
 impl PusReceiver {
-    pub fn new(apid: u16, tm_tx: mpsc::Sender<StoreAddr>, tm_store: Arc<Mutex<TmStore>>) -> Self {
+    pub fn new(
+        apid: u16,
+        tm_tx: mpsc::Sender<StoreAddr>,
+        tm_store: TmStore,
+        verif_reporter: SharedStdVerifReporterWithSender,
+    ) -> Self {
         Self {
             tm_helper: PusTmWithCdsShortHelper::new(apid),
             tm_tx,
             tm_store,
+            verif_reporter,
         }
     }
 }
@@ -44,11 +52,7 @@ impl PusReceiver {
             println!("Received PUS ping command TC[17,1]");
             println!("Sending ping reply PUS TM[17,2]");
             let ping_reply = self.tm_helper.create_pus_tm_timestamp_now(17, 2, None);
-            let addr = self
-                .tm_store
-                .lock()
-                .expect("Locking TM store failed")
-                .add_pus_tm(&ping_reply);
+            let addr = self.tm_store.add_pus_tm(&ping_reply);
             self.tm_tx
                 .send(addr)
                 .expect("Sending TM to TM funnel failed");

fsrc-example/src/bin/obsw/tmtc.rs

@@ -1,28 +1,28 @@
 use fsrc_core::hal::host::udp_server::{ReceiveResult, UdpTcServer};
 use std::net::SocketAddr;
-use std::sync::{mpsc, Arc, Mutex};
+use std::sync::mpsc;
 use std::thread;
 use std::time::Duration;
 
 use crate::ccsds::CcsdsReceiver;
 use crate::pus::PusReceiver;
 use crate::UdpTmtcServer;
-use fsrc_core::pool::{LocalPool, StoreAddr};
+use fsrc_core::pool::{SharedPool, StoreAddr};
+use fsrc_core::pus::verification::SharedStdVerifReporterWithSender;
 use fsrc_core::tmtc::{CcsdsDistributor, CcsdsError, PusDistributor};
 use spacepackets::tm::PusTm;
 
 pub const PUS_APID: u16 = 0x02;
 
+#[derive(Clone)]
 pub struct TmStore {
-    pub pool: LocalPool,
+    pub pool: SharedPool,
 }
 
 impl TmStore {
     pub fn add_pus_tm(&mut self, pus_tm: &PusTm) -> StoreAddr {
-        let (addr, buf) = self
-            .pool
-            .free_element(pus_tm.len_packed())
-            .expect("Store error");
+        let mut pg = self.pool.write().expect("Error locking TM store");
+        let (addr, buf) = pg.free_element(pus_tm.len_packed()).expect("Store error");
         pus_tm
             .write_to(buf)
             .expect("Writing PUS TM to store failed");
@@ -33,10 +33,16 @@ impl TmStore {
 pub fn core_tmtc_task(
     tm_creator_tx: mpsc::Sender<StoreAddr>,
     tm_server_rx: mpsc::Receiver<StoreAddr>,
-    tm_store: Arc<Mutex<TmStore>>,
+    tm_store_helper: TmStore,
     addr: SocketAddr,
+    verif_reporter: SharedStdVerifReporterWithSender,
 ) {
-    let pus_receiver = PusReceiver::new(PUS_APID, tm_creator_tx, tm_store.clone());
+    let pus_receiver = PusReceiver::new(
+        PUS_APID,
+        tm_creator_tx,
+        tm_store_helper.clone(),
+        verif_reporter,
+    );
     let pus_distributor = PusDistributor::new(Box::new(pus_receiver));
     let ccsds_receiver = CcsdsReceiver {
         pus_handler: pus_distributor,
@@ -44,10 +50,11 @@ pub fn core_tmtc_task(
     let ccsds_distributor = CcsdsDistributor::new(Box::new(ccsds_receiver));
     let udp_tc_server = UdpTcServer::new(addr, 2048, Box::new(ccsds_distributor))
         .expect("Creating UDP TMTC server failed");
+
     let mut udp_tmtc_server = UdpTmtcServer {
         udp_tc_server,
         tm_rx: tm_server_rx,
-        tm_store,
+        tm_store: tm_store_helper.pool.clone(),
     };
     loop {
         core_tmtc_loop(&mut udp_tmtc_server);
@@ -89,9 +96,9 @@ fn core_tm_handling(udp_tmtc_server: &mut UdpTmtcServer, recv_addr: &SocketAddr)
     while let Ok(addr) = udp_tmtc_server.tm_rx.try_recv() {
         let mut store_lock = udp_tmtc_server
             .tm_store
-            .lock()
+            .write()
             .expect("Locking TM store failed");
-        let pg = store_lock.pool.read_with_guard(addr);
+        let pg = store_lock.read_with_guard(addr);
         let buf = pg.read().expect("Error reading TM pool data");
         println!("Sending TM");
         udp_tmtc_server

fsrc-example/src/bin/test.rs

@@ -27,10 +27,7 @@ impl FieldDataProvider for FixedFieldDataWrapper {
 type FieldDataTraitObj = Box<dyn FieldDataProvider>;
 
 fn main() {
-    let (s0, r0): (
-        Sender<FieldDataTraitObj>,
-        Receiver<FieldDataTraitObj>,
-    ) = bounded(5);
+    let (s0, r0): (Sender<FieldDataTraitObj>, Receiver<FieldDataTraitObj>) = bounded(5);
     let data_wrapper = FixedFieldDataWrapper::from_two_u32(2, 3);
     s0.send(Box::new(data_wrapper)).unwrap();
     let jh0 = thread::spawn(move || {