rename subfolders, add more READMEs

satrs-example/Cargo.toml

@@ -0,0 +1,16 @@
+[package]
+name = "fsrc-example"
+version = "0.1.0"
+edition = "2021"
+authors = ["Robin Mueller <muellerr@irs.uni-stuttgart.de>"]
+
+[dependencies]
+crossbeam-channel = "0.5"
+delegate = "0.8"
+zerocopy = "0.6"
+
+[dependencies.spacepackets]
+path = "../spacepackets"
+
+[dependencies.fsrc-core]
+path = "../fsrc-core"

satrs-example/pyclient/.gitignore

@@ -0,0 +1,4 @@
+/venv
+/log
+/.idea/*
+!/.idea/runConfigurations

satrs-example/pyclient/main.py

@@ -0,0 +1,277 @@
+#!/usr/bin/env python3
+"""Example client for the sat-rs example application"""
+import sys
+import time
+from typing import Optional
+
+import tmtccmd
+from spacepackets.ecss import PusTelemetry, PusTelecommand, PusVerificator
+from spacepackets.ecss.pus_17_test import Service17Tm
+from spacepackets.ecss.pus_1_verification import UnpackParams, Service1Tm
+from spacepackets.util import UnsignedByteField
+
+from tmtccmd import CcsdsTmtcBackend, TcHandlerBase, ProcedureParamsWrapper
+from tmtccmd.core.base import BackendRequest
+from tmtccmd.pus import VerificationWrapper
+from tmtccmd.tm import CcsdsTmHandler, SpecificApidHandlerBase
+from tmtccmd.com_if import ComInterface
+from tmtccmd.config import (
+    default_json_path,
+    SetupParams,
+    TmTcCfgHookBase,
+    TmtcDefinitionWrapper,
+    CoreServiceList,
+    OpCodeEntry,
+    params_to_procedure_conversion,
+)
+from tmtccmd.config import PreArgsParsingWrapper, SetupWrapper
+from tmtccmd.logging import get_console_logger
+from tmtccmd.logging.pus import (
+    RegularTmtcLogWrapper,
+    RawTmtcTimedLogWrapper,
+    TimedLogWhen,
+)
+from tmtccmd.tc import (
+    TcQueueEntryType,
+    ProcedureWrapper,
+    TcProcedureType,
+    FeedWrapper,
+    SendCbParams,
+    DefaultPusQueueHelper,
+)
+from tmtccmd.tm.pus_5_event import Service5Tm
+from tmtccmd.util import FileSeqCountProvider, PusFileSeqCountProvider
+from tmtccmd.util.obj_id import ObjectIdDictT
+
+from tmtccmd.util.tmtc_printer import FsfwTmTcPrinter
+
+LOGGER = get_console_logger()
+
+EXAMPLE_PUS_APID = 0x02
+
+
+class SatRsConfigHook(TmTcCfgHookBase):
+    def __init__(self, json_cfg_path: str):
+        super().__init__(json_cfg_path=json_cfg_path)
+
+    def assign_communication_interface(self, com_if_key: str) -> Optional[ComInterface]:
+        print("Communication interface assignment function was called")
+        from tmtccmd.config.com_if import (
+            create_com_interface_default,
+            create_com_interface_cfg_default,
+        )
+
+        cfg = create_com_interface_cfg_default(
+            com_if_key=com_if_key,
+            json_cfg_path=self.cfg_path,
+            space_packet_ids=None,
+        )
+        return create_com_interface_default(cfg)
+
+    def get_tmtc_definitions(self) -> TmtcDefinitionWrapper:
+        from tmtccmd.config.globals import get_default_tmtc_defs
+
+        defs = get_default_tmtc_defs()
+        srv_5 = OpCodeEntry()
+        srv_5.add("0", "Event Test")
+        defs.add_service(
+            name=CoreServiceList.SERVICE_5.value,
+            info="PUS Service 5 Event",
+            op_code_entry=srv_5,
+        )
+        srv_17 = OpCodeEntry()
+        srv_17.add("0", "Ping Test")
+        defs.add_service(
+            name=CoreServiceList.SERVICE_17_ALT,
+            info="PUS Service 17 Test",
+            op_code_entry=srv_17,
+        )
+        return defs
+
+    def perform_mode_operation(self, tmtc_backend: CcsdsTmtcBackend, mode: int):
+        LOGGER.info("Mode operation hook was called")
+        pass
+
+    def get_object_ids(self) -> ObjectIdDictT:
+        from tmtccmd.config.objects import get_core_object_ids
+
+        return get_core_object_ids()
+
+
+class PusHandler(SpecificApidHandlerBase):
+    def __init__(
+        self,
+        verif_wrapper: VerificationWrapper,
+        printer: FsfwTmTcPrinter,
+        raw_logger: RawTmtcTimedLogWrapper,
+    ):
+        super().__init__(EXAMPLE_PUS_APID, None)
+        self.printer = printer
+        self.raw_logger = raw_logger
+        self.verif_wrapper = verif_wrapper
+
+    def handle_tm(self, packet: bytes, _user_args: any):
+        try:
+            tm_packet = PusTelemetry.unpack(packet)
+        except ValueError as e:
+            LOGGER.warning("Could not generate PUS TM object from raw data")
+            LOGGER.warning(f"Raw Packet: [{packet.hex(sep=',')}], REPR: {packet!r}")
+            raise e
+        service = tm_packet.service
+        dedicated_handler = False
+        if service == 1:
+            tm_packet = Service1Tm.unpack(data=packet, params=UnpackParams(1, 2))
+            res = self.verif_wrapper.add_tm(tm_packet)
+            if res is None:
+                LOGGER.info(
+                    f"Received Verification TM[{tm_packet.service}, {tm_packet.subservice}] "
+                    f"with Request ID {tm_packet.tc_req_id.as_u32():#08x}"
+                )
+                LOGGER.warning(
+                    f"No matching telecommand found for {tm_packet.tc_req_id}"
+                )
+            else:
+                self.verif_wrapper.log_to_console(tm_packet, res)
+                self.verif_wrapper.log_to_file(tm_packet, res)
+            dedicated_handler = True
+        if service == 5:
+            tm_packet = Service5Tm.unpack(packet)
+        if service == 17:
+            tm_packet = Service17Tm.unpack(packet)
+            dedicated_handler = True
+            if tm_packet.subservice == 2:
+                self.printer.file_logger.info("Received Ping Reply TM[17,2]")
+                LOGGER.info("Received Ping Reply TM[17,2]")
+            else:
+                self.printer.file_logger.info(
+                    f"Received Test Packet with unknown subservice {tm_packet.subservice}"
+                )
+                LOGGER.info(
+                    f"Received Test Packet with unknown subservice {tm_packet.subservice}"
+                )
+        if tm_packet is None:
+            LOGGER.info(
+                f"The service {service} is not implemented in Telemetry Factory"
+            )
+            tm_packet = PusTelemetry.unpack(packet)
+        self.raw_logger.log_tm(tm_packet)
+        if not dedicated_handler and tm_packet is not None:
+            self.printer.handle_long_tm_print(packet_if=tm_packet, info_if=tm_packet)
+
+
+class TcHandler(TcHandlerBase):
+    def __init__(
+        self,
+        seq_count_provider: FileSeqCountProvider,
+        verif_wrapper: VerificationWrapper,
+    ):
+        super(TcHandler, self).__init__()
+        self.seq_count_provider = seq_count_provider
+        self.verif_wrapper = verif_wrapper
+        self.queue_helper = DefaultPusQueueHelper(
+            queue_wrapper=None,
+            seq_cnt_provider=seq_count_provider,
+        )
+
+    def send_cb(self, send_params: SendCbParams):
+        entry_helper = send_params.entry
+        if entry_helper.is_tc:
+            if entry_helper.entry_type == TcQueueEntryType.PUS_TC:
+                pus_tc_wrapper = entry_helper.to_pus_tc_entry()
+                pus_tc_wrapper.pus_tc.seq_count = (
+                    self.seq_count_provider.get_and_increment()
+                )
+                self.verif_wrapper.add_tc(pus_tc_wrapper.pus_tc)
+                raw_tc = pus_tc_wrapper.pus_tc.pack()
+                LOGGER.info(f"Sending {pus_tc_wrapper.pus_tc}")
+                send_params.com_if.send(raw_tc)
+        elif entry_helper.entry_type == TcQueueEntryType.LOG:
+            log_entry = entry_helper.to_log_entry()
+            LOGGER.info(log_entry.log_str)
+
+    def queue_finished_cb(self, helper: ProcedureWrapper):
+        if helper.proc_type == TcProcedureType.DEFAULT:
+            def_proc = helper.to_def_procedure()
+            LOGGER.info(
+                f"Queue handling finished for service {def_proc.service} and "
+                f"op code {def_proc.op_code}"
+            )
+
+    def feed_cb(self, helper: ProcedureWrapper, wrapper: FeedWrapper):
+        self.queue_helper.queue_wrapper = wrapper.queue_wrapper
+        if helper.proc_type == TcProcedureType.DEFAULT:
+            def_proc = helper.to_def_procedure()
+            service = def_proc.service
+            if (
+                service == CoreServiceList.SERVICE_17
+                or service == CoreServiceList.SERVICE_17_ALT
+            ):
+                return self.queue_helper.add_pus_tc(
+                    PusTelecommand(service=17, subservice=1)
+                )
+
+
+def main():
+    tmtccmd.init_printout(False)
+    hook_obj = SatRsConfigHook(json_cfg_path=default_json_path())
+    parser_wrapper = PreArgsParsingWrapper()
+    parser_wrapper.create_default_parent_parser()
+    parser_wrapper.create_default_parser()
+    parser_wrapper.add_def_proc_args()
+    post_args_wrapper = parser_wrapper.parse(hook_obj)
+    params = SetupParams()
+    proc_wrapper = ProcedureParamsWrapper()
+    if post_args_wrapper.use_gui:
+        post_args_wrapper.set_params_without_prompts(params, proc_wrapper)
+    else:
+        post_args_wrapper.set_params_with_prompts(params, proc_wrapper)
+    params.apid = EXAMPLE_PUS_APID
+    setup_args = SetupWrapper(
+        hook_obj=hook_obj, setup_params=params, proc_param_wrapper=proc_wrapper
+    )
+    # Create console logger helper and file loggers
+    tmtc_logger = RegularTmtcLogWrapper()
+    printer = FsfwTmTcPrinter(tmtc_logger.logger)
+    raw_logger = RawTmtcTimedLogWrapper(when=TimedLogWhen.PER_HOUR, interval=1)
+    verificator = PusVerificator()
+    verification_wrapper = VerificationWrapper(verificator, LOGGER, printer.file_logger)
+    # Create primary TM handler and add it to the CCSDS Packet Handler
+    tm_handler = PusHandler(verification_wrapper, printer, raw_logger)
+    ccsds_handler = CcsdsTmHandler(generic_handler=None)
+    ccsds_handler.add_apid_handler(tm_handler)
+
+    # Create TC handler
+    seq_count_provider = PusFileSeqCountProvider()
+    tc_handler = TcHandler(seq_count_provider, verification_wrapper)
+    tmtccmd.setup(setup_args=setup_args)
+    init_proc = params_to_procedure_conversion(setup_args.proc_param_wrapper)
+    tmtc_backend = tmtccmd.create_default_tmtc_backend(
+        setup_wrapper=setup_args,
+        tm_handler=ccsds_handler,
+        tc_handler=tc_handler,
+        init_procedure=init_proc,
+    )
+    tmtccmd.start(tmtc_backend=tmtc_backend, hook_obj=hook_obj)
+    try:
+        while True:
+            state = tmtc_backend.periodic_op(None)
+            if state.request == BackendRequest.TERMINATION_NO_ERROR:
+                sys.exit(0)
+            elif state.request == BackendRequest.DELAY_IDLE:
+                LOGGER.info("TMTC Client in IDLE mode")
+                time.sleep(3.0)
+            elif state.request == BackendRequest.DELAY_LISTENER:
+                time.sleep(0.8)
+            elif state.request == BackendRequest.DELAY_CUSTOM:
+                if state.next_delay.total_seconds() <= 0.4:
+                    time.sleep(state.next_delay.total_seconds())
+                else:
+                    time.sleep(0.4)
+            elif state.request == BackendRequest.CALL_NEXT:
+                pass
+    except KeyboardInterrupt:
+        sys.exit(0)
+
+
+if __name__ == "__main__":
+    main()

satrs-example/pyclient/requirements.txt

@@ -0,0 +1 @@
+tmtccmd == 3.0.0rc2

satrs-example/pyclient/seqcnt.txt

@@ -0,0 +1 @@
+30

satrs-example/pyclient/tmtc_conf.json

@@ -0,0 +1,6 @@
+{
+    "com_if": "udp",
+    "tcpip_udp_ip_addr": "127.0.0.1",
+    "tcpip_udp_port": 7301,
+    "tcpip_udp_recv_max_size": 1500
+}

satrs-example/src/bin/client.rs

@@ -0,0 +1,96 @@
+use fsrc_core::pus::verification::RequestId;
+use fsrc_example::{OBSW_SERVER_ADDR, SERVER_PORT};
+use spacepackets::ecss::PusPacket;
+use spacepackets::tc::PusTc;
+use spacepackets::tm::PusTm;
+use spacepackets::SpHeader;
+use std::net::{IpAddr, SocketAddr, UdpSocket};
+use std::time::Duration;
+
+fn main() {
+    let mut buf = [0; 32];
+    let addr = SocketAddr::new(IpAddr::V4(OBSW_SERVER_ADDR), SERVER_PORT);
+    let mut sph = SpHeader::tc(0x02, 0, 0).unwrap();
+    let pus_tc = PusTc::new_simple(&mut sph, 17, 1, None, true);
+    let client = UdpSocket::bind("127.0.0.1:7302").expect("Connecting to UDP server failed");
+    let tc_req_id = RequestId::new(&pus_tc);
+    println!(
+        "Packing and sending PUS ping command TC[17,1] with request ID {}",
+        tc_req_id
+    );
+    let size = pus_tc
+        .write_to_bytes(&mut buf)
+        .expect("Creating PUS TC failed");
+    client
+        .send_to(&buf[0..size], &addr)
+        .expect(&*format!("Sending to {:?} failed", addr));
+    client
+        .set_read_timeout(Some(Duration::from_secs(2)))
+        .expect("Setting read timeout failed");
+    loop {
+        let res = client.recv(&mut buf);
+        match res {
+            Ok(_len) => {
+                let (pus_tm, size) = PusTm::from_bytes(&buf, 7).expect("Parsing PUS TM failed");
+                if pus_tm.service() == 17 && pus_tm.subservice() == 2 {
+                    println!("Received PUS Ping Reply TM[17,2]")
+                } else if pus_tm.service() == 1 {
+                    if pus_tm.source_data().is_none() {
+                        println!("Invalid verification TM, no source data");
+                    }
+                    let src_data = pus_tm.source_data().unwrap();
+                    if src_data.len() < 4 {
+                        println!("Invalid verification TM source data, less than 4 bytes")
+                    }
+                    let req_id = RequestId::from_bytes(src_data).unwrap();
+                    if pus_tm.subservice() == 1 {
+                        println!(
+                            "Received TM[1,1] acceptance success for request ID {}",
+                            req_id
+                        )
+                    } else if pus_tm.subservice() == 2 {
+                        println!(
+                            "Received TM[1,2] acceptance failure for request ID {}",
+                            req_id
+                        )
+                    } else if pus_tm.subservice() == 3 {
+                        println!("Received TM[1,3] start success for request ID {}", req_id)
+                    } else if pus_tm.subservice() == 4 {
+                        println!("Received TM[1,2] start failure for request ID {}", req_id)
+                    } else if pus_tm.subservice() == 5 {
+                        println!("Received TM[1,5] step success for request ID {}", req_id)
+                    } else if pus_tm.subservice() == 6 {
+                        println!("Received TM[1,6] step failure for request ID {}", req_id)
+                    } else if pus_tm.subservice() == 7 {
+                        println!(
+                            "Received TM[1,7] completion success for request ID {}",
+                            req_id
+                        )
+                    } else if pus_tm.subservice() == 8 {
+                        println!(
+                            "Received TM[1,8] completion failure for request ID {}",
+                            req_id
+                        );
+                    }
+                } else {
+                    println!(
+                        "Received TM[{}, {}] with {} bytes",
+                        pus_tm.service(),
+                        pus_tm.subservice(),
+                        size
+                    );
+                }
+            }
+            Err(ref e)
+                if e.kind() == std::io::ErrorKind::WouldBlock
+                    || e.kind() == std::io::ErrorKind::TimedOut =>
+            {
+                println!("No reply received for 2 seconds");
+                break;
+            }
+            _ => {
+                println!("UDP receive error {:?}", res.unwrap_err());
+            }
+        }
+    }
+}

satrs-example/src/bin/obsw/ccsds.rs

@@ -0,0 +1,37 @@
+use crate::tmtc::PUS_APID;
+use fsrc_core::tmtc::{CcsdsPacketHandler, PusDistributor, ReceivesCcsdsTc};
+use spacepackets::{CcsdsPacket, SpHeader};
+
+pub struct CcsdsReceiver {
+    pub pus_handler: PusDistributor<()>,
+}
+
+impl CcsdsPacketHandler for CcsdsReceiver {
+    type Error = ();
+
+    fn valid_apids(&self) -> &'static [u16] {
+        &[PUS_APID]
+    }
+
+    fn handle_known_apid(
+        &mut self,
+        sp_header: &SpHeader,
+        tc_raw: &[u8],
+    ) -> Result<(), Self::Error> {
+        if sp_header.apid() == PUS_APID {
+            self.pus_handler
+                .pass_ccsds(sp_header, tc_raw)
+                .expect("Handling PUS packet failed");
+        }
+        Ok(())
+    }
+
+    fn handle_unknown_apid(
+        &mut self,
+        sp_header: &SpHeader,
+        _tc_raw: &[u8],
+    ) -> Result<(), Self::Error> {
+        println!("Unknown APID 0x{:x?} detected", sp_header.apid());
+        Ok(())
+    }
+}

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

@@ -0,0 +1,178 @@
+mod ccsds;
+mod pus;
+mod tmtc;
+
+use crate::tmtc::{core_tmtc_task, CoreTmtcArgs, TmStore, PUS_APID};
+use fsrc_core::event_man::{
+    EventManagerWithMpscQueue, MpscEventReceiver, MpscEventU32SendProvider, SendEventProvider,
+};
+use fsrc_core::events::EventU32;
+use fsrc_core::hal::host::udp_server::UdpTcServer;
+use fsrc_core::pool::{LocalPool, PoolCfg, SharedPool, StoreAddr};
+use fsrc_core::pus::event_man::{
+    DefaultPusMgmtBackendProvider, EventReporter, EventRequest, EventRequestWithToken,
+    PusEventDispatcher,
+};
+use fsrc_core::pus::verification::{
+    MpscVerifSender, VerificationReporterCfg, VerificationReporterWithSender,
+};
+use fsrc_core::pus::{EcssTmError, EcssTmSender};
+use fsrc_core::tmtc::CcsdsError;
+use fsrc_example::{OBSW_SERVER_ADDR, SERVER_PORT};
+use spacepackets::time::{CdsShortTimeProvider, TimeWriter};
+use spacepackets::tm::PusTm;
+use std::net::{IpAddr, SocketAddr};
+use std::sync::mpsc::channel;
+use std::sync::{mpsc, Arc, Mutex, RwLock};
+use std::thread;
+
+struct TmFunnel {
+    tm_funnel_rx: mpsc::Receiver<StoreAddr>,
+    tm_server_tx: mpsc::Sender<StoreAddr>,
+}
+
+struct UdpTmtcServer {
+    udp_tc_server: UdpTcServer<CcsdsError<()>>,
+    tm_rx: mpsc::Receiver<StoreAddr>,
+    tm_store: SharedPool,
+}
+
+unsafe impl Send for UdpTmtcServer {}
+
+struct EventTmSender {
+    store_helper: TmStore,
+    sender: mpsc::Sender<StoreAddr>,
+}
+
+impl EventTmSender {
+    fn new(store_helper: TmStore, sender: mpsc::Sender<StoreAddr>) -> Self {
+        Self {
+            store_helper,
+            sender,
+        }
+    }
+}
+
+impl EcssTmSender for EventTmSender {
+    type Error = mpsc::SendError<StoreAddr>;
+
+    fn send_tm(&mut self, tm: PusTm) -> Result<(), EcssTmError<Self::Error>> {
+        let addr = self.store_helper.add_pus_tm(&tm);
+        self.sender.send(addr).map_err(EcssTmError::SendError)
+    }
+}
+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: 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_funnel_tx, tm_funnel_rx) = channel();
+    let (tm_server_tx, tm_server_rx) = channel();
+    let sender = MpscVerifSender::new(tm_store.clone(), tm_funnel_tx.clone());
+    let verif_cfg = VerificationReporterCfg::new(PUS_APID, 1, 2, 8).unwrap();
+    let reporter_with_sender_0 = Arc::new(Mutex::new(VerificationReporterWithSender::new(
+        verif_cfg,
+        Box::new(sender),
+    )));
+
+    // Create event handling components
+    let (event_request_tx, event_request_rx) = channel::<EventRequestWithToken>();
+    let (event_sender, event_man_rx) = channel();
+    let event_recv = MpscEventReceiver::<EventU32>::new(event_man_rx);
+    let mut event_man = EventManagerWithMpscQueue::new(Box::new(event_recv));
+    let event_reporter = EventReporter::new(PUS_APID, 128).unwrap();
+    let pus_tm_backend = DefaultPusMgmtBackendProvider::<EventU32>::default();
+    let mut pus_event_dispatcher =
+        PusEventDispatcher::new(event_reporter, Box::new(pus_tm_backend));
+    let (pus_event_man_tx, pus_event_man_rx) = channel();
+    let pus_event_man_send_provider = MpscEventU32SendProvider::new(1, pus_event_man_tx);
+    let reporter1 = reporter_with_sender_0.clone();
+    event_man.subscribe_all(pus_event_man_send_provider.id());
+
+    // Create clones here to allow move for thread 0
+    let core_args = CoreTmtcArgs {
+        tm_store: tm_store_helper.clone(),
+        tm_sender: tm_funnel_tx.clone(),
+        event_sender,
+        event_request_tx,
+    };
+
+    println!("Starting TMTC task");
+    let jh0 = thread::spawn(move || {
+        core_tmtc_task(core_args, tm_server_rx, addr, reporter_with_sender_0);
+    });
+
+    println!("Starting TM funnel task");
+    let jh1 = thread::spawn(move || {
+        let tm_funnel = TmFunnel {
+            tm_server_tx,
+            tm_funnel_rx,
+        };
+        loop {
+            if let Ok(addr) = tm_funnel.tm_funnel_rx.recv() {
+                tm_funnel
+                    .tm_server_tx
+                    .send(addr)
+                    .expect("Sending TM to server failed");
+            }
+        }
+    });
+
+    println!("Starting event handling task");
+    let jh2 = thread::spawn(move || {
+        let mut timestamp: [u8; 7] = [0; 7];
+        let mut sender = EventTmSender::new(tm_store_helper, tm_funnel_tx);
+        let mut time_provider = CdsShortTimeProvider::new(0, 0);
+        let report_completion = |event_req: EventRequestWithToken, timestamp: &[u8]| {
+            let mut reporter = reporter1
+                .lock()
+                .expect("Locking Verification reporter failed");
+            reporter
+                .completion_success(event_req.token, timestamp)
+                .expect("Sending completion success failed");
+        };
+        loop {
+            if let Ok(event_req) = event_request_rx.try_recv() {
+                match event_req.request {
+                    EventRequest::Enable(event) => {
+                        pus_event_dispatcher
+                            .enable_tm_for_event(&event)
+                            .expect("Enabling TM failed");
+                        update_time(&mut time_provider, &mut timestamp);
+                        report_completion(event_req, &timestamp);
+                    }
+                    EventRequest::Disable(event) => {
+                        pus_event_dispatcher
+                            .disable_tm_for_event(&event)
+                            .expect("Disabling TM failed");
+                        update_time(&mut time_provider, &mut timestamp);
+                        report_completion(event_req, &timestamp);
+                    }
+                }
+            }
+            if let Ok((event, _param)) = pus_event_man_rx.try_recv() {
+                update_time(&mut time_provider, &mut timestamp);
+                pus_event_dispatcher
+                    .generate_pus_event_tm_generic(&mut sender, &timestamp, event, None)
+                    .expect("Sending TM as event failed");
+            }
+        }
+    });
+
+    jh0.join().expect("Joining UDP TMTC server thread failed");
+    jh1.join().expect("Joining TM Funnel thread failed");
+    jh2.join().expect("Joining Event Manager thread failed");
+}
+
+pub fn update_time(time_provider: &mut CdsShortTimeProvider, timestamp: &mut [u8]) {
+    time_provider
+        .update_from_now()
+        .expect("Could not get current time");
+    time_provider
+        .write_to_bytes(timestamp)
+        .expect("Writing timestamp failed");
+}

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

@@ -0,0 +1,188 @@
+use crate::tmtc::TmStore;
+use fsrc_core::events::EventU32;
+use fsrc_core::pool::StoreAddr;
+use fsrc_core::pus::event::Subservices;
+use fsrc_core::pus::event_man::{EventRequest, EventRequestWithToken};
+use fsrc_core::pus::verification::{
+    FailParams, SharedStdVerifReporterWithSender, TcStateAccepted, VerificationToken,
+};
+use fsrc_core::tmtc::tm_helper::PusTmWithCdsShortHelper;
+use fsrc_core::tmtc::PusServiceProvider;
+use spacepackets::ecss::{EcssEnumU16, PusPacket};
+use spacepackets::tc::PusTc;
+use spacepackets::time::{CdsShortTimeProvider, TimeWriter};
+use spacepackets::SpHeader;
+use std::sync::mpsc;
+
+pub struct PusReceiver {
+    pub tm_helper: PusTmWithCdsShortHelper,
+    pub tm_tx: mpsc::Sender<StoreAddr>,
+    pub tm_store: TmStore,
+    pub verif_reporter: SharedStdVerifReporterWithSender,
+    event_request_tx: mpsc::Sender<EventRequestWithToken>,
+    stamper: CdsShortTimeProvider,
+    time_stamp: [u8; 7],
+}
+
+impl PusReceiver {
+    pub fn new(
+        apid: u16,
+        tm_tx: mpsc::Sender<StoreAddr>,
+        tm_store: TmStore,
+        verif_reporter: SharedStdVerifReporterWithSender,
+        event_request_tx: mpsc::Sender<EventRequestWithToken>,
+    ) -> Self {
+        Self {
+            tm_helper: PusTmWithCdsShortHelper::new(apid),
+            tm_tx,
+            tm_store,
+            verif_reporter,
+            event_request_tx,
+            stamper: CdsShortTimeProvider::default(),
+            time_stamp: [0; 7],
+        }
+    }
+}
+
+impl PusServiceProvider for PusReceiver {
+    type Error = ();
+
+    fn handle_pus_tc_packet(
+        &mut self,
+        service: u8,
+        _header: &SpHeader,
+        pus_tc: &PusTc,
+    ) -> Result<(), Self::Error> {
+        let mut reporter = self
+            .verif_reporter
+            .lock()
+            .expect("Locking Verification Reporter failed");
+        let init_token = reporter.add_tc(pus_tc);
+        self.stamper
+            .update_from_now()
+            .expect("Updating time for time stamp failed");
+        self.stamper
+            .write_to_bytes(&mut self.time_stamp)
+            .expect("Writing time stamp failed");
+        let accepted_token = reporter
+            .acceptance_success(init_token, &self.time_stamp)
+            .expect("Acceptance success failure");
+        drop(reporter);
+        if service == 17 {
+            self.handle_test_service(pus_tc, accepted_token);
+        } else if service == 5 {
+            self.handle_event_service(pus_tc, accepted_token);
+        }
+        Ok(())
+    }
+}
+
+impl PusReceiver {
+    fn handle_test_service(&mut self, pus_tc: &PusTc, token: VerificationToken<TcStateAccepted>) {
+        if pus_tc.subservice() == 1 {
+            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.add_pus_tm(&ping_reply);
+            let mut reporter = self
+                .verif_reporter
+                .lock()
+                .expect("Error locking verification reporter");
+            let start_token = reporter
+                .start_success(token, &self.time_stamp)
+                .expect("Error sending start success");
+            self.tm_tx
+                .send(addr)
+                .expect("Sending TM to TM funnel failed");
+            reporter
+                .completion_success(start_token, &self.time_stamp)
+                .expect("Error sending completion success");
+        }
+    }
+
+    fn update_time_stamp(&mut self) {
+        self.stamper
+            .update_from_now()
+            .expect("Updating timestamp failed");
+        self.stamper
+            .write_to_bytes(&mut self.time_stamp)
+            .expect("Writing timestamp failed");
+    }
+
+    fn handle_event_service(&mut self, pus_tc: &PusTc, token: VerificationToken<TcStateAccepted>) {
+        let send_start_failure = |verif_reporter: &mut SharedStdVerifReporterWithSender,
+                                  timestamp: &[u8; 7],
+                                  failure_code: EcssEnumU16,
+                                  failure_data: Option<&[u8]>| {
+            verif_reporter
+                .lock()
+                .expect("Locking verification reporter failed")
+                .start_failure(
+                    token,
+                    FailParams::new(timestamp, &failure_code, failure_data),
+                )
+                .expect("Sending start failure TM failed");
+        };
+        let send_start_acceptance = |verif_reporter: &mut SharedStdVerifReporterWithSender,
+                                     timestamp: &[u8; 7]| {
+            verif_reporter
+                .lock()
+                .expect("Locking verification reporter failed")
+                .start_success(token, timestamp)
+                .expect("Sending start success TM failed")
+        };
+        if pus_tc.user_data().is_none() {
+            self.update_time_stamp();
+            send_start_failure(
+                &mut self.verif_reporter,
+                &self.time_stamp,
+                EcssEnumU16::new(1),
+                None,
+            );
+            return;
+        }
+        let app_data = pus_tc.user_data().unwrap();
+        if app_data.len() < 4 {
+            self.update_time_stamp();
+            send_start_failure(
+                &mut self.verif_reporter,
+                &self.time_stamp,
+                EcssEnumU16::new(1),
+                None,
+            );
+            return;
+        }
+        let event_id = EventU32::from(u32::from_be_bytes(app_data.try_into().unwrap()));
+        match PusPacket::subservice(pus_tc).try_into() {
+            Ok(Subservices::TcEnableEventGeneration) => {
+                self.update_time_stamp();
+                let start_token = send_start_acceptance(&mut self.verif_reporter, &self.time_stamp);
+                self.event_request_tx
+                    .send(EventRequestWithToken {
+                        request: EventRequest::Enable(event_id),
+                        token: start_token,
+                    })
+                    .expect("Sending event request failed");
+            }
+            Ok(Subservices::TcDisableEventGeneration) => {
+                self.update_time_stamp();
+                let start_token = send_start_acceptance(&mut self.verif_reporter, &self.time_stamp);
+                self.event_request_tx
+                    .send(EventRequestWithToken {
+                        request: EventRequest::Disable(event_id),
+                        token: start_token,
+                    })
+                    .expect("Sending event request failed");
+            }
+            _ => {
+                self.update_time_stamp();
+                send_start_failure(
+                    &mut self.verif_reporter,
+                    &self.time_stamp,
+                    EcssEnumU16::new(2),
+                    None,
+                );
+            }
+        }
+    }
+}

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

@@ -0,0 +1,121 @@
+use fsrc_core::events::EventU32;
+use fsrc_core::hal::host::udp_server::{ReceiveResult, UdpTcServer};
+use fsrc_core::params::Params;
+use std::net::SocketAddr;
+use std::sync::mpsc;
+use std::sync::mpsc::Sender;
+use std::thread;
+use std::time::Duration;
+
+use crate::ccsds::CcsdsReceiver;
+use crate::pus::PusReceiver;
+use crate::UdpTmtcServer;
+use fsrc_core::pool::{SharedPool, StoreAddr};
+use fsrc_core::pus::event_man::EventRequestWithToken;
+use fsrc_core::pus::verification::SharedStdVerifReporterWithSender;
+use fsrc_core::tmtc::{CcsdsDistributor, CcsdsError, PusDistributor};
+use spacepackets::tm::PusTm;
+
+pub const PUS_APID: u16 = 0x02;
+
+pub struct CoreTmtcArgs {
+    pub tm_store: TmStore,
+    pub tm_sender: Sender<StoreAddr>,
+    pub event_sender: Sender<(EventU32, Option<Params>)>,
+    pub event_request_tx: Sender<EventRequestWithToken>,
+}
+
+#[derive(Clone)]
+pub struct TmStore {
+    pub pool: SharedPool,
+}
+
+impl TmStore {
+    pub fn add_pus_tm(&mut self, pus_tm: &PusTm) -> StoreAddr {
+        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_bytes(buf)
+            .expect("Writing PUS TM to store failed");
+        addr
+    }
+}
+
+pub fn core_tmtc_task(
+    args: CoreTmtcArgs,
+    tm_server_rx: mpsc::Receiver<StoreAddr>,
+    addr: SocketAddr,
+    verif_reporter: SharedStdVerifReporterWithSender,
+) {
+    let pus_receiver = PusReceiver::new(
+        PUS_APID,
+        args.tm_sender,
+        args.tm_store.clone(),
+        verif_reporter,
+        args.event_request_tx,
+    );
+    let pus_distributor = PusDistributor::new(Box::new(pus_receiver));
+    let ccsds_receiver = CcsdsReceiver {
+        pus_handler: pus_distributor,
+    };
+    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: args.tm_store.pool.clone(),
+    };
+    loop {
+        core_tmtc_loop(&mut udp_tmtc_server);
+        thread::sleep(Duration::from_millis(400));
+    }
+}
+
+fn core_tmtc_loop(udp_tmtc_server: &mut UdpTmtcServer) {
+    while core_tc_handling(udp_tmtc_server) {}
+    if let Some(recv_addr) = udp_tmtc_server.udp_tc_server.last_sender() {
+        core_tm_handling(udp_tmtc_server, &recv_addr);
+    }
+}
+
+fn core_tc_handling(udp_tmtc_server: &mut UdpTmtcServer) -> bool {
+    match udp_tmtc_server.udp_tc_server.try_recv_tc() {
+        Ok(_) => true,
+        Err(e) => match e {
+            ReceiveResult::ReceiverError(e) => match e {
+                CcsdsError::PacketError(e) => {
+                    println!("Got packet error: {e:?}");
+                    true
+                }
+                CcsdsError::CustomError(_) => {
+                    println!("Unknown receiver error");
+                    true
+                }
+            },
+            ReceiveResult::IoError(e) => {
+                println!("IO error {e}");
+                false
+            }
+            ReceiveResult::NothingReceived => false,
+        },
+    }
+}
+
+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
+            .write()
+            .expect("Locking TM store failed");
+        let pg = store_lock.read_with_guard(addr);
+        let buf = pg.read().expect("Error reading TM pool data");
+        println!("Sending TM");
+        udp_tmtc_server
+            .udp_tc_server
+            .socket
+            .send_to(buf, recv_addr)
+            .expect("Sending TM failed");
+    }
+}

satrs-example/src/bin/test.rs

@@ -0,0 +1,55 @@
+#![allow(dead_code)]
+use crossbeam_channel::{bounded, Receiver, Sender};
+use std::thread;
+use zerocopy::{AsBytes, FromBytes, NetworkEndian, Unaligned, U16};
+
+trait FieldDataProvider: Send {
+    fn get_data(&self) -> &[u8];
+}
+
+struct FixedFieldDataWrapper {
+    data: [u8; 8],
+}
+
+impl FixedFieldDataWrapper {
+    pub fn from_two_u32(p0: u32, p1: u32) -> Self {
+        let mut data = [0; 8];
+        data[0..4].copy_from_slice(p0.to_be_bytes().as_slice());
+        data[4..8].copy_from_slice(p1.to_be_bytes().as_slice());
+        Self { data }
+    }
+}
+
+impl FieldDataProvider for FixedFieldDataWrapper {
+    fn get_data(&self) -> &[u8] {
+        self.data.as_slice()
+    }
+}
+
+type FieldDataTraitObj = Box<dyn FieldDataProvider>;
+
+struct ExampleMgmSet {
+    mgm_vec: [f32; 3],
+    temperature: u16,
+}
+
+#[derive(FromBytes, AsBytes, Unaligned)]
+#[repr(C)]
+struct ExampleMgmSetZc {
+    mgm_vec: [u8; 12],
+    temperatur: U16<NetworkEndian>,
+}
+
+fn main() {
+    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 || {
+        let data = r0.recv().unwrap();
+        let raw = data.get_data();
+        println!("Received data {:?}", raw);
+    });
+    let jh1 = thread::spawn(|| {});
+    jh0.join().unwrap();
+    jh1.join().unwrap();
+}

satrs-example/src/lib.rs

@@ -0,0 +1,4 @@
+use std::net::Ipv4Addr;
+
+pub const OBSW_SERVER_ADDR: Ipv4Addr = Ipv4Addr::new(127, 0, 0, 1);
+pub const SERVER_PORT: u16 = 7301;