added and scheduled MGM assembly

.github/workflows/ci.yml

@@ -11,9 +11,6 @@ jobs:
     steps:
       - uses: actions/checkout@v4
       - uses: dtolnay/rust-toolchain@stable
-      - name: Install libudev-dev on Ubuntu
-        if: ${{ matrix.os == 'ubuntu-latest' }}
-        run: sudo apt update && sudo apt install -y libudev-dev
       - run: cargo check
       # Check example with static pool configuration
       - run: cargo check -p satrs-example --no-default-features
@@ -26,7 +23,6 @@ jobs:
       - uses: dtolnay/rust-toolchain@stable
       - name: Install nextest
         uses: taiki-e/install-action@nextest
-      - run: sudo apt update && sudo apt install -y libudev-dev
       - run: cargo nextest run --all-features
       - run: cargo test --doc --all-features
 
@@ -51,8 +47,6 @@ jobs:
     steps:
       - uses: actions/checkout@v4
       - uses: dtolnay/rust-toolchain@stable
-        with:
-          components: rustfmt
       - run: cargo fmt --all -- --check
 
   docs:
@@ -61,7 +55,7 @@ jobs:
     steps:
       - uses: actions/checkout@v4
       - uses: dtolnay/rust-toolchain@nightly
-      - run: RUSTDOCFLAGS="--cfg docsrs" cargo +nightly doc -p satrs --all-features --no-deps
+      - run: cargo +nightly doc --all-features --config 'build.rustdocflags=["--cfg", "docs_rs"]'
 
   clippy:
     name: Clippy
@@ -69,7 +63,4 @@ jobs:
     steps:
       - uses: actions/checkout@v4
       - uses: dtolnay/rust-toolchain@stable
-        with:
-          components: clippy
-      - run: sudo apt update && sudo apt install -y libudev-dev
       - run: cargo clippy -- -D warnings

Cargo.toml

@@ -4,11 +4,8 @@ members = [
     "satrs",
     "satrs-mib",
     "satrs-example",
-    "satrs-example/models",
-    "satrs-example/client",
-    "satrs-example/minisim",
+    "satrs-minisim",
     "satrs-shared",
-    "embedded-examples/embedded-client",
 ]
 
 exclude = [

README.md

@@ -4,7 +4,6 @@
 [![sat-rs book](https://img.shields.io/badge/sat--rs-book-darkgreen?style=flat)](https://robamu.github.io/sat-rs/book/)
 [![Crates.io](https://img.shields.io/crates/v/satrs)](https://crates.io/crates/satrs)
 [![docs.rs](https://img.shields.io/docsrs/satrs)](https://docs.rs/satrs)
-[![matrix chat](https://img.shields.io/matrix/sat-rs%3Amatrix.org)](https://matrix.to/#/#sat-rs:matrix.org)
 
 sat-rs
 =========
@@ -62,8 +61,6 @@ Each project has its own `CHANGELOG.md`.
    packet protocol implementations. This repository is re-exported in the
    [`satrs`](https://egit.irs.uni-stuttgart.de/rust/satrs/src/branch/main/satrs)
    crate.
- * [`cfdp`](https://egit.irs.uni-stuttgart.de/rust/cfdp): CCSDS File Delivery Protocol
-   (CFDP) high-level library components.
 
 # Flight Heritage
 

embedded-examples/embedded-client/Cargo.toml

@@ -1,18 +0,0 @@
-[package]
-name = "embedded-client"
-version = "0.1.0"
-edition = "2024"
-
-[dependencies]
-clap = { version = "4", features = ["derive"] }
-serialport = "4"
-toml = "0.9"
-serde = { version = "1", features = ["derive"] }
-satrs-stm32f3-disco-rtic = { path = "../stm32f3-disco-rtic" }
-spacepackets = { version = "0.17" }
-tmtc-utils = { git = "https://egit.irs.uni-stuttgart.de/rust/tmtc-utils.git", version = "0.1" }
-postcard = { version = "1", features = ["alloc"] }
-cobs = "0.5"
-fern = "0.7"
-humantime = "2"
-log = "0.4"

embedded-examples/embedded-client/config.toml

@@ -1,2 +0,0 @@
-[interface]
-serial_port = "/dev/ttyUSB0"

embedded-examples/embedded-client/src/main.rs

@@ -1,107 +0,0 @@
-use std::{
-    fs::File,
-    io::Read,
-    path::Path,
-    time::{Duration, SystemTime},
-};
-
-use clap::Parser;
-use cobs::CobsDecoderOwned;
-use satrs_stm32f3_disco_rtic::Request;
-use spacepackets::{CcsdsPacketCreatorOwned, CcsdsPacketReader, SpHeader};
-use tmtc_utils::transport::serial::PacketTransportSerialCobs;
-
-#[derive(Parser, Debug)]
-struct Cli {
-    #[arg(short, long)]
-    ping: bool,
-
-    /// Set frequency in milliseconds.
-    #[arg(short, long)]
-    set_led_frequency: Option<u32>,
-}
-
-#[derive(Debug, serde::Deserialize)]
-struct Config {
-    interface: Interface,
-}
-
-#[derive(Debug, serde::Deserialize)]
-struct Interface {
-    serial_port: String,
-}
-
-fn setup_logger() -> Result<(), fern::InitError> {
-    fern::Dispatch::new()
-        .format(|out, message, record| {
-            out.finish(format_args!(
-                "[{} {} {}] {}",
-                humantime::format_rfc3339_seconds(SystemTime::now()),
-                record.level(),
-                record.target(),
-                message
-            ))
-        })
-        .level(log::LevelFilter::Debug)
-        .chain(std::io::stdout())
-        .chain(fern::log_file("output.log")?)
-        .apply()?;
-    Ok(())
-}
-
-fn main() {
-    setup_logger().expect("failed to initialize logger");
-    println!("sat-rs embedded examples TMTC client");
-
-    let cli = Cli::parse();
-    let mut config_file =
-        File::open(Path::new("config.toml")).expect("opening config.toml file failed");
-    let mut toml_str = String::new();
-    config_file
-        .read_to_string(&mut toml_str)
-        .expect("reading config.toml file failed");
-    let config: Config = toml::from_str(&toml_str).expect("parsing config.toml file failed");
-    println!("Connecting to serial port {}", config.interface.serial_port);
-
-    let serial = serialport::new(config.interface.serial_port, 115200)
-        .open()
-        .expect("opening serial port failed");
-    let mut transport = PacketTransportSerialCobs::new(serial, CobsDecoderOwned::new(1024));
-
-    if cli.ping {
-        let request = Request::Ping;
-        let tc = create_stm32f3_tc(&request);
-        log::info!(
-            "Sending ping request with TC ID: {:#010x}",
-            tc.ccsds_packet_id_and_psc().raw()
-        );
-        transport.send(&tc.to_vec()).unwrap();
-    }
-
-    if let Some(freq_ms) = cli.set_led_frequency {
-        let request = Request::ChangeBlinkFrequency(Duration::from_millis(freq_ms as u64));
-        let tc = create_stm32f3_tc(&request);
-        log::info!(
-            "Sending change blink frequency request {:?} with TC ID: {:#010x}",
-            request,
-            tc.ccsds_packet_id_and_psc().raw()
-        );
-        transport.send(&tc.to_vec()).unwrap();
-    }
-
-    log::info!("Waiting for response...");
-    loop {
-        transport
-            .receive(|packet: &[u8]| {
-                let reader = CcsdsPacketReader::new_with_checksum(packet);
-                log::info!("Received packet: {:?}", reader);
-            })
-            .unwrap();
-    }
-}
-
-fn create_stm32f3_tc(request: &Request) -> CcsdsPacketCreatorOwned {
-    let req_raw = postcard::to_allocvec(&request).unwrap();
-    let sp_header = SpHeader::new_from_apid(satrs_stm32f3_disco_rtic::APID);
-    CcsdsPacketCreatorOwned::new_tc_with_checksum(sp_header, &req_raw).unwrap()
-}

embedded-examples/stm32f3-disco-rtic/.cargo/def_config.toml

@@ -34,4 +34,4 @@ rustflags = [
 target = "thumbv7em-none-eabihf" # Cortex-M4F and Cortex-M7F (with FPU)
 
 [env]
-DEFMT_LOG = "info"
+DEFMT_LOG = "info"

embedded-examples/stm32f3-disco-rtic/.gitignore

@@ -1,4 +1,4 @@
 /target
 /itm.txt
-/.cargo/config.toml
+/.cargo/config*
 /.vscode

embedded-examples/stm32f3-disco-rtic/Cargo.toml

@@ -9,28 +9,49 @@ default-run = "satrs-stm32f3-disco-rtic"
 [dependencies]
 cortex-m = { version = "0.7", features = ["critical-section-single-core"] }
 cortex-m-rt = "0.7"
-defmt = "1"
-defmt-rtt = { version = "1" }
-panic-probe = { version = "1", features = ["print-defmt"] }
-embedded-hal = "1"
+defmt = "0.3"
+defmt-brtt = { version = "0.1", default-features = false, features = ["rtt"] }
+panic-probe = { version = "0.3", features = ["print-defmt"] }
+embedded-hal = "0.2.7"
 cortex-m-semihosting = "0.5.0"
-embassy-stm32 = { version = "0.4", features = ["defmt", "stm32f303vc", "unstable-pac"] }
 enumset = "1"
-heapless = "0.9"
-spacepackets = { version = "0.17", default-features = false, features = ["defmt", "serde"] }
-static_cell = "2"
-cobs = { version = "0.5", default-features = false, features = ["defmt"] }
-postcard = { version = "1" }
-arbitrary-int = "2"
-thiserror = { version = "2", default-features = false }
-serde = { version = "1", default-features = false, features = ["derive"] }
+heapless = "0.8"
 
-rtic = { version = "2", features = ["thumbv7-backend"] }
-rtic-sync = { version = "1" }
-rtic-monotonics = { version = "2", features = ["cortex-m-systick"] }
+[dependencies.rtic]
+version = "2"
+features = ["thumbv7-backend"]
+
+[dependencies.rtic-monotonics]
+version = "2"
+features = ["cortex-m-systick"]
+
+[dependencies.cobs]
+version = "0.3"
+default-features = false
+
+[dependencies.stm32f3xx-hal]
+git = "https://github.com/robamu/stm32f3xx-hal"
+version = "0.11.0-alpha.0"
+features = ["stm32f303xc", "rt", "enumset"]
+branch = "complete-dma-update"
+# Can be used in workspace to develop and update HAL
+# path = "../stm32f3xx-hal"
+
+[dependencies.stm32f3-discovery]
+git = "https://github.com/robamu/stm32f3-discovery"
+version = "0.8.0-alpha.0"
+branch = "complete-dma-update-hal"
+# Can be used in workspace to develop and update BSP
+# path = "../stm32f3-discovery"
+
+[dependencies.satrs]
+# path = "satrs"
+version = "0.2"
+default-features = false
+features = ["defmt"]
 
 [dev-dependencies]
-defmt-test = "0.4"
+defmt-test = "0.3"
 
 # cargo test
 [profile.test]

embedded-examples/stm32f3-disco-rtic/legacy/jlink.gdb

@@ -0,0 +1,10 @@
+target extended-remote localhost:2331
+
+monitor reset
+
+# *try* to stop at the user entry point (it might be gone due to inlining)
+break main
+
+load
+
+continue

embedded-examples/stm32f3-disco-rtic/legacy/openocd.cfg

@@ -0,0 +1,12 @@
+# Sample OpenOCD configuration for the STM32F3DISCOVERY development board
+
+# Depending on the hardware revision you got you'll have to pick ONE of these
+# interfaces. At any time only one interface should be commented out.
+
+# Revision C (newer revision)
+source [find interface/stlink.cfg]
+
+# Revision A and B (older revisions)
+# source [find interface/stlink-v2.cfg]
+
+source [find target/stm32f3x.cfg]

embedded-examples/stm32f3-disco-rtic/legacy/openocd.gdb

@@ -0,0 +1,42 @@
+target extended-remote :3333
+
+# print demangled symbols
+set print asm-demangle on
+
+# set backtrace limit to not have infinite backtrace loops
+set backtrace limit 32
+
+# detect unhandled exceptions, hard faults and panics
+break DefaultHandler
+break HardFault
+break rust_begin_unwind
+# # run the next few lines so the panic message is printed immediately
+# # the number needs to be adjusted for your panic handler
+# commands $bpnum
+# next 4
+# end
+
+# *try* to stop at the user entry point (it might be gone due to inlining)
+break main
+
+# monitor arm semihosting enable
+
+# # send captured ITM to the file itm.fifo
+# # (the microcontroller SWO pin must be connected to the programmer SWO pin)
+# # 8000000 must match the core clock frequency
+# # 2000000 is the frequency of the SWO pin. This was added for newer
+# openocd versions like v0.12.0.
+# monitor tpiu config internal itm.txt uart off 8000000 2000000
+
+# # OR: make the microcontroller SWO pin output compatible with UART (8N1)
+# # 8000000 must match the core clock frequency
+# # 2000000 is the frequency of the SWO pin
+# monitor tpiu config external uart off 8000000 2000000
+
+# # enable ITM port 0
+# monitor itm port 0 on
+
+load
+
+# start the process but immediately halt the processor
+stepi

embedded-examples/stm32f3-disco-rtic/pyclient/.gitignore

@@ -0,0 +1,8 @@
+/venv
+/.tmtc-history.txt
+/log
+/.idea/*
+!/.idea/runConfigurations
+
+/seqcnt.txt
+/tmtc_conf.json

embedded-examples/stm32f3-disco-rtic/pyclient/def_tmtc_conf.json

@@ -0,0 +1,4 @@
+{
+    "com_if": "serial_cobs",
+    "serial_baudrate": 115200
+}

embedded-examples/stm32f3-disco-rtic/pyclient/main.py

@@ -0,0 +1,305 @@
+#!/usr/bin/env python3
+"""Example client for the sat-rs example application"""
+import struct
+import logging
+import sys
+import time
+from typing import Any, Optional, cast
+from prompt_toolkit.history import FileHistory, History
+from spacepackets.ecss.tm import CdsShortTimestamp
+
+import tmtccmd
+from spacepackets.ecss import PusTelemetry, PusTelecommand, PusTm, PusVerificator
+from spacepackets.ecss.pus_17_test import Service17Tm
+from spacepackets.ecss.pus_1_verification import UnpackParams, Service1Tm
+
+from tmtccmd import TcHandlerBase, ProcedureParamsWrapper
+from tmtccmd.core.base import BackendRequest
+from tmtccmd.core.ccsds_backend import QueueWrapper
+from tmtccmd.logging import add_colorlog_console_logger
+from tmtccmd.pus import VerificationWrapper
+from tmtccmd.tmtc import CcsdsTmHandler, SpecificApidHandlerBase
+from tmtccmd.com import ComInterface
+from tmtccmd.config import (
+    CmdTreeNode,
+    default_json_path,
+    SetupParams,
+    HookBase,
+    params_to_procedure_conversion,
+)
+from tmtccmd.config.com import SerialCfgWrapper
+from tmtccmd.config import PreArgsParsingWrapper, SetupWrapper
+from tmtccmd.logging.pus import (
+    RegularTmtcLogWrapper,
+    RawTmtcTimedLogWrapper,
+    TimedLogWhen,
+)
+from tmtccmd.tmtc import (
+    TcQueueEntryType,
+    ProcedureWrapper,
+    TcProcedureType,
+    FeedWrapper,
+    SendCbParams,
+    DefaultPusQueueHelper,
+)
+from tmtccmd.pus.s5_fsfw_event import Service5Tm
+from spacepackets.seqcount import FileSeqCountProvider, PusFileSeqCountProvider
+from tmtccmd.util.obj_id import ObjectIdDictT
+
+_LOGGER = logging.getLogger()
+
+EXAMPLE_PUS_APID = 0x02
+
+
+class SatRsConfigHook(HookBase):
+    def __init__(self, json_cfg_path: str):
+        super().__init__(json_cfg_path)
+
+    def get_communication_interface(self, com_if_key: str) -> Optional[ComInterface]:
+        from tmtccmd.config.com import (
+            create_com_interface_default,
+            create_com_interface_cfg_default,
+        )
+
+        assert self.cfg_path is not None
+        cfg = create_com_interface_cfg_default(
+            com_if_key=com_if_key,
+            json_cfg_path=self.cfg_path,
+            space_packet_ids=None,
+        )
+        if cfg is None:
+            raise ValueError(
+                f"No valid configuration could be retrieved for the COM IF with key {com_if_key}"
+            )
+        if cfg.com_if_key == "serial_cobs":
+            cfg = cast(SerialCfgWrapper, cfg)
+            cfg.serial_cfg.serial_timeout = 0.5
+        return create_com_interface_default(cfg)
+
+    def get_command_definitions(self) -> CmdTreeNode:
+        """This function should return the root node of the command definition tree."""
+        return create_cmd_definition_tree()
+
+    def get_cmd_history(self) -> Optional[History]:
+        """Optionlly return a history class for the past command paths which will be used
+        when prompting a command path from the user in CLI mode."""
+        return FileHistory(".tmtc-history.txt")
+
+    def get_object_ids(self) -> ObjectIdDictT:
+        from tmtccmd.config.objects import get_core_object_ids
+
+        return get_core_object_ids()
+
+
+def create_cmd_definition_tree() -> CmdTreeNode:
+    root_node = CmdTreeNode.root_node()
+    root_node.add_child(CmdTreeNode("ping", "Send PUS ping TC"))
+    root_node.add_child(CmdTreeNode("change_blink_freq", "Change blink frequency"))
+    return root_node
+
+
+class PusHandler(SpecificApidHandlerBase):
+    def __init__(
+        self,
+        file_logger: logging.Logger,
+        verif_wrapper: VerificationWrapper,
+        raw_logger: RawTmtcTimedLogWrapper,
+    ):
+        super().__init__(EXAMPLE_PUS_APID, None)
+        self.file_logger = file_logger
+        self.raw_logger = raw_logger
+        self.verif_wrapper = verif_wrapper
+
+    def handle_tm(self, packet: bytes, _user_args: Any):
+        try:
+            pus_tm = PusTm.unpack(
+                packet, timestamp_len=CdsShortTimestamp.TIMESTAMP_SIZE
+            )
+        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 = pus_tm.service
+        tm_packet = None
+        if service == 1:
+            tm_packet = Service1Tm.unpack(
+                data=packet, params=UnpackParams(CdsShortTimestamp.TIMESTAMP_SIZE, 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)
+        if service == 3:
+            _LOGGER.info("No handling for HK packets implemented")
+            _LOGGER.info(f"Raw packet: 0x[{packet.hex(sep=',')}]")
+            pus_tm = PusTelemetry.unpack(packet, CdsShortTimestamp.TIMESTAMP_SIZE)
+            if pus_tm.subservice == 25:
+                if len(pus_tm.source_data) < 8:
+                    raise ValueError("No addressable ID in HK packet")
+                json_str = pus_tm.source_data[8:]
+                _LOGGER.info("received JSON string: " + json_str.decode("utf-8"))
+        if service == 5:
+            tm_packet = Service5Tm.unpack(packet, CdsShortTimestamp.TIMESTAMP_SIZE)
+        if service == 17:
+            tm_packet = Service17Tm.unpack(packet, CdsShortTimestamp.TIMESTAMP_SIZE)
+            if tm_packet.subservice == 2:
+                _LOGGER.info("Received Ping Reply TM[17,2]")
+            else:
+                _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, CdsShortTimestamp.TIMESTAMP_SIZE)
+        self.raw_logger.log_tm(pus_tm)
+
+
+def make_addressable_id(target_id: int, unique_id: int) -> bytes:
+    byte_string = bytearray(struct.pack("!I", target_id))
+    byte_string.extend(struct.pack("!I", unique_id))
+    return byte_string
+
+
+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=QueueWrapper.empty(),
+            tc_sched_timestamp_len=7,
+            seq_cnt_provider=seq_count_provider,
+            pus_verificator=verif_wrapper.pus_verificator,
+            default_pus_apid=EXAMPLE_PUS_APID,
+        )
+
+    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, info: ProcedureWrapper):
+        if info.proc_type == TcProcedureType.TREE_COMMANDING:
+            def_proc = info.to_tree_commanding_procedure()
+            _LOGGER.info(f"Queue handling finished for command {def_proc.cmd_path}")
+
+    def feed_cb(self, info: ProcedureWrapper, wrapper: FeedWrapper):
+        q = self.queue_helper
+        q.queue_wrapper = wrapper.queue_wrapper
+        if info.proc_type == TcProcedureType.TREE_COMMANDING:
+            def_proc = info.to_tree_commanding_procedure()
+            cmd_path = def_proc.cmd_path
+            if cmd_path == "/ping":
+                q.add_log_cmd("Sending PUS ping telecommand")
+                q.add_pus_tc(PusTelecommand(service=17, subservice=1))
+            if cmd_path == "/change_blink_freq":
+                self.create_change_blink_freq_command(q)
+
+    def create_change_blink_freq_command(self, q: DefaultPusQueueHelper):
+        q.add_log_cmd("Changing blink frequency")
+        while True:
+            blink_freq = int(
+                input(
+                    "Please specify new blink frequency in ms. Valid Range [2..10000]: "
+                )
+            )
+            if blink_freq < 2 or blink_freq > 10000:
+                print(
+                    "Invalid blink frequency. Please specify a value between 2 and 10000."
+                )
+                continue
+            break
+        app_data = struct.pack("!I", blink_freq)
+        q.add_pus_tc(PusTelecommand(service=8, subservice=1, app_data=app_data))
+
+
+def main():
+    add_colorlog_console_logger(_LOGGER)
+    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()
+    params = SetupParams()
+    post_args_wrapper = parser_wrapper.parse(hook_obj, params)
+    proc_wrapper = ProcedureParamsWrapper()
+    if post_args_wrapper.use_gui:
+        post_args_wrapper.set_params_without_prompts(proc_wrapper)
+    else:
+        post_args_wrapper.set_params_with_prompts(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()
+    file_logger = tmtc_logger.logger
+    raw_logger = RawTmtcTimedLogWrapper(when=TimedLogWhen.PER_HOUR, interval=1)
+    verificator = PusVerificator()
+    verification_wrapper = VerificationWrapper(verificator, _LOGGER, file_logger)
+    # Create primary TM handler and add it to the CCSDS Packet Handler
+    tm_handler = PusHandler(file_logger, verification_wrapper, 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()

embedded-examples/stm32f3-disco-rtic/pyclient/requirements.txt

@@ -0,0 +1,2 @@
+tmtccmd == 8.0.1
+# -e git+https://github.com/robamu-org/tmtccmd.git@main#egg=tmtccmd

embedded-examples/stm32f3-disco-rtic/src/bin/blinky.rs

@@ -1,61 +1,76 @@
-#![no_main]
 #![no_std]
+#![no_main]
+use satrs_stm32f3_disco_rtic as _;
 
-use panic_probe as _;
-use rtic::app;
+use stm32f3_discovery::leds::Leds;
+use stm32f3_discovery::stm32f3xx_hal::delay::Delay;
+use stm32f3_discovery::stm32f3xx_hal::{pac, prelude::*};
+use stm32f3_discovery::switch_hal::{OutputSwitch, ToggleableOutputSwitch};
 
-#[app(device = embassy_stm32)]
-mod app {
-    use rtic_monotonics::fugit::ExtU32;
-    use rtic_monotonics::Monotonic as _;
-    use satrs_stm32f3_disco_rtic::{Direction, LedPinSet, Leds};
+#[cortex_m_rt::entry]
+fn main() -> ! {
+    defmt::println!("STM32F3 Discovery Blinky");
+    let dp = pac::Peripherals::take().unwrap();
+    let mut rcc = dp.RCC.constrain();
+    let cp = cortex_m::Peripherals::take().unwrap();
+    let mut flash = dp.FLASH.constrain();
+    let clocks = rcc.cfgr.freeze(&mut flash.acr);
+    let mut delay = Delay::new(cp.SYST, clocks);
 
-    rtic_monotonics::systick_monotonic!(Mono, 1000);
+    let mut gpioe = dp.GPIOE.split(&mut rcc.ahb);
+    let mut leds = Leds::new(
+        gpioe.pe8,
+        gpioe.pe9,
+        gpioe.pe10,
+        gpioe.pe11,
+        gpioe.pe12,
+        gpioe.pe13,
+        gpioe.pe14,
+        gpioe.pe15,
+        &mut gpioe.moder,
+        &mut gpioe.otyper,
+    );
+    let delay_ms = 200u16;
+    loop {
+        leds.ld3_n.toggle().ok();
+        delay.delay_ms(delay_ms);
+        leds.ld3_n.toggle().ok();
+        delay.delay_ms(delay_ms);
 
-    #[shared]
-    struct Shared {}
+        //explicit on/off
+        leds.ld4_nw.on().ok();
+        delay.delay_ms(delay_ms);
+        leds.ld4_nw.off().ok();
+        delay.delay_ms(delay_ms);
 
-    #[local]
-    struct Local {
-        leds: Leds,
-        current_dir: Direction,
-    }
+        leds.ld5_ne.on().ok();
+        delay.delay_ms(delay_ms);
+        leds.ld5_ne.off().ok();
+        delay.delay_ms(delay_ms);
 
-    #[init]
-    fn init(cx: init::Context) -> (Shared, Local) {
-        let p = embassy_stm32::init(Default::default());
+        leds.ld6_w.on().ok();
+        delay.delay_ms(delay_ms);
+        leds.ld6_w.off().ok();
+        delay.delay_ms(delay_ms);
 
-        defmt::info!("Starting sat-rs demo application for the STM32F3-Discovery using RTICv2");
+        leds.ld7_e.on().ok();
+        delay.delay_ms(delay_ms);
+        leds.ld7_e.off().ok();
+        delay.delay_ms(delay_ms);
 
-        let led_pin_set = LedPinSet {
-            pin_n: p.PE8,
-            pin_ne: p.PE9,
-            pin_e: p.PE10,
-            pin_se: p.PE11,
-            pin_s: p.PE12,
-            pin_sw: p.PE13,
-            pin_w: p.PE14,
-            pin_nw: p.PE15,
-        };
-        let leds = Leds::new(led_pin_set);
+        leds.ld8_sw.on().ok();
+        delay.delay_ms(delay_ms);
+        leds.ld8_sw.off().ok();
+        delay.delay_ms(delay_ms);
 
-        // Initialize the systick interrupt & obtain the token to prove that we did
-        Mono::start(cx.core.SYST, 8_000_000);
-        blinky::spawn().expect("failed to spawn blinky task");
-        (
-            Shared {},
-            Local {
-                leds,
-                current_dir: Direction::North,
-            },
-        )
-    }
+        leds.ld9_se.on().ok();
+        delay.delay_ms(delay_ms);
+        leds.ld9_se.off().ok();
+        delay.delay_ms(delay_ms);
 
-    #[task(local = [leds, current_dir])]
-    async fn blinky(cx: blinky::Context) {
-        loop {
-            cx.local.leds.blink_next(cx.local.current_dir);
-            Mono::delay(200.millis()).await;
-        }
+        leds.ld10_s.on().ok();
+        delay.delay_ms(delay_ms);
+        leds.ld10_s.off().ok();
+        delay.delay_ms(delay_ms);
     }
 }

embedded-examples/stm32f3-disco-rtic/src/lib.rs

@@ -1,190 +1,51 @@
 #![no_main]
 #![no_std]
 
-use arbitrary_int::u11;
-use core::time::Duration;
-use embassy_stm32::gpio::Output;
-use spacepackets::{
-    ccsds_packet_len_for_user_data_len_with_checksum, CcsdsPacketCreationError,
-    CcsdsPacketCreatorWithReservedData, CcsdsPacketIdAndPsc, SpacePacketHeader,
-};
+use cortex_m_semihosting::debug;
 
-pub const APID: u11 = u11::new(0x02);
+use defmt_brtt as _; // global logger
 
-#[derive(defmt::Format, serde::Serialize, serde::Deserialize, PartialEq, Eq, Clone, Copy)]
-pub enum Direction {
-    North,
-    NorthEast,
-    East,
-    SouthEast,
-    South,
-    SouthWest,
-    West,
-    NorthWest,
+use stm32f3xx_hal as _; // memory layout
+
+use panic_probe as _;
+
+// same panicking *behavior* as `panic-probe` but doesn't print a panic message
+// this prevents the panic message being printed *twice* when `defmt::panic` is invoked
+#[defmt::panic_handler]
+fn panic() -> ! {
+    cortex_m::asm::udf()
 }
 
-impl Direction {
-    pub fn switch_to_next(&mut self) -> (Self, Self) {
-        let curr = *self;
-        *self = match self {
-            Direction::North => Direction::NorthEast,
-            Direction::NorthEast => Direction::East,
-            Direction::East => Direction::SouthEast,
-            Direction::SouthEast => Direction::South,
-            Direction::South => Direction::SouthWest,
-            Direction::SouthWest => Direction::West,
-            Direction::West => Direction::NorthWest,
-            Direction::NorthWest => Direction::North,
-        };
-        (curr, *self)
+/// Terminates the application and makes a semihosting-capable debug tool exit
+/// with status code 0.
+pub fn exit() -> ! {
+    loop {
+        debug::exit(debug::EXIT_SUCCESS);
     }
 }
 
-#[derive(Copy, Clone, Debug, defmt::Format, serde::Serialize, serde::Deserialize)]
-pub enum Request {
-    Ping,
-    ChangeBlinkFrequency(Duration),
-}
-
-#[derive(Debug, defmt::Format, serde::Serialize, serde::Deserialize)]
-pub struct TmHeader {
-    pub tc_packet_id: Option<CcsdsPacketIdAndPsc>,
-    pub uptime_millis: u32,
-}
-
-#[derive(Debug, defmt::Format, serde::Serialize, serde::Deserialize)]
-pub enum Response {
-    CommandDone,
-}
-
-pub fn tm_size(tm_header: &TmHeader, response: &Response) -> usize {
-    ccsds_packet_len_for_user_data_len_with_checksum(
-        postcard::experimental::serialized_size(tm_header).unwrap()
-            + postcard::experimental::serialized_size(response).unwrap(),
-    )
-    .unwrap()
-}
-
-pub fn create_tm_packet(
-    buf: &mut [u8],
-    sp_header: SpacePacketHeader,
-    tm_header: TmHeader,
-    response: Response,
-) -> Result<usize, CcsdsPacketCreationError> {
-    let packet_data_size = postcard::experimental::serialized_size(&tm_header).unwrap()
-        + postcard::experimental::serialized_size(&response).unwrap();
-    let mut creator =
-        CcsdsPacketCreatorWithReservedData::new_tm_with_checksum(sp_header, packet_data_size, buf)?;
-
-    let current_index = postcard::to_slice(&tm_header, creator.packet_data_mut())
-        .unwrap()
-        .len();
-    postcard::to_slice(&response, &mut creator.packet_data_mut()[current_index..]).unwrap();
-    Ok(creator.finish())
-}
-
-pub struct Leds {
-    pub north: Output<'static>,
-    pub north_east: Output<'static>,
-    pub east: Output<'static>,
-    pub south_east: Output<'static>,
-    pub south: Output<'static>,
-    pub south_west: Output<'static>,
-    pub west: Output<'static>,
-    pub north_west: Output<'static>,
-}
-
-impl Leds {
-    pub fn blink_next(&mut self, current_dir: &mut Direction) {
-        let (prev, curr) = current_dir.switch_to_next();
-        self.set_dir_low(prev);
-        self.set_dir_high(curr);
-    }
-
-    pub fn set_dir(&mut self, dir: Direction, level: embassy_stm32::gpio::Level) {
-        match dir {
-            Direction::North => self.north.set_level(level),
-            Direction::NorthEast => self.north_east.set_level(level),
-            Direction::East => self.east.set_level(level),
-            Direction::SouthEast => self.south_east.set_level(level),
-            Direction::South => self.south.set_level(level),
-            Direction::SouthWest => self.south_west.set_level(level),
-            Direction::West => self.west.set_level(level),
-            Direction::NorthWest => self.north_west.set_level(level),
-        }
-    }
-
-    pub fn set_dir_low(&mut self, dir: Direction) {
-        self.set_dir(dir, embassy_stm32::gpio::Level::Low);
-    }
-
-    pub fn set_dir_high(&mut self, dir: Direction) {
-        self.set_dir(dir, embassy_stm32::gpio::Level::High);
+/// Hardfault handler.
+///
+/// Terminates the application and makes a semihosting-capable debug tool exit
+/// with an error. This seems better than the default, which is to spin in a
+/// loop.
+#[cortex_m_rt::exception]
+unsafe fn HardFault(_frame: &cortex_m_rt::ExceptionFrame) -> ! {
+    loop {
+        debug::exit(debug::EXIT_FAILURE);
     }
 }
 
-pub struct LedPinSet {
-    pub pin_n: embassy_stm32::Peri<'static, embassy_stm32::peripherals::PE8>,
-    pub pin_ne: embassy_stm32::Peri<'static, embassy_stm32::peripherals::PE9>,
-    pub pin_e: embassy_stm32::Peri<'static, embassy_stm32::peripherals::PE10>,
-    pub pin_se: embassy_stm32::Peri<'static, embassy_stm32::peripherals::PE11>,
-    pub pin_s: embassy_stm32::Peri<'static, embassy_stm32::peripherals::PE12>,
-    pub pin_sw: embassy_stm32::Peri<'static, embassy_stm32::peripherals::PE13>,
-    pub pin_w: embassy_stm32::Peri<'static, embassy_stm32::peripherals::PE14>,
-    pub pin_nw: embassy_stm32::Peri<'static, embassy_stm32::peripherals::PE15>,
-}
+// defmt-test 0.3.0 has the limitation that this `#[tests]` attribute can only be used
+// once within a crate. the module can be in any file but there can only be at most
+// one `#[tests]` module in this library crate
+#[cfg(test)]
+#[defmt_test::tests]
+mod unit_tests {
+    use defmt::assert;
 
-impl Leds {
-    pub fn new(pin_set: LedPinSet) -> Self {
-        let led_n = Output::new(
-            pin_set.pin_n,
-            embassy_stm32::gpio::Level::Low,
-            embassy_stm32::gpio::Speed::Medium,
-        );
-        let led_ne = Output::new(
-            pin_set.pin_ne,
-            embassy_stm32::gpio::Level::Low,
-            embassy_stm32::gpio::Speed::Medium,
-        );
-        let led_e = Output::new(
-            pin_set.pin_e,
-            embassy_stm32::gpio::Level::Low,
-            embassy_stm32::gpio::Speed::Medium,
-        );
-        let led_se = Output::new(
-            pin_set.pin_se,
-            embassy_stm32::gpio::Level::Low,
-            embassy_stm32::gpio::Speed::Medium,
-        );
-        let led_s = Output::new(
-            pin_set.pin_s,
-            embassy_stm32::gpio::Level::Low,
-            embassy_stm32::gpio::Speed::Medium,
-        );
-        let led_sw = Output::new(
-            pin_set.pin_sw,
-            embassy_stm32::gpio::Level::Low,
-            embassy_stm32::gpio::Speed::Medium,
-        );
-        let led_w = Output::new(
-            pin_set.pin_w,
-            embassy_stm32::gpio::Level::Low,
-            embassy_stm32::gpio::Speed::Medium,
-        );
-        let led_nw = Output::new(
-            pin_set.pin_nw,
-            embassy_stm32::gpio::Level::Low,
-            embassy_stm32::gpio::Speed::Medium,
-        );
-        Self {
-            north: led_n,
-            north_east: led_ne,
-            east: led_e,
-            south_east: led_se,
-            south: led_s,
-            south_west: led_sw,
-            west: led_w,
-            north_west: led_nw,
-        }
+    #[test]
+    fn it_works() {
+        assert!(true)
     }
 }

embedded-examples/stm32f3-disco-rtic/src/main.rs

@@ -1,349 +1,682 @@
 #![no_std]
 #![no_main]
-use arbitrary_int::{u11, u14};
-use cortex_m_semihosting::debug::{self, EXIT_FAILURE, EXIT_SUCCESS};
-use satrs_stm32f3_disco_rtic::{create_tm_packet, tm_size, CcsdsPacketId, Request, Response};
-use spacepackets::{CcsdsPacketCreationError, SpHeader};
-
-use defmt_rtt as _; // global logger
-
-use panic_probe as _;
+use satrs::pus::verification::{
+    FailParams, TcStateAccepted, VerificationReportCreator, VerificationToken,
+};
+use satrs::spacepackets::ecss::tc::PusTcReader;
+use satrs::spacepackets::ecss::tm::{PusTmCreator, PusTmSecondaryHeader};
+use satrs::spacepackets::ecss::EcssEnumU16;
+use satrs::spacepackets::CcsdsPacket;
+use satrs::spacepackets::{ByteConversionError, SpHeader};
+// global logger + panicking-behavior + memory layout
+use satrs_stm32f3_disco_rtic as _;
 
 use rtic::app;
 
+use heapless::{mpmc::Q8, Vec};
 #[allow(unused_imports)]
 use rtic_monotonics::fugit::{MillisDurationU32, TimerInstantU32};
 use rtic_monotonics::systick::prelude::*;
-
-use crate::app::Mono;
+use satrs::seq_count::SequenceCountProviderCore;
+use satrs::spacepackets::{ecss::PusPacket, ecss::WritablePusPacket};
+use stm32f3xx_hal::dma::dma1;
+use stm32f3xx_hal::gpio::{PushPull, AF7, PA2, PA3};
+use stm32f3xx_hal::pac::USART2;
+use stm32f3xx_hal::serial::{Rx, RxEvent, Serial, SerialDmaRx, SerialDmaTx, Tx, TxEvent};
 
 const UART_BAUD: u32 = 115200;
 const DEFAULT_BLINK_FREQ_MS: u32 = 1000;
 const TX_HANDLER_FREQ_MS: u32 = 20;
+const MIN_DELAY_BETWEEN_TX_PACKETS_MS: u32 = 5;
 const MAX_TC_LEN: usize = 128;
 const MAX_TM_LEN: usize = 128;
+pub const PUS_APID: u16 = 0x02;
 
-pub const PUS_APID: u11 = u11::new(0x02);
+type TxType = Tx<USART2, PA2<AF7<PushPull>>>;
+type RxType = Rx<USART2, PA3<AF7<PushPull>>>;
+type InstantFugit = TimerInstantU32<1000>;
+type TxDmaTransferType = SerialDmaTx<&'static [u8], dma1::C7, TxType>;
+type RxDmaTransferType = SerialDmaRx<&'static mut [u8], dma1::C6, RxType>;
 
 // This is the predictable maximum overhead of the COBS encoding scheme.
 // It is simply the maximum packet lenght dividied by 254 rounded up.
-const COBS_TM_OVERHEAD: usize = cobs::max_encoding_overhead(MAX_TM_LEN);
+const COBS_TC_OVERHEAD: usize = (MAX_TC_LEN + 254 - 1) / 254;
+const COBS_TM_OVERHEAD: usize = (MAX_TM_LEN + 254 - 1) / 254;
 
+const TC_BUF_LEN: usize = MAX_TC_LEN + COBS_TC_OVERHEAD;
 const TM_BUF_LEN: usize = MAX_TC_LEN + COBS_TM_OVERHEAD;
 
-const TC_DMA_BUF_LEN: usize = 512;
+// This is a static buffer which should ONLY (!) be used as the TX DMA
+// transfer buffer.
+static mut DMA_TX_BUF: [u8; TM_BUF_LEN] = [0; TM_BUF_LEN];
+// This is a static buffer which should ONLY (!) be used as the RX DMA
+// transfer buffer.
+static mut DMA_RX_BUF: [u8; TC_BUF_LEN] = [0; TC_BUF_LEN];
 
-type TmPacket = heapless::Vec<u8, MAX_TM_LEN>;
+type TmPacket = Vec<u8, MAX_TM_LEN>;
+type TcPacket = Vec<u8, MAX_TC_LEN>;
 
-static TM_QUEUE: heapless::mpmc::Queue<TmPacket, 16> = heapless::mpmc::Queue::new();
+static TM_REQUESTS: Q8<TmPacket> = Q8::new();
 
-#[derive(Debug, defmt::Format, thiserror::Error)]
-pub enum TmSendError {
-    #[error("packet creation error: {0}")]
-    PacketCreation(#[from] CcsdsPacketCreationError),
-    #[error("queue error")]
-    Queue,
+use core::sync::atomic::{AtomicU16, Ordering};
+
+pub struct SeqCountProviderAtomicRef {
+    atomic: AtomicU16,
+    ordering: Ordering,
+}
+
+impl SeqCountProviderAtomicRef {
+    pub const fn new(ordering: Ordering) -> Self {
+        Self {
+            atomic: AtomicU16::new(0),
+            ordering,
+        }
+    }
+}
+
+impl SequenceCountProviderCore<u16> for SeqCountProviderAtomicRef {
+    fn get(&self) -> u16 {
+        self.atomic.load(self.ordering)
+    }
+
+    fn increment(&self) {
+        self.atomic.fetch_add(1, self.ordering);
+    }
+
+    fn get_and_increment(&self) -> u16 {
+        self.atomic.fetch_add(1, self.ordering)
+    }
+}
+
+static SEQ_COUNT_PROVIDER: SeqCountProviderAtomicRef =
+    SeqCountProviderAtomicRef::new(Ordering::Relaxed);
+
+pub struct TxIdle {
+    tx: TxType,
+    dma_channel: dma1::C7,
 }
 
 #[derive(Debug, defmt::Format)]
-pub struct RequestWithTcId {
-    pub request: Request,
-    pub tc_id: CcsdsPacketId,
+pub enum TmSendError {
+    ByteConversion(ByteConversionError),
+    Queue,
 }
 
-#[app(device = embassy_stm32)]
-mod app {
-    use core::time::Duration;
+impl From<ByteConversionError> for TmSendError {
+    fn from(value: ByteConversionError) -> Self {
+        Self::ByteConversion(value)
+    }
+}
 
+fn send_tm(tm_creator: PusTmCreator) -> Result<(), TmSendError> {
+    if tm_creator.len_written() > MAX_TM_LEN {
+        return Err(ByteConversionError::ToSliceTooSmall {
+            expected: tm_creator.len_written(),
+            found: MAX_TM_LEN,
+        }
+        .into());
+    }
+    let mut tm_vec = TmPacket::new();
+    tm_vec
+        .resize(tm_creator.len_written(), 0)
+        .expect("vec resize failed");
+    tm_creator.write_to_bytes(tm_vec.as_mut_slice())?;
+    defmt::info!(
+        "Sending TM[{},{}] with size {}",
+        tm_creator.service(),
+        tm_creator.subservice(),
+        tm_creator.len_written()
+    );
+    TM_REQUESTS
+        .enqueue(tm_vec)
+        .map_err(|_| TmSendError::Queue)?;
+    Ok(())
+}
+
+fn handle_tm_send_error(error: TmSendError) {
+    defmt::warn!("sending tm failed with error {}", error);
+}
+
+pub enum UartTxState {
+    // Wrapped in an option because we need an owned type later.
+    Idle(Option<TxIdle>),
+    // Same as above
+    Transmitting(Option<TxDmaTransferType>),
+}
+
+pub struct UartTxShared {
+    last_completed: Option<InstantFugit>,
+    state: UartTxState,
+}
+
+pub struct RequestWithToken {
+    token: VerificationToken<TcStateAccepted>,
+    request: Request,
+}
+
+#[derive(Debug, defmt::Format)]
+pub enum Request {
+    Ping,
+    ChangeBlinkFrequency(u32),
+}
+
+#[derive(Debug, defmt::Format)]
+pub enum RequestError {
+    InvalidApid = 1,
+    InvalidService = 2,
+    InvalidSubservice = 3,
+    NotEnoughAppData = 4,
+}
+
+pub fn convert_pus_tc_to_request(
+    tc: &PusTcReader,
+    verif_reporter: &mut VerificationReportCreator,
+    src_data_buf: &mut [u8],
+    timestamp: &[u8],
+) -> Result<RequestWithToken, RequestError> {
+    defmt::info!(
+        "Found PUS TC [{},{}] with length {}",
+        tc.service(),
+        tc.subservice(),
+        tc.len_packed()
+    );
+
+    let token = verif_reporter.add_tc(tc);
+    if tc.apid() != PUS_APID {
+        defmt::warn!("Received tc with unknown APID {}", tc.apid());
+        let result = send_tm(
+            verif_reporter
+                .acceptance_failure(
+                    src_data_buf,
+                    token,
+                    SEQ_COUNT_PROVIDER.get_and_increment(),
+                    0,
+                    FailParams::new(timestamp, &EcssEnumU16::new(0), &[]),
+                )
+                .unwrap(),
+        );
+        if let Err(e) = result {
+            handle_tm_send_error(e);
+        }
+        return Err(RequestError::InvalidApid);
+    }
+    let (tm_creator, accepted_token) = verif_reporter
+        .acceptance_success(
+            src_data_buf,
+            token,
+            SEQ_COUNT_PROVIDER.get_and_increment(),
+            0,
+            timestamp,
+        )
+        .unwrap();
+
+    if let Err(e) = send_tm(tm_creator) {
+        handle_tm_send_error(e);
+    }
+
+    if tc.service() == 17 && tc.subservice() == 1 {
+        if tc.subservice() == 1 {
+            return Ok(RequestWithToken {
+                request: Request::Ping,
+                token: accepted_token,
+            });
+        } else {
+            return Err(RequestError::InvalidSubservice);
+        }
+    } else if tc.service() == 8 {
+        if tc.subservice() == 1 {
+            if tc.user_data().len() < 4 {
+                return Err(RequestError::NotEnoughAppData);
+            }
+            let new_freq_ms = u32::from_be_bytes(tc.user_data()[0..4].try_into().unwrap());
+            return Ok(RequestWithToken {
+                request: Request::ChangeBlinkFrequency(new_freq_ms),
+                token: accepted_token,
+            });
+        } else {
+            return Err(RequestError::InvalidSubservice);
+        }
+    } else {
+        return Err(RequestError::InvalidService);
+    }
+}
+
+#[app(device = stm32f3xx_hal::pac, peripherals = true)]
+mod app {
     use super::*;
-    use arbitrary_int::u14;
-    use rtic::Mutex;
-    use rtic_sync::{
-        channel::{Receiver, Sender},
-        make_channel,
-    };
-    use satrs_stm32f3_disco_rtic::{CcsdsPacketId, LedPinSet, Request, Response};
-    use spacepackets::CcsdsPacketReader;
+    use core::slice::Iter;
+    use satrs::pus::verification::{TcStateStarted, VerificationReportCreator};
+    use satrs::spacepackets::{ecss::tc::PusTcReader, time::cds::P_FIELD_BASE};
+    #[allow(unused_imports)]
+    use stm32f3_discovery::leds::Direction;
+    use stm32f3_discovery::leds::Leds;
+    use stm32f3xx_hal::prelude::*;
+
+    use stm32f3_discovery::switch_hal::OutputSwitch;
+    use stm32f3xx_hal::Switch;
+    #[allow(dead_code)]
+    type SerialType = Serial<USART2, (PA2<AF7<PushPull>>, PA3<AF7<PushPull>>)>;
 
     systick_monotonic!(Mono, 1000);
 
-    embassy_stm32::bind_interrupts!(struct Irqs {
-        USART2 => embassy_stm32::usart::InterruptHandler<embassy_stm32::peripherals::USART2>;
-    });
-
     #[shared]
     struct Shared {
-        blink_freq: Duration,
+        blink_freq: MillisDurationU32,
+        tx_shared: UartTxShared,
+        rx_transfer: Option<RxDmaTransferType>,
     }
 
     #[local]
     struct Local {
-        leds: satrs_stm32f3_disco_rtic::Leds,
-        current_dir: satrs_stm32f3_disco_rtic::Direction,
-        seq_count: u14,
-        tx: embassy_stm32::usart::UartTx<'static, embassy_stm32::mode::Async>,
-        rx: embassy_stm32::usart::RingBufferedUartRx<'static>,
+        verif_reporter: VerificationReportCreator,
+        leds: Leds,
+        last_dir: Direction,
+        curr_dir: Iter<'static, Direction>,
     }
 
     #[init]
     fn init(cx: init::Context) -> (Shared, Local) {
-        static DMA_BUF: static_cell::ConstStaticCell<[u8; TC_DMA_BUF_LEN]> =
-            static_cell::ConstStaticCell::new([0; TC_DMA_BUF_LEN]);
+        let mut rcc = cx.device.RCC.constrain();
 
-        let p = embassy_stm32::init(Default::default());
-
-        let (req_sender, req_receiver) = make_channel!(RequestWithTcId, 16);
         // Initialize the systick interrupt & obtain the token to prove that we did
         Mono::start(cx.core.SYST, 8_000_000);
 
-        defmt::info!("sat-rs demo application for the STM32F3-Discovery with RTICv2");
-        let led_pin_set = LedPinSet {
-            pin_n: p.PE8,
-            pin_ne: p.PE9,
-            pin_e: p.PE10,
-            pin_se: p.PE11,
-            pin_s: p.PE12,
-            pin_sw: p.PE13,
-            pin_w: p.PE14,
-            pin_nw: p.PE15,
-        };
-        let leds = satrs_stm32f3_disco_rtic::Leds::new(led_pin_set);
+        let mut flash = cx.device.FLASH.constrain();
+        let clocks = rcc
+            .cfgr
+            .use_hse(8.MHz())
+            .sysclk(8.MHz())
+            .pclk1(8.MHz())
+            .freeze(&mut flash.acr);
 
-        let mut config = embassy_stm32::usart::Config::default();
-        config.baudrate = UART_BAUD;
-        let uart = embassy_stm32::usart::Uart::new(
-            p.USART2, p.PA3, p.PA2, Irqs, p.DMA1_CH7, p.DMA1_CH6, config,
-        )
-        .unwrap();
+        // Set up monotonic timer.
+        //let mono_timer = MonoTimer::new(cx.core.DWT, clocks, &mut cx.core.DCB);
 
-        let (tx, rx) = uart.split();
+        defmt::info!("Starting sat-rs demo application for the STM32F3-Discovery");
+        let mut gpioe = cx.device.GPIOE.split(&mut rcc.ahb);
+
+        let leds = Leds::new(
+            gpioe.pe8,
+            gpioe.pe9,
+            gpioe.pe10,
+            gpioe.pe11,
+            gpioe.pe12,
+            gpioe.pe13,
+            gpioe.pe14,
+            gpioe.pe15,
+            &mut gpioe.moder,
+            &mut gpioe.otyper,
+        );
+        let mut gpioa = cx.device.GPIOA.split(&mut rcc.ahb);
+        // USART2 pins
+        let mut pins = (
+            // TX pin: PA2
+            gpioa
+                .pa2
+                .into_af_push_pull(&mut gpioa.moder, &mut gpioa.otyper, &mut gpioa.afrl),
+            // RX pin: PA3
+            gpioa
+                .pa3
+                .into_af_push_pull(&mut gpioa.moder, &mut gpioa.otyper, &mut gpioa.afrl),
+        );
+        pins.1.internal_pull_up(&mut gpioa.pupdr, true);
+        let mut usart2 = Serial::new(
+            cx.device.USART2,
+            pins,
+            UART_BAUD.Bd(),
+            clocks,
+            &mut rcc.apb1,
+        );
+        usart2.configure_rx_interrupt(RxEvent::Idle, Switch::On);
+        // This interrupt is enabled to re-schedule new transfers in the interrupt handler immediately.
+        usart2.configure_tx_interrupt(TxEvent::TransmissionComplete, Switch::On);
+
+        let dma1 = cx.device.DMA1.split(&mut rcc.ahb);
+        let (mut tx_serial, mut rx_serial) = usart2.split();
+
+        // This interrupt is immediately triggered, clear it. It will only be reset
+        // by the hardware when data is received on RX (RXNE event)
+        rx_serial.clear_event(RxEvent::Idle);
+        // For some reason, this is also immediately triggered..
+        tx_serial.clear_event(TxEvent::TransmissionComplete);
+        let rx_transfer = rx_serial.read_exact(unsafe { DMA_RX_BUF.as_mut_slice() }, dma1.ch6);
         defmt::info!("Spawning tasks");
-        blinky::spawn().unwrap();
+        blink::spawn().unwrap();
         serial_tx_handler::spawn().unwrap();
-        serial_rx_handler::spawn(req_sender).unwrap();
-        req_handler::spawn(req_receiver).unwrap();
+
+        let verif_reporter = VerificationReportCreator::new(PUS_APID).unwrap();
 
         (
             Shared {
-                blink_freq: Duration::from_millis(DEFAULT_BLINK_FREQ_MS as u64),
+                blink_freq: MillisDurationU32::from_ticks(DEFAULT_BLINK_FREQ_MS),
+                tx_shared: UartTxShared {
+                    last_completed: None,
+                    state: UartTxState::Idle(Some(TxIdle {
+                        tx: tx_serial,
+                        dma_channel: dma1.ch7,
+                    })),
+                },
+                rx_transfer: Some(rx_transfer),
             },
             Local {
+                verif_reporter,
                 leds,
-                tx,
-                seq_count: u14::new(0),
-                rx: rx.into_ring_buffered(DMA_BUF.take()),
-                current_dir: satrs_stm32f3_disco_rtic::Direction::North,
+                last_dir: Direction::North,
+                curr_dir: Direction::iter(),
             },
         )
     }
 
-    #[task(local = [leds, current_dir], shared=[blink_freq])]
-    async fn blinky(mut cx: blinky::Context) {
+    #[task(local = [leds, curr_dir, last_dir], shared=[blink_freq])]
+    async fn blink(mut cx: blink::Context) {
+        let blink::LocalResources {
+            leds,
+            curr_dir,
+            last_dir,
+            ..
+        } = cx.local;
+        let mut toggle_leds = |dir: &Direction| {
+            let last_led = leds.for_direction(*last_dir);
+            last_led.off().ok();
+            let led = leds.for_direction(*dir);
+            led.on().ok();
+            *last_dir = *dir;
+        };
         loop {
-            cx.local.leds.blink_next(cx.local.current_dir);
+            match curr_dir.next() {
+                Some(dir) => {
+                    toggle_leds(dir);
+                }
+                None => {
+                    *curr_dir = Direction::iter();
+                    toggle_leds(curr_dir.next().unwrap());
+                }
+            }
             let current_blink_freq = cx.shared.blink_freq.lock(|current| *current);
-            Mono::delay(MillisDurationU32::from_ticks(
-                current_blink_freq.as_millis() as u32,
-            ))
-            .await;
+            Mono::delay(current_blink_freq).await;
         }
     }
 
     #[task(
-        local = [
-            tx,
-            encoded_buf: [u8; TM_BUF_LEN] = [0; TM_BUF_LEN]
-        ],
-        shared = [],
+        shared = [tx_shared],
     )]
-    async fn serial_tx_handler(cx: serial_tx_handler::Context) {
+    async fn serial_tx_handler(mut cx: serial_tx_handler::Context) {
         loop {
-            while let Some(vec) = TM_QUEUE.dequeue() {
-                let encoded_len =
-                    cobs::encode_including_sentinels(&vec[0..vec.len()], cx.local.encoded_buf);
-                defmt::debug!("sending {} bytes over UART", encoded_len);
-                cx.local
-                    .tx
-                    .write(&cx.local.encoded_buf[0..encoded_len])
-                    .await
-                    .unwrap();
+            let is_idle = cx.shared.tx_shared.lock(|tx_shared| {
+                if let UartTxState::Idle(_) = tx_shared.state {
+                    return true;
+                }
+                false
+            });
+            if is_idle {
+                let last_completed = cx.shared.tx_shared.lock(|shared| shared.last_completed);
+                if let Some(last_completed) = last_completed {
+                    let elapsed_ms = (Mono::now() - last_completed).to_millis();
+                    if elapsed_ms < MIN_DELAY_BETWEEN_TX_PACKETS_MS {
+                        Mono::delay((MIN_DELAY_BETWEEN_TX_PACKETS_MS - elapsed_ms).millis()).await;
+                    }
+                }
+            } else {
+                // Check for completion after 1 ms
+                Mono::delay(1.millis()).await;
                 continue;
             }
+            if let Some(vec) = TM_REQUESTS.dequeue() {
+                cx.shared
+                    .tx_shared
+                    .lock(|tx_shared| match &mut tx_shared.state {
+                        UartTxState::Idle(tx) => {
+                            let encoded_len;
+                            //debug!(target: "serial_tx_handler", "bytes: {:x?}", &buf[0..len]);
+                            // Safety: We only copy the data into the TX DMA buffer in this task.
+                            // If the DMA is active, another branch will be taken.
+                            unsafe {
+                                // 0 sentinel value as start marker
+                                DMA_TX_BUF[0] = 0;
+                                encoded_len =
+                                    cobs::encode(&vec[0..vec.len()], &mut DMA_TX_BUF[1..]);
+                                // Should never panic, we accounted for the overhead.
+                                // Write into transfer buffer directly, no need for intermediate
+                                // encoding buffer.
+                                // 0 end marker
+                                DMA_TX_BUF[encoded_len + 1] = 0;
+                            }
+                            //debug!(target: "serial_tx_handler", "Sending {} bytes", encoded_len + 2);
+                            //debug!("sent: {:x?}", &mut_tx_dma_buf[0..encoded_len + 2]);
+                            let tx_idle = tx.take().unwrap();
+                            // Transfer completion and re-scheduling of new TX transfers will be done
+                            // by the IRQ handler.
+                            // SAFETY: The DMA is the exclusive writer to the DMA buffer now.
+                            let transfer = tx_idle.tx.write_all(
+                                unsafe { &DMA_TX_BUF[0..encoded_len + 2] },
+                                tx_idle.dma_channel,
+                            );
+                            tx_shared.state = UartTxState::Transmitting(Some(transfer));
+                            // The memory block is automatically returned to the pool when it is dropped.
+                        }
+                        UartTxState::Transmitting(_) => (),
+                    });
+                // Check for completion after 1 ms
+                Mono::delay(1.millis()).await;
+                continue;
+            }
+            // Nothing to do, and we are idle.
             Mono::delay(TX_HANDLER_FREQ_MS.millis()).await;
         }
     }
 
     #[task(
         local = [
-            rx,
-            read_buf: [u8; 128] = [0; 128],
+            verif_reporter,
             decode_buf: [u8; MAX_TC_LEN] = [0; MAX_TC_LEN],
+            src_data_buf: [u8; MAX_TM_LEN] = [0; MAX_TM_LEN],
+            timestamp: [u8; 7] = [0; 7],
         ],
         shared = [blink_freq]
     )]
     async fn serial_rx_handler(
-        cx: serial_rx_handler::Context,
-        mut sender: Sender<'static, RequestWithTcId, 16>,
+        mut cx: serial_rx_handler::Context,
+        received_packet: Vec<u8, MAX_TC_LEN>,
     ) {
-        let mut decoder = cobs::CobsDecoder::new(cx.local.decode_buf);
-        loop {
-            match cx.local.rx.read(cx.local.read_buf).await {
-                Ok(bytes) => {
-                    defmt::debug!("received {} bytes over UART", bytes);
-                    for byte in cx.local.read_buf[0..bytes].iter() {
-                        match decoder.feed(*byte) {
-                            Ok(None) => (),
-                            Ok(Some(packet_size)) => {
-                                match CcsdsPacketReader::new_with_checksum(
-                                    &decoder.dest()[0..packet_size],
-                                ) {
-                                    Ok(packet) => {
-                                        let packet_id = packet.packet_id();
-                                        let psc = packet.psc();
-                                        let tc_packet_id = CcsdsPacketId { packet_id, psc };
-                                        if let Ok(request) =
-                                            postcard::from_bytes::<Request>(packet.packet_data())
-                                        {
-                                            sender
-                                                .send(RequestWithTcId {
-                                                    request,
-                                                    tc_id: tc_packet_id,
-                                                })
-                                                .await
-                                                .unwrap();
-                                        }
+        cx.local.timestamp[0] = P_FIELD_BASE;
+        defmt::info!("Received packet with {} bytes", received_packet.len());
+        let decode_buf = cx.local.decode_buf;
+        let packet = received_packet.as_slice();
+        let mut start_idx = None;
+        for (idx, byte) in packet.iter().enumerate() {
+            if *byte != 0 {
+                start_idx = Some(idx);
+                break;
+            }
+        }
+        if start_idx.is_none() {
+            defmt::warn!("decoding error, can only process cobs encoded frames, data is all 0");
+            return;
+        }
+        let start_idx = start_idx.unwrap();
+        match cobs::decode(&received_packet.as_slice()[start_idx..], decode_buf) {
+            Ok(len) => {
+                defmt::info!("Decoded packet length: {}", len);
+                let pus_tc = PusTcReader::new(decode_buf);
+                match pus_tc {
+                    Ok((tc, _tc_len)) => {
+                        match convert_pus_tc_to_request(
+                            &tc,
+                            cx.local.verif_reporter,
+                            cx.local.src_data_buf,
+                            cx.local.timestamp,
+                        ) {
+                            Ok(request_with_token) => {
+                                let started_token = handle_start_verification(
+                                    request_with_token.token,
+                                    cx.local.verif_reporter,
+                                    cx.local.src_data_buf,
+                                    cx.local.timestamp,
+                                );
+
+                                match request_with_token.request {
+                                    Request::Ping => {
+                                        handle_ping_request(cx.local.timestamp);
                                     }
-                                    Err(e) => {
-                                        defmt::error!("error unpacking ccsds packet: {}", e);
+                                    Request::ChangeBlinkFrequency(new_freq_ms) => {
+                                        defmt::info!("Received blink frequency change request with new frequncy {}", new_freq_ms);
+                                        cx.shared.blink_freq.lock(|blink_freq| {
+                                            *blink_freq =
+                                                MillisDurationU32::from_ticks(new_freq_ms);
+                                        });
                                     }
                                 }
+                                handle_completion_verification(
+                                    started_token,
+                                    cx.local.verif_reporter,
+                                    cx.local.src_data_buf,
+                                    cx.local.timestamp,
+                                );
                             }
                             Err(e) => {
-                                defmt::error!("cobs decoding error: {}", e);
+                                // TODO: Error handling: Send verification failure based on request error.
+                                defmt::warn!("request error {}", e);
                             }
                         }
                     }
-                }
-                Err(e) => {
-                    defmt::error!("uart read error: {}", e);
-                }
-            }
-        }
-    }
-
-    #[task(shared = [blink_freq], local = [seq_count])]
-    async fn req_handler(
-        mut cx: req_handler::Context,
-        mut receiver: Receiver<'static, RequestWithTcId, 16>,
-    ) {
-        loop {
-            match receiver.recv().await {
-                Ok(request_with_tc_id) => {
-                    let tm_send_result = match request_with_tc_id.request {
-                        Request::Ping => handle_ping_request(&mut cx, request_with_tc_id.tc_id),
-                        Request::ChangeBlinkFrequency(duration) => {
-                            handle_change_blink_frequency_request(
-                                &mut cx,
-                                request_with_tc_id.tc_id,
-                                duration,
-                            )
-                        }
-                    };
-                    if let Err(e) = tm_send_result {
-                        defmt::error!("error sending TM response: {}", e);
+                    Err(e) => {
+                        defmt::warn!("Error unpacking PUS TC: {}", e);
                     }
                 }
-                Err(_e) => defmt::error!("request receive error"),
+            }
+            Err(_) => {
+                defmt::warn!("decoding error, can only process cobs encoded frames")
             }
         }
     }
 
-    fn handle_ping_request(
-        cx: &mut req_handler::Context,
-        tc_packet_id: CcsdsPacketId,
-    ) -> Result<(), TmSendError> {
-        defmt::info!("Received PUS ping telecommand, sending ping reply");
-        send_tm(tc_packet_id, Response::CommandDone, *cx.local.seq_count)?;
-        *cx.local.seq_count = cx.local.seq_count.wrapping_add(u14::new(1));
-        Ok(())
+    fn handle_ping_request(timestamp: &[u8]) {
+        defmt::info!("Received PUS ping telecommand, sending ping reply TM[17,2]");
+        let sp_header =
+            SpHeader::new_for_unseg_tc(PUS_APID, SEQ_COUNT_PROVIDER.get_and_increment(), 0);
+        let sec_header = PusTmSecondaryHeader::new_simple(17, 2, timestamp);
+        let ping_reply = PusTmCreator::new(sp_header, sec_header, &[], true);
+        let mut tm_packet = TmPacket::new();
+        tm_packet
+            .resize(ping_reply.len_written(), 0)
+            .expect("vec resize failed");
+        ping_reply.write_to_bytes(&mut tm_packet).unwrap();
+        if TM_REQUESTS.enqueue(tm_packet).is_err() {
+            defmt::warn!("TC queue full");
+            return;
+        }
     }
 
-    fn handle_change_blink_frequency_request(
-        cx: &mut req_handler::Context,
-        tc_packet_id: CcsdsPacketId,
-        duration: Duration,
-    ) -> Result<(), TmSendError> {
-        defmt::info!(
-            "Received ChangeBlinkFrequency request, new frequency: {} ms",
-            duration.as_millis()
+    fn handle_start_verification(
+        accepted_token: VerificationToken<TcStateAccepted>,
+        verif_reporter: &mut VerificationReportCreator,
+        src_data_buf: &mut [u8],
+        timestamp: &[u8],
+    ) -> VerificationToken<TcStateStarted> {
+        let (tm_creator, started_token) = verif_reporter
+            .start_success(
+                src_data_buf,
+                accepted_token,
+                SEQ_COUNT_PROVIDER.get(),
+                0,
+                &timestamp,
+            )
+            .unwrap();
+        let result = send_tm(tm_creator);
+        if let Err(e) = result {
+            handle_tm_send_error(e);
+        }
+        started_token
+    }
+
+    fn handle_completion_verification(
+        started_token: VerificationToken<TcStateStarted>,
+        verif_reporter: &mut VerificationReportCreator,
+        src_data_buf: &mut [u8],
+        timestamp: &[u8],
+    ) {
+        let result = send_tm(
+            verif_reporter
+                .completion_success(
+                    src_data_buf,
+                    started_token,
+                    SEQ_COUNT_PROVIDER.get(),
+                    0,
+                    timestamp,
+                )
+                .unwrap(),
         );
+        if let Err(e) = result {
+            handle_tm_send_error(e);
+        }
+    }
+
+    #[task(binds = DMA1_CH6, shared = [rx_transfer])]
+    fn rx_dma_isr(mut cx: rx_dma_isr::Context) {
+        let mut tc_packet = TcPacket::new();
+        cx.shared.rx_transfer.lock(|rx_transfer| {
+            let rx_ref = rx_transfer.as_ref().unwrap();
+            if rx_ref.is_complete() {
+                let uart_rx_owned = rx_transfer.take().unwrap();
+                let (buf, c, rx) = uart_rx_owned.stop();
+                // The received data is transferred to another task now to avoid any processing overhead
+                // during the interrupt. There are multiple ways to do this, we use a stack allocaed vector here
+                // to do this.
+                tc_packet.resize(buf.len(), 0).expect("vec resize failed");
+                tc_packet.copy_from_slice(buf);
+
+                // Start the next transfer as soon as possible.
+                *rx_transfer = Some(rx.read_exact(buf, c));
+
+                // Send the vector to a regular task.
+                serial_rx_handler::spawn(tc_packet).expect("spawning rx handler task failed");
+                // If this happens, there is a high chance that the maximum packet length was
+                // exceeded. Circular mode is not used here, so data might be missed.
+                defmt::warn!(
+                    "rx transfer with maximum length {}, might miss data",
+                    TC_BUF_LEN
+                );
+            }
+        });
+    }
+
+    #[task(binds = USART2_EXTI26, shared = [rx_transfer, tx_shared])]
+    fn serial_isr(mut cx: serial_isr::Context) {
         cx.shared
-            .blink_freq
-            .lock(|blink_freq| *blink_freq = duration);
-        send_tm(tc_packet_id, Response::CommandDone, *cx.local.seq_count)?;
-        *cx.local.seq_count = cx.local.seq_count.wrapping_add(u14::new(1));
-        Ok(())
-    }
-}
-
-fn send_tm(
-    tc_packet_id: CcsdsPacketId,
-    response: Response,
-    current_seq_count: u14,
-) -> Result<(), TmSendError> {
-    let sp_header = SpHeader::new_for_unseg_tc(PUS_APID, current_seq_count, 0);
-    let tm_header = satrs_stm32f3_disco_rtic::TmHeader {
-        tc_packet_id: Some(tc_packet_id),
-        uptime_millis: Mono::now().duration_since_epoch().to_millis(),
-    };
-    let mut tm_packet = TmPacket::new();
-    let tm_size = tm_size(&tm_header, &response);
-    tm_packet.resize(tm_size, 0).expect("vec resize failed");
-    create_tm_packet(&mut tm_packet, sp_header, tm_header, response)?;
-    if TM_QUEUE.enqueue(tm_packet).is_err() {
-        defmt::warn!("TC queue full");
-        return Err(TmSendError::Queue);
-    }
-    Ok(())
-}
-
-// same panicking *behavior* as `panic-probe` but doesn't print a panic message
-// this prevents the panic message being printed *twice* when `defmt::panic` is invoked
-#[defmt::panic_handler]
-fn panic() -> ! {
-    cortex_m::asm::udf()
-}
-
-/// Terminates the application and makes a semihosting-capable debug tool exit
-/// with status code 0.
-pub fn exit() -> ! {
-    loop {
-        debug::exit(EXIT_SUCCESS);
-    }
-}
-
-/// Hardfault handler.
-///
-/// Terminates the application and makes a semihosting-capable debug tool exit
-/// with an error. This seems better than the default, which is to spin in a
-/// loop.
-#[cortex_m_rt::exception]
-unsafe fn HardFault(_frame: &cortex_m_rt::ExceptionFrame) -> ! {
-    loop {
-        debug::exit(EXIT_FAILURE);
-    }
-}
-
-// defmt-test 0.3.0 has the limitation that this `#[tests]` attribute can only be used
-// once within a crate. the module can be in any file but there can only be at most
-// one `#[tests]` module in this library crate
-#[cfg(test)]
-#[defmt_test::tests]
-mod unit_tests {
-    use defmt::assert;
-
-    #[test]
-    fn it_works() {
-        assert!(true)
+            .tx_shared
+            .lock(|tx_shared| match &mut tx_shared.state {
+                UartTxState::Idle(_) => (),
+                UartTxState::Transmitting(transfer) => {
+                    let transfer_ref = transfer.as_ref().unwrap();
+                    if transfer_ref.is_complete() {
+                        let transfer = transfer.take().unwrap();
+                        let (_, dma_channel, mut tx) = transfer.stop();
+                        tx.clear_event(TxEvent::TransmissionComplete);
+                        tx_shared.state = UartTxState::Idle(Some(TxIdle { tx, dma_channel }));
+                        // We cache the last completed time to ensure that there is a minimum delay between consecutive
+                        // transferred packets.
+                        tx_shared.last_completed = Some(Mono::now());
+                    }
+                }
+            });
+        let mut tc_packet = TcPacket::new();
+        cx.shared.rx_transfer.lock(|rx_transfer| {
+            let rx_transfer_ref = rx_transfer.as_ref().unwrap();
+            // Received a partial packet.
+            if rx_transfer_ref.is_event_triggered(RxEvent::Idle) {
+                let rx_transfer_owned = rx_transfer.take().unwrap();
+                let (buf, ch, mut rx, rx_len) = rx_transfer_owned.stop_and_return_received_bytes();
+                // The received data is transferred to another task now to avoid any processing overhead
+                // during the interrupt. There are multiple ways to do this, we use a stack
+                // allocated vector to do this.
+                tc_packet
+                    .resize(rx_len as usize, 0)
+                    .expect("vec resize failed");
+                tc_packet[0..rx_len as usize].copy_from_slice(&buf[0..rx_len as usize]);
+                rx.clear_event(RxEvent::Idle);
+                serial_rx_handler::spawn(tc_packet).expect("spawning rx handler failed");
+                *rx_transfer = Some(rx.read_exact(buf, ch));
+            }
+        });
     }
 }

embedded-examples/stm32h7-nucleo-rtic/Cargo.toml

@@ -16,17 +16,16 @@ harness = false
 [dependencies]
 cortex-m = { version = "0.7", features = ["critical-section-single-core"] }
 cortex-m-rt = "0.7"
-defmt = "1"
+defmt = "0.3"
 defmt-brtt = { version = "0.1", default-features = false, features = ["rtt"] }
-panic-probe = { version = "1", features = ["print-defmt"] }
+panic-probe = { version = "0.3", features = ["print-defmt"] }
 cortex-m-semihosting = "0.5.0"
-# TODO: Replace with embassy-hal.
 stm32h7xx-hal = { version="0.16", features= ["stm32h743v", "ethernet"] }
 embedded-alloc = "0.6"
 rtic-sync = { version = "1", features = ["defmt-03"] }
 
 [dependencies.smoltcp]
-version = "0.12"
+version = "0.11"
 default-features = false
 features = ["medium-ethernet", "proto-ipv4", "socket-raw", "socket-dhcpv4", "socket-udp", "defmt"]
 
@@ -40,11 +39,12 @@ features = ["cortex-m-systick"]
 
 [dependencies.satrs]
 path = "../../satrs"
+version = "0.2"
 default-features = false
 features = ["defmt", "heapless"]
 
 [dev-dependencies]
-defmt-test = "0.4"
+defmt-test = "0.3"
 
 # cargo build/run
 [profile.dev]

justfile

@@ -1,29 +0,0 @@
-all: check build embedded test check-fmt clippy docs
-
-check:
-  cargo check
-  cargo check -p satrs-example --no-default-features
-
-build:
-  cargo build
-
-test:
-  cargo nextest run --all-features
-  cargo test --doc --all-features
-
-embedded:
-  cargo check -p satrs --target=thumbv7em-none-eabihf --no-default-features
-
-check-fmt:
-  cargo fmt --all -- --check
-
-fmt:
-  cargo fmt --all
-
-clippy:
-  cargo clippy -- -D warnings
-
-docs-satrs:
-  RUSTDOCFLAGS="--cfg docsrs --generate-link-to-definition -Z unstable-options" cargo +nightly doc -p satrs --all-features
-
-docs: docs-satrs

satrs-example/Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "satrs-example"
 version = "0.1.1"
-edition = "2024"
+edition = "2021"
 authors = ["Robin Mueller <muellerr@irs.uni-stuttgart.de>"]
 default-run = "satrs-example"
 homepage = "https://egit.irs.uni-stuttgart.de/rust/sat-rs"
@@ -18,24 +18,26 @@ csv = "1"
 num_enum = "0.7"
 thiserror = "2"
 lazy_static = "1"
-strum = { version = "0.28", features = ["derive"] }
+strum = { version = "0.26", features = ["derive"] }
 derive-new = "0.7"
 cfg-if = "1"
-arbitrary-int = "2"
-bitbybit = "2"
-postcard = "1"
-ctrlc = "3"
 serde = { version = "1", features = ["derive"] }
 serde_json = "1"
 
-satrs = { path = "../satrs", features = ["test_util"] }
-models = { path = "./models" }
-satrs-minisim = { path = "./minisim" }
-satrs-mib = { path = "../satrs-mib" }
+[dependencies.satrs]
+path = "../satrs"
+features = ["test_util"]
+
+[dependencies.satrs-minisim]
+path = "../satrs-minisim"
+
+[dependencies.satrs-mib]
+version = "0.1.1"
+path = "../satrs-mib"
 
 [features]
-# default = ["heap_tmtc"]
-# heap_tmtc = []
+heap_tmtc = []
+default = ["heap_tmtc"]
 
 [dev-dependencies]
 env_logger = "0.11"

satrs-example/client/Cargo.toml

@@ -1,19 +0,0 @@
-[package]
-name = "client"
-version = "0.1.0"
-edition = "2024"
-
-[dependencies]
-clap = { version = "4", features = ["derive"] }
-log = "0.4"
-fern = "0.7"
-humantime = "2"
-serde = { version = "1" }
-satrs-example = { path = ".." }
-models = { path = "../models" }
-spacepackets = { version = "0.17", git = "https://egit.irs.uni-stuttgart.de/rust/spacepackets.git", default-features = false }
-bitbybit = "2"
-arbitrary-int = "2"
-ctrlc = { version = "3.5" }
-postcard = { version = "1" }
-anyhow = "1"

satrs-example/client/src/main.rs

@@ -1,334 +0,0 @@
-use anyhow::bail;
-use arbitrary_int::u11;
-use clap::Parser as _;
-use models::{Apid, MessageType, TcHeader, mgm::request::HkRequest};
-use satrs_example::config::{OBSW_SERVER_ADDR, SERVER_PORT};
-use spacepackets::{CcsdsPacketIdAndPsc, SpacePacketHeader};
-use std::{
-    net::{IpAddr, SocketAddr, UdpSocket},
-    sync::{
-        Arc,
-        atomic::{AtomicBool, Ordering},
-    },
-    time::{Duration, SystemTime},
-};
-
-#[derive(clap::Parser)]
-pub struct Cli {
-    #[arg(short, long)]
-    ping: bool,
-    #[arg(short, long)]
-    test_event: bool,
-
-    #[command(subcommand)]
-    commands: Option<Commands>,
-}
-
-#[derive(clap::Subcommand)]
-enum Commands {
-    Mgm0(MgmArgs),
-    Mgm1(MgmArgs),
-    MgmAssy(MgmAssemblyArgs),
-}
-
-impl Commands {
-    #[inline]
-    pub fn target_id(&self) -> models::ComponentId {
-        match self {
-            Commands::Mgm0(_mgm_args) => models::ComponentId::AcsMgm0,
-            Commands::Mgm1(_mgm_args) => models::ComponentId::AcsMgm1,
-            Commands::MgmAssy(_mgm_assembly_args) => models::ComponentId::AcsMgmAssembly,
-        }
-    }
-}
-
-#[derive(Debug, PartialEq, Eq, Clone, Copy, clap::Parser)]
-struct MgmArgs {
-    #[arg(short, long)]
-    ping: bool,
-    #[arg(long)]
-    request_hk: bool,
-    #[arg(short, long)]
-    mode: Option<DeviceModeSelect>,
-}
-
-#[derive(Debug, PartialEq, Eq, Clone, Copy, clap::Parser)]
-struct MgmAssemblyArgs {
-    #[arg(short, long)]
-    ping: bool,
-    #[arg(short, long)]
-    mode: Option<AssemblyModeSelect>,
-}
-
-#[derive(Debug, PartialEq, Eq, Clone, Copy, clap::ValueEnum)]
-pub enum DeviceModeSelect {
-    Off,
-    Normal,
-}
-
-#[derive(Debug, PartialEq, Eq, Clone, Copy, clap::ValueEnum)]
-pub enum AssemblyModeSelect {
-    NoModeKeeping,
-    Off,
-    Normal,
-}
-
-fn setup_logger(level: log::LevelFilter) -> Result<(), fern::InitError> {
-    fern::Dispatch::new()
-        .format(|out, message, record| {
-            out.finish(format_args!(
-                "[{} {} {}] {}",
-                humantime::format_rfc3339_seconds(SystemTime::now()),
-                record.level(),
-                record.target(),
-                message
-            ))
-        })
-        .level(level)
-        .chain(std::io::stdout())
-        .chain(fern::log_file("output.log")?)
-        .apply()?;
-    Ok(())
-}
-
-fn main() -> anyhow::Result<()> {
-    setup_logger(log::LevelFilter::Debug).unwrap();
-    let kill_signal = Arc::new(AtomicBool::new(false));
-    let ctrl_kill_signal = kill_signal.clone();
-    ctrlc::set_handler(move || ctrl_kill_signal.store(true, Ordering::Relaxed)).unwrap();
-    let cli = Cli::parse();
-
-    let addr = SocketAddr::new(IpAddr::V4(OBSW_SERVER_ADDR), SERVER_PORT);
-    let client = UdpSocket::bind("127.0.0.1:7302").expect("Connecting to UDP server failed");
-    client.set_nonblocking(true)?;
-    client.set_read_timeout(Some(Duration::from_millis(200)))?;
-
-    if cli.ping {
-        let request = models::ccsds::CcsdsTcPacketOwned::new_with_request(
-            SpacePacketHeader::new_from_apid(u11::new(Apid::Tmtc as u16)),
-            TcHeader::new(models::ComponentId::Controller, models::MessageType::Ping),
-            models::control::request::Request::Ping,
-        );
-        let sent_tc_id = CcsdsPacketIdAndPsc::new_from_ccsds_packet(&request.sp_header);
-        log::info!("sending ping request with TC ID {:#010x}", sent_tc_id.raw());
-        let request_packet = request.to_vec();
-        client.send_to(&request_packet, addr).unwrap();
-    }
-    if cli.test_event {
-        let request = models::ccsds::CcsdsTcPacketOwned::new_with_request(
-            SpacePacketHeader::new_from_apid(u11::new(Apid::Tmtc as u16)),
-            TcHeader::new(models::ComponentId::Controller, models::MessageType::Event),
-            models::control::request::Request::TestEvent,
-        );
-        let sent_tc_id = CcsdsPacketIdAndPsc::new_from_ccsds_packet(&request.sp_header);
-        log::info!(
-            "sending event request with TC ID {:#010x}",
-            sent_tc_id.raw()
-        );
-        let request_packet = request.to_vec();
-        client.send_to(&request_packet, addr).unwrap();
-    }
-    if let Some(cmd) = cli.commands {
-        let target_id = cmd.target_id();
-        match cmd {
-            Commands::Mgm0(args) | Commands::Mgm1(args) => {
-                if args.ping {
-                    let request = models::ccsds::CcsdsTcPacketOwned::new_with_request(
-                        SpacePacketHeader::new_from_apid(u11::new(Apid::Acs as u16)),
-                        TcHeader::new(cmd.target_id(), models::MessageType::Ping),
-                        models::mgm::request::Request::Ping,
-                    );
-                    let sent_tc_id = CcsdsPacketIdAndPsc::new_from_ccsds_packet(&request.sp_header);
-                    log::info!(
-                        "sending {:?} ping request with TC ID {:#010x}",
-                        target_id,
-                        sent_tc_id.raw()
-                    );
-                    let request_packet = request.to_vec();
-                    client.send_to(&request_packet, addr).unwrap();
-                }
-                if args.request_hk {
-                    let request = models::ccsds::CcsdsTcPacketOwned::new_with_request(
-                        SpacePacketHeader::new_from_apid(u11::new(Apid::Acs as u16)),
-                        TcHeader::new(target_id, models::MessageType::Hk),
-                        models::mgm::request::Request::Hk(HkRequest {
-                            id: models::mgm::request::HkId::Sensor,
-                            req_type: models::HkRequestType::OneShot,
-                        }),
-                    );
-                    let sent_tc_id = CcsdsPacketIdAndPsc::new_from_ccsds_packet(&request.sp_header);
-                    log::info!(
-                        "sending {:?} HK request with TC ID {:#010x}",
-                        target_id,
-                        sent_tc_id.raw()
-                    );
-                    let request_packet = request.to_vec();
-                    client.send_to(&request_packet, addr).unwrap();
-                }
-                if let Some(mode) = args.mode {
-                    let dev_mode = match mode {
-                        DeviceModeSelect::Off => models::DeviceMode::Off,
-                        DeviceModeSelect::Normal => models::DeviceMode::Normal,
-                    };
-
-                    let request = models::ccsds::CcsdsTcPacketOwned::new_with_request(
-                        SpacePacketHeader::new_from_apid(u11::new(Apid::Acs as u16)),
-                        TcHeader::new(target_id, models::MessageType::Mode),
-                        models::mgm::request::Request::Mode(
-                            models::mgm::request::ModeRequest::SetMode(dev_mode),
-                        ),
-                    );
-                    let sent_tc_id = CcsdsPacketIdAndPsc::new_from_ccsds_packet(&request.sp_header);
-                    log::info!(
-                        "sending {:?} HK request with TC ID {:#010x}",
-                        target_id,
-                        sent_tc_id.raw()
-                    );
-                    let request_packet = request.to_vec();
-                    client.send_to(&request_packet, addr).unwrap();
-                }
-            }
-            Commands::MgmAssy(mgm_assembly_args) => {
-                if mgm_assembly_args.ping {
-                    let request = models::ccsds::CcsdsTcPacketOwned::new_with_request(
-                        SpacePacketHeader::new_from_apid(u11::new(Apid::Acs as u16)),
-                        TcHeader::new(cmd.target_id(), models::MessageType::Ping),
-                        models::mgm::request::Request::Ping,
-                    );
-                    let sent_tc_id = CcsdsPacketIdAndPsc::new_from_ccsds_packet(&request.sp_header);
-                    log::info!(
-                        "sending {:?} ping request with TC ID {:#010x}",
-                        target_id,
-                        sent_tc_id.raw()
-                    );
-                    let request_packet = request.to_vec();
-                    client.send_to(&request_packet, addr).unwrap();
-                }
-                if let Some(mode) = mgm_assembly_args.mode {
-                    let assembly_mode = match mode {
-                        AssemblyModeSelect::NoModeKeeping => {
-                            models::mgm_assembly::AssemblyMode::NoModeKeeping
-                        }
-                        AssemblyModeSelect::Off => {
-                            models::mgm_assembly::AssemblyMode::Device(models::DeviceMode::Off)
-                        }
-                        AssemblyModeSelect::Normal => {
-                            models::mgm_assembly::AssemblyMode::Device(models::DeviceMode::Normal)
-                        }
-                    };
-
-                    let request = models::ccsds::CcsdsTcPacketOwned::new_with_request(
-                        SpacePacketHeader::new_from_apid(u11::new(Apid::Acs as u16)),
-                        TcHeader::new(target_id, models::MessageType::Mode),
-                        models::mgm_assembly::request::Request::Mode(
-                            models::mgm_assembly::request::ModeRequest::SetMode(assembly_mode),
-                        ),
-                    );
-                    let sent_tc_id = CcsdsPacketIdAndPsc::new_from_ccsds_packet(&request.sp_header);
-                    log::info!(
-                        "sending {:?} HK request with TC ID {:#010x}",
-                        target_id,
-                        sent_tc_id.raw()
-                    );
-                    let request_packet = request.to_vec();
-                    client.send_to(&request_packet, addr).unwrap();
-                }
-            }
-        }
-    }
-
-    let mut recv_buf: Box<[u8; 2048]> = Box::new([0; 2048]);
-    log::info!("entering listening loop");
-    loop {
-        if kill_signal.load(std::sync::atomic::Ordering::Relaxed) {
-            log::info!("received kill signal, exiting");
-            break;
-        }
-        match client.recv(recv_buf.as_mut_slice()) {
-            Ok(received_bytes) => handle_raw_tm_packet(&recv_buf.as_slice()[0..received_bytes])?,
-            Err(e) => {
-                if e.kind() == std::io::ErrorKind::WouldBlock
-                    || e.kind() == std::io::ErrorKind::TimedOut
-                {
-                    continue;
-                }
-                log::warn!("UDP reception error: {}", e)
-            }
-        }
-    }
-    Ok(())
-}
-
-fn handle_raw_tm_packet(data: &[u8]) -> anyhow::Result<()> {
-    match spacepackets::CcsdsPacketReader::new_with_checksum(data) {
-        Ok(packet) => {
-            let tm_header_result =
-                postcard::take_from_bytes::<models::TmHeader>(packet.user_data());
-            if let Err(e) = tm_header_result {
-                bail!("Failed to deserialize TM header: {}", e);
-            }
-            let (tm_header, remainder) = tm_header_result.unwrap();
-            if let Some(tc_id) = tm_header.tc_id {
-                log::info!(
-                    "Received TM with APID {} and from sender {:?} for TC ID {:#010x}",
-                    packet.apid(),
-                    tm_header.sender_id,
-                    tc_id.raw()
-                );
-            } else {
-                log::info!(
-                    "Received unsolicited TM with APID {} and from sender {:?}",
-                    packet.apid(),
-                    tm_header.sender_id,
-                );
-            }
-            if tm_header.message_type == MessageType::Event {
-                let response = postcard::from_bytes::<models::Event>(remainder);
-                log::info!(
-                    "Received event from {:?}: {:?}",
-                    tm_header.sender_id,
-                    response.unwrap()
-                );
-                return Ok(());
-            }
-            match tm_header.sender_id {
-                models::ComponentId::EpsPcdu => {
-                    let response =
-                        postcard::from_bytes::<models::pcdu::response::Response>(remainder);
-                    log::info!("Received response from PCDU: {:?}", response.unwrap());
-                }
-                models::ComponentId::Controller => {
-                    let response =
-                        postcard::from_bytes::<models::control::response::Response>(remainder);
-                    log::info!("Received response from controller: {:?}", response.unwrap());
-                }
-                models::ComponentId::AcsSubsystem => todo!(),
-                models::ComponentId::AcsMgmAssembly => {
-                    let response =
-                        postcard::from_bytes::<models::mgm_assembly::response::Response>(remainder);
-                    log::info!(
-                        "Received response from MGM Assembly: {:?}",
-                        response.unwrap()
-                    );
-                }
-                models::ComponentId::AcsMgm0 => {
-                    let response =
-                        postcard::from_bytes::<models::mgm::response::Response>(remainder);
-                    log::info!("Received response from MGM0: {:?}", response.unwrap());
-                }
-                models::ComponentId::AcsMgm1 => {
-                    let response =
-                        postcard::from_bytes::<models::mgm::response::Response>(remainder);
-                    log::info!("Received response from MGM1: {:?}", response.unwrap());
-                }
-                models::ComponentId::EpsSubsystem => todo!(),
-                models::ComponentId::UdpServer => todo!(),
-                models::ComponentId::TcpServer => todo!(),
-                models::ComponentId::Ground => todo!(),
-                models::ComponentId::EventManager => {}
-            }
-        }
-        Err(_) => todo!(),
-    }
-    Ok(())
-}

satrs-example/models/Cargo.toml

@@ -1,15 +0,0 @@
-[package]
-name = "models"
-version = "0.1.0"
-edition = "2024"
-
-[dependencies]
-serde = { version = "1", features = ["derive"] }
-spacepackets = { version = "0.17", git = "https://egit.irs.uni-stuttgart.de/rust/spacepackets.git", default-features = false }
-satrs = { path = "../../satrs" }
-num_enum = { version = "0.7" }
-strum = { version = "0.28", features = ["derive"] }
-postcard = { version = "1" }
-thiserror = { version = "2" }
-bitbybit = "2"
-arbitrary-int = "2"

satrs-example/models/src/ccsds.rs

@@ -1,130 +0,0 @@
-use crate::TmHeader;
-use serde::Serialize;
-use spacepackets::{
-    CcsdsPacketCreationError, CcsdsPacketCreatorWithReservedData, SpHeader, SpacePacketHeader,
-    ccsds_packet_len_for_user_data_len_with_checksum,
-};
-
-use crate::TcHeader;
-
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct CcsdsTcPacketOwned {
-    pub sp_header: SpacePacketHeader,
-    pub tc_header: TcHeader,
-    pub payload: alloc::vec::Vec<u8>,
-}
-
-impl CcsdsTcPacketOwned {
-    pub fn new_with_request<R: serde::Serialize>(
-        sp_header: SpacePacketHeader,
-        tc_header: TcHeader,
-        request: R,
-    ) -> Self {
-        let request_serialized = postcard::to_allocvec(&request).unwrap();
-        Self::new(sp_header, tc_header, request_serialized)
-    }
-
-    pub fn new(
-        sp_header: SpacePacketHeader,
-        tc_header: TcHeader,
-        payload: alloc::vec::Vec<u8>,
-    ) -> Self {
-        Self {
-            sp_header,
-            tc_header,
-            payload,
-        }
-    }
-
-    pub fn write_to_bytes(&self, buf: &mut [u8]) -> Result<usize, CcsdsCreationError> {
-        let response_len =
-            postcard::experimental::serialized_size(&self.tc_header)? + self.payload.len();
-        let mut ccsds_tc = CcsdsPacketCreatorWithReservedData::new_tc_with_checksum(
-            self.sp_header,
-            response_len,
-            buf,
-        )?;
-        let user_data = ccsds_tc.packet_data_mut();
-        let ser_len = postcard::to_slice(&self.tc_header, user_data)?.len();
-        user_data[ser_len..ser_len + self.payload.len()].copy_from_slice(&self.payload);
-        let ccsds_packet_len = ccsds_tc.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.tc_header).unwrap() as usize
-                + postcard::experimental::serialized_size(&self.payload).unwrap() as usize,
-        )
-        .unwrap()
-    }
-
-    pub fn to_vec(&self) -> alloc::vec::Vec<u8> {
-        let mut buf = alloc::vec![0u8; self.len_written()];
-        let len = self.write_to_bytes(&mut buf).unwrap();
-        buf.truncate(len);
-        buf
-    }
-}
-
-#[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,
-}
-
-/// 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>,
-}
-
-impl CcsdsTmPacketOwned {
-    pub fn new_with_serde_payload(
-        sp_header: SpHeader,
-        tm_header: &TmHeader,
-        payload: &impl Serialize,
-    ) -> Result<Self, postcard::Error> {
-        Ok(CcsdsTmPacketOwned {
-            sp_header,
-            tm_header: *tm_header,
-            payload: postcard::to_allocvec(&payload)?,
-        })
-    }
-
-    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) -> alloc::vec::Vec<u8> {
-        let mut buf = alloc::vec![0u8; self.len_written()];
-        let len = self.write_to_bytes(&mut buf).unwrap();
-        buf.truncate(len);
-        buf
-    }
-}

satrs-example/models/src/control.rs

@@ -1,39 +0,0 @@
-use crate::Message;
-
-#[derive(serde::Serialize, serde::Deserialize, Clone, Copy, Debug)]
-pub enum Event {
-    TestEvent,
-}
-
-impl Message for Event {
-    fn message_type(&self) -> crate::MessageType {
-        crate::MessageType::Event
-    }
-}
-
-pub mod request {
-    #[derive(serde::Serialize, serde::Deserialize, Clone, Copy, Debug)]
-    pub enum Request {
-        Ping,
-        TestEvent,
-    }
-}
-
-pub mod response {
-    use crate::Message;
-
-    #[derive(serde::Serialize, serde::Deserialize, Clone, Copy, Debug)]
-    pub enum Response {
-        Ok,
-        Event(super::Event),
-    }
-
-    impl Message for Response {
-        fn message_type(&self) -> crate::MessageType {
-            match self {
-                Response::Ok => crate::MessageType::Verification,
-                Response::Event(_event) => crate::MessageType::Event,
-            }
-        }
-    }
-}

satrs-example/models/src/lib.rs

@@ -1,196 +0,0 @@
-extern crate alloc;
-use core::str::FromStr;
-
-use spacepackets::{
-    CcsdsPacketIdAndPsc,
-    time::cds::{CdsTime, MIN_CDS_FIELD_LEN},
-};
-
-pub mod ccsds;
-pub mod control;
-pub mod mgm;
-pub mod mgm_assembly;
-pub mod pcdu;
-
-#[derive(
-    Debug,
-    Copy,
-    Clone,
-    PartialEq,
-    Eq,
-    Hash,
-    serde::Serialize,
-    serde::Deserialize,
-    num_enum::TryFromPrimitive,
-    num_enum::IntoPrimitive,
-)]
-#[repr(u64)]
-pub enum ComponentId {
-    Controller,
-
-    AcsSubsystem,
-    AcsMgmAssembly,
-    AcsMgm0,
-    AcsMgm1,
-
-    EpsSubsystem,
-    EpsPcdu,
-
-    UdpServer,
-    TcpServer,
-    EventManager,
-
-    Ground,
-}
-
-#[derive(Debug, PartialEq, Eq, strum::EnumIter)]
-#[bitbybit::bitenum(u11)]
-pub enum Apid {
-    Tmtc = 1,
-    Cfdp = 2,
-
-    Acs = 3,
-    Eps = 6,
-}
-
-#[derive(Debug, Copy, Clone, serde::Serialize, serde::Deserialize)]
-pub enum Event {
-    ControllerEvent(control::Event),
-}
-
-impl Message for Event {
-    fn message_type(&self) -> MessageType {
-        MessageType::Event
-    }
-}
-
-#[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]>,
-}
-
-impl TmHeader {
-    pub fn new(
-        sender_id: ComponentId,
-        target_id: ComponentId,
-        message_type: MessageType,
-        tc_id: Option<CcsdsPacketIdAndPsc>,
-        cds_timestamp: &CdsTime,
-    ) -> Self {
-        // Can not fail, CDS short always requires 7 bytes.
-        let mut stamp_buf: [u8; MIN_CDS_FIELD_LEN] = [0; MIN_CDS_FIELD_LEN];
-        cds_timestamp.write_to_bytes(&mut stamp_buf).unwrap();
-        Self {
-            sender_id,
-            target_id,
-            tc_id,
-            message_type,
-            timestamp: Some(stamp_buf),
-        }
-    }
-    pub fn new_for_unsolicited_tm(
-        sender_id: ComponentId,
-        target_id: ComponentId,
-        message_type: MessageType,
-        cds_timestamp: &CdsTime,
-    ) -> Self {
-        Self::new(sender_id, target_id, message_type, None, cds_timestamp)
-    }
-
-    pub fn new_for_tc_response(
-        sender_id: ComponentId,
-        target_id: ComponentId,
-        message_type: MessageType,
-        tc_id: CcsdsPacketIdAndPsc,
-        cds_timestamp: &CdsTime,
-    ) -> Self {
-        Self::new(
-            sender_id,
-            target_id,
-            message_type,
-            Some(tc_id),
-            cds_timestamp,
-        )
-    }
-
-    pub fn from_bytes_postcard(data: &[u8]) -> Result<(Self, &[u8]), postcard::Error> {
-        postcard::take_from_bytes::<TmHeader>(data)
-    }
-}
-
-#[derive(Debug, Copy, Clone, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
-#[non_exhaustive]
-pub struct TcHeader {
-    pub target_id: ComponentId,
-    pub request_type: MessageType,
-}
-
-impl TcHeader {
-    pub fn new(target_id: ComponentId, request_type: MessageType) -> Self {
-        Self {
-            target_id,
-            request_type,
-        }
-    }
-}
-
-#[derive(Debug, Copy, Clone, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
-pub enum MessageType {
-    Ping,
-    Mode,
-    Hk,
-    Action,
-    Event,
-    Verification,
-}
-
-pub trait Message {
-    fn message_type(&self) -> MessageType;
-}
-
-/// Generic device mode which covers the requirements of most devices.
-///
-/// The states are related both to the physical and the logical state of the device. Some
-/// device handlers control the power supply of their own device and an off state might also
-/// mean that the device is physically off.
-#[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq, Eq, Copy, Clone)]
-pub enum DeviceMode {
-    Off = 0,
-    On = 1,
-    /// Normal operation mode where periodic polling might be done as well.
-    Normal = 2,
-}
-
-impl FromStr for DeviceMode {
-    type Err = ();
-
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        match s.to_lowercase().as_str() {
-            "off" => Ok(DeviceMode::Off),
-            "on" => Ok(DeviceMode::On),
-            "normal" => Ok(DeviceMode::Normal),
-            _ => Err(()),
-        }
-    }
-}
-
-#[derive(Debug, Copy, Clone, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
-#[non_exhaustive]
-pub enum HkRequestType {
-    OneShot,
-    /// Enable periodic HK generation with a specified frequency.
-    EnablePeriodic(core::time::Duration),
-    DisablePeriodic,
-    /// Modify periodic HK generation interval.
-    ModifyInterval(core::time::Duration),
-}
-
-#[cfg(test)]
-mod tests {}

satrs-example/models/src/mgm.rs

@@ -1,90 +0,0 @@
-pub mod request {
-    use crate::{DeviceMode, HkRequestType, Message};
-
-    #[derive(serde::Serialize, serde::Deserialize, Debug, Clone, Copy, PartialEq, Eq)]
-    pub enum ModeRequest {
-        SetMode(DeviceMode),
-        ReadMode,
-    }
-
-    #[derive(Debug, PartialEq, Eq, Clone, Copy, serde::Serialize, serde::Deserialize)]
-    pub enum HkId {
-        Sensor,
-    }
-
-    #[derive(Debug, PartialEq, Eq, Clone, Copy, serde::Serialize, serde::Deserialize)]
-    pub struct HkRequest {
-        pub id: HkId,
-        pub req_type: HkRequestType,
-    }
-
-    #[derive(serde::Serialize, serde::Deserialize, Clone, Copy, Debug)]
-    pub enum Request {
-        Ping,
-        Hk(HkRequest),
-        Mode(ModeRequest),
-    }
-
-    impl Request {
-        fn message_type(&self) -> crate::MessageType {
-            match self {
-                Request::Ping => crate::MessageType::Verification,
-                Request::Hk(_hk_request) => crate::MessageType::Hk,
-                Request::Mode(_mode) => crate::MessageType::Mode,
-            }
-        }
-    }
-    impl Message for Request {
-        fn message_type(&self) -> crate::MessageType {
-            self.message_type()
-        }
-    }
-}
-
-#[derive(Default, Debug, Copy, Clone, serde::Serialize, serde::Deserialize)]
-pub struct MgmData {
-    pub valid: bool,
-    pub x: f32,
-    pub y: f32,
-    pub z: f32,
-}
-
-pub mod response {
-    use crate::{DeviceMode, Message, mgm::MgmData};
-
-    #[derive(serde::Serialize, serde::Deserialize, Clone, Copy, Debug)]
-    pub enum HkResponse {
-        MgmData(MgmData),
-    }
-
-    #[derive(serde::Serialize, serde::Deserialize, Debug, Clone, Copy)]
-    pub enum ModeResponse {
-        /// New mode has been set.
-        Mode(DeviceMode),
-        /// Setting a mode timed out.
-        SetModeTimeout,
-    }
-
-    #[derive(serde::Serialize, serde::Deserialize, Clone, Copy, Debug)]
-    pub enum Response {
-        Ok,
-        Hk(HkResponse),
-        Mode(ModeResponse),
-    }
-
-    impl Response {
-        fn message_type(&self) -> crate::MessageType {
-            match self {
-                Response::Ok => crate::MessageType::Verification,
-                Response::Hk(_hk_response) => crate::MessageType::Hk,
-                Response::Mode(_mode_failure) => crate::MessageType::Mode,
-            }
-        }
-    }
-
-    impl Message for Response {
-        fn message_type(&self) -> crate::MessageType {
-            self.message_type()
-        }
-    }
-}

satrs-example/models/src/mgm_assembly.rs

@@ -1,109 +0,0 @@
-use core::str::FromStr;
-
-use crate::DeviceMode;
-
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, Copy, PartialEq, Eq)]
-pub enum AssemblyMode {
-    /// The assembly mode ressembles the modes of the devices it controls. It also tries to keep
-    /// the children in the correct mode by re-commanding them into the correct mode.
-    Device(DeviceMode),
-    /// Mode keeping disabled.
-    NoModeKeeping,
-}
-
-impl FromStr for AssemblyMode {
-    type Err = ();
-
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        match s.to_lowercase().as_str() {
-            "off" => Ok(AssemblyMode::Device(DeviceMode::Off)),
-            "on" => Ok(AssemblyMode::Device(DeviceMode::On)),
-            "normal" => Ok(AssemblyMode::Device(DeviceMode::Normal)),
-            "no_mode_keeping" => Ok(AssemblyMode::NoModeKeeping),
-            _ => Err(()),
-        }
-    }
-}
-
-pub mod request {
-    use crate::{HkRequestType, Message, mgm_assembly::AssemblyMode};
-
-    #[derive(Debug, PartialEq, Eq, Clone, Copy, serde::Serialize, serde::Deserialize)]
-    pub enum HkId {
-        Sensor,
-    }
-
-    #[derive(Debug, Copy, Clone, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
-    pub enum ModeRequest {
-        SetMode(AssemblyMode),
-        ReadMode,
-    }
-
-    #[derive(Debug, PartialEq, Eq, Clone, Copy, serde::Serialize, serde::Deserialize)]
-    pub struct HkRequest {
-        pub id: HkId,
-        pub req_type: HkRequestType,
-    }
-
-    #[derive(serde::Serialize, serde::Deserialize, Clone, Copy, Debug)]
-    pub enum Request {
-        Ping,
-        Mode(ModeRequest),
-    }
-
-    impl Request {
-        fn message_type(&self) -> crate::MessageType {
-            match self {
-                Request::Ping => crate::MessageType::Verification,
-                Request::Mode(_mode) => crate::MessageType::Mode,
-            }
-        }
-    }
-    impl Message for Request {
-        fn message_type(&self) -> crate::MessageType {
-            self.message_type()
-        }
-    }
-}
-
-pub mod response {
-    use crate::{DeviceMode, Message};
-
-    #[derive(serde::Serialize, serde::Deserialize, Clone, Copy, Debug, PartialEq, Eq)]
-    pub enum ModeCommandFailure {
-        Timeout,
-    }
-
-    #[derive(Debug, Copy, Clone, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
-    pub enum ModeReport {
-        /// Mode of the assembly.
-        Mode(super::AssemblyMode),
-        /// Timeout failure setting the children modes.
-        SetModeTimeout([Option<DeviceMode>; 2]),
-        /// Children are in wrong mode after commanding.
-        WrongMode([Option<DeviceMode>; 2]),
-        /// An assembly tried modekeeping but can not keep its mode.
-        CanNotKeepMode([Option<DeviceMode>; 2]),
-    }
-
-    #[derive(serde::Serialize, serde::Deserialize, Clone, Copy, Debug, PartialEq, Eq)]
-    pub enum Response {
-        Ok,
-        Mode(ModeReport),
-    }
-
-    impl Response {
-        fn message_type(&self) -> crate::MessageType {
-            match self {
-                Response::Ok => crate::MessageType::Verification,
-                Response::Mode(_mode_report) => crate::MessageType::Mode,
-            }
-        }
-    }
-
-    impl Message for Response {
-        fn message_type(&self) -> crate::MessageType {
-            self.message_type()
-        }
-    }
-}

satrs-example/models/src/pcdu.rs

@@ -1,147 +0,0 @@
-use std::collections::HashMap;
-
-use strum::IntoEnumIterator as _;
-
-#[bitbybit::bitfield(u16, debug, default = 0x0)]
-#[derive(serde::Serialize, serde::Deserialize)]
-pub struct SwitchesBitfield {
-    #[bit(2, rw)]
-    magnetorquer: bool,
-    #[bit(1, rw)]
-    mgm1: bool,
-    #[bit(0, rw)]
-    mgm0: bool,
-}
-
-#[derive(
-    Debug,
-    Copy,
-    Clone,
-    PartialEq,
-    Eq,
-    serde::Serialize,
-    serde::Deserialize,
-    Hash,
-    strum::EnumIter,
-    num_enum::IntoPrimitive,
-    num_enum::TryFromPrimitive,
-)]
-#[repr(u16)]
-pub enum SwitchId {
-    Mgm0 = 0,
-    Mgm1 = 1,
-    Mgt = 2,
-}
-
-#[derive(Debug, Eq, PartialEq, Copy, Clone, serde::Serialize, serde::Deserialize)]
-pub enum SwitchState {
-    Off = 0,
-    On = 1,
-    Unknown = 2,
-    Faulty = 3,
-}
-
-impl From<SwitchStateBinary> for SwitchState {
-    fn from(value: SwitchStateBinary) -> Self {
-        match value {
-            SwitchStateBinary::Off => SwitchState::Off,
-            SwitchStateBinary::On => SwitchState::On,
-        }
-    }
-}
-
-#[derive(Debug, Eq, PartialEq, Copy, Clone, serde::Serialize, serde::Deserialize)]
-pub enum SwitchStateBinary {
-    Off = 0,
-    On = 1,
-}
-
-pub type SwitchMapBinary = HashMap<SwitchId, SwitchStateBinary>;
-
-pub struct SwitchMapBinaryWrapper(pub SwitchMapBinary);
-
-impl Default for SwitchMapBinaryWrapper {
-    fn default() -> Self {
-        let mut switch_map = SwitchMapBinary::default();
-        for entry in SwitchId::iter() {
-            switch_map.insert(entry, SwitchStateBinary::Off);
-        }
-        Self(switch_map)
-    }
-}
-
-pub struct SwitchRequest {
-    pub switch_id: SwitchId,
-    pub target_state: SwitchStateBinary,
-}
-
-impl SwitchRequest {
-    pub fn new(switch_id: SwitchId, target_state: SwitchStateBinary) -> Self {
-        Self {
-            switch_id,
-            target_state,
-        }
-    }
-
-    pub fn switch_id(&self) -> SwitchId {
-        self.switch_id
-    }
-
-    pub fn target_state(&self) -> SwitchStateBinary {
-        self.target_state
-    }
-}
-
-pub mod request {
-    use crate::{DeviceMode, Message};
-
-    use super::*;
-
-    #[derive(serde::Serialize, serde::Deserialize, Clone, Copy, Debug)]
-    pub enum Request {
-        Mode(DeviceMode),
-        Ping,
-        GetSwitches,
-        EnableSwitches(SwitchesBitfield),
-        DisableSwitches(SwitchesBitfield),
-    }
-
-    impl Request {
-        pub fn message_type(&self) -> crate::MessageType {
-            match self {
-                Request::Mode(_mode) => crate::MessageType::Mode,
-                Request::Ping => crate::MessageType::Verification,
-                Request::GetSwitches => crate::MessageType::Action,
-                Request::EnableSwitches(_switches) | Request::DisableSwitches(_switches) => {
-                    crate::MessageType::Action
-                }
-            }
-        }
-    }
-
-    impl Message for Request {
-        fn message_type(&self) -> crate::MessageType {
-            self.message_type()
-        }
-    }
-}
-
-pub mod response {
-    use super::*;
-    use crate::Message;
-
-    #[derive(serde::Serialize, serde::Deserialize, Clone, Copy, Debug)]
-    pub enum Response {
-        Ok,
-        Switches(SwitchesBitfield),
-    }
-
-    impl Message for Response {
-        fn message_type(&self) -> crate::MessageType {
-            match self {
-                Response::Ok => crate::MessageType::Verification,
-                Response::Switches(_switches) => crate::MessageType::Action,
-            }
-        }
-    }
-}

satrs-example/src/acs/assembly.rs

@@ -0,0 +1,175 @@
+// TODO: Write the assembly
+//
+
+use std::sync::mpsc;
+
+use satrs::{
+    dev_mgmt::{DevManagerCommandingHelper, DevManagerHelperResult, TransparentDevManagerHook},
+    mode::{
+        ModeAndSubmode, ModeError, ModeProvider, ModeReply, ModeReplyReceiver as _,
+        ModeReplySender as _, ModeRequest, ModeRequestHandler, ModeRequestReceiver as _,
+        ModeRequestorAndHandlerMpscBounded, UNKNOWN_MODE,
+    },
+    mode_tree::{ModeChild, ModeNode, ModeParent},
+    queue::GenericTargetedMessagingError,
+    request::{GenericMessage, MessageMetadata},
+    ComponentId,
+};
+use satrs_example::{ids, DeviceMode};
+
+pub type RequestSenderType = mpsc::SyncSender<GenericMessage<ModeRequest>>;
+pub type ReplySenderType = mpsc::SyncSender<GenericMessage<ModeReply>>;
+
+// TODO: Needs to perform same functions as the integration test assembly, but also needs
+// to track mode changes and health changes of children.
+pub struct MgmAssembly {
+    pub mode_node: ModeRequestorAndHandlerMpscBounded,
+    pub mode_requestor_info: Option<MessageMetadata>,
+    pub mode_and_submode: ModeAndSubmode,
+    pub commanding_helper: DevManagerCommandingHelper<TransparentDevManagerHook>,
+}
+
+impl MgmAssembly {
+    pub fn new(mode_node: ModeRequestorAndHandlerMpscBounded) -> Self {
+        Self {
+            mode_node,
+            mode_requestor_info: None,
+            mode_and_submode: UNKNOWN_MODE,
+            commanding_helper: DevManagerCommandingHelper::new(TransparentDevManagerHook::default()),
+        }
+    }
+
+    pub const fn id() -> ComponentId {
+        ids::acs::MGM_ASSEMBLY.raw()
+    }
+
+    pub fn periodic_operation(&mut self) {
+        self.check_mode_requests().expect("mode messaging error");
+        self.check_mode_replies().expect("mode messaging error");
+        // TODO: perform target keeping, check whether children are in correct mode.
+    }
+
+    pub fn check_mode_requests(&mut self) -> Result<(), GenericTargetedMessagingError> {
+        while let Some(request) = self.mode_node.try_recv_mode_request()? {
+            self.handle_mode_request(request).unwrap();
+        }
+        Ok(())
+    }
+
+    pub fn check_mode_replies(&mut self) -> Result<(), ModeError> {
+        while let Some(reply_and_id) = self.mode_node.try_recv_mode_reply()? {
+            match self.commanding_helper.handle_mode_reply(&reply_and_id) {
+                Ok(result) => {
+                    if let DevManagerHelperResult::ModeCommandingDone(context) = result {
+                        // Complete the mode command.
+                        self.mode_and_submode = context.target_mode;
+                        self.handle_mode_reached(self.mode_requestor_info)?;
+                    }
+                }
+                Err(err) => match err {
+                    satrs::dev_mgmt::DevManagerHelperError::ChildNotInStore => todo!(),
+                },
+            }
+        }
+        Ok(())
+    }
+}
+
+impl ModeNode for MgmAssembly {
+    fn id(&self) -> ComponentId {
+        Self::id()
+    }
+}
+impl ModeParent for MgmAssembly {
+    type Sender = RequestSenderType;
+
+    fn add_mode_child(&mut self, id: ComponentId, request_sender: RequestSenderType) {
+        self.mode_node.add_request_target(id, request_sender);
+        self.commanding_helper.add_mode_child(id, UNKNOWN_MODE);
+    }
+}
+
+impl ModeChild for MgmAssembly {
+    type Sender = ReplySenderType;
+
+    fn add_mode_parent(&mut self, id: ComponentId, reply_sender: ReplySenderType) {
+        self.mode_node.add_reply_target(id, reply_sender);
+    }
+}
+
+impl ModeProvider for MgmAssembly {
+    fn mode_and_submode(&self) -> ModeAndSubmode {
+        self.mode_and_submode
+    }
+}
+
+impl ModeRequestHandler for MgmAssembly {
+    type Error = ModeError;
+    fn start_transition(
+        &mut self,
+        requestor: MessageMetadata,
+        mode_and_submode: ModeAndSubmode,
+        forced: bool,
+    ) -> Result<(), Self::Error> {
+        // Always accept forced commands and commands to mode OFF.
+        if self.commanding_helper.target_mode().is_some()
+            && !forced
+            && mode_and_submode.mode() != DeviceMode::Off as u32
+        {
+            return Err(ModeError::Busy);
+        }
+        self.mode_requestor_info = Some(requestor);
+        self.commanding_helper.send_mode_cmd_to_all_children(
+            requestor.request_id(),
+            mode_and_submode,
+            forced,
+            &self.mode_node,
+        )?;
+        Ok(())
+    }
+
+    fn announce_mode(&self, requestor_info: Option<MessageMetadata>, recursive: bool) {
+        println!(
+            "TestAssembly: Announcing mode (recursively: {}): {:?}",
+            recursive, self.mode_and_submode
+        );
+        let request_id = requestor_info.map_or(0, |info| info.request_id());
+        self.commanding_helper
+            .send_announce_mode_cmd_to_children(request_id, &self.mode_node, recursive)
+            .expect("sending mode request failed");
+        // TODO: Send announce event.
+        log::info!(
+            "MGM assembly announcing mode: {:?}",
+            self.mode_and_submode()
+        );
+    }
+
+    fn handle_mode_reached(
+        &mut self,
+        mode_requestor: Option<MessageMetadata>,
+    ) -> Result<(), Self::Error> {
+        if let Some(requestor) = mode_requestor {
+            self.send_mode_reply(requestor, ModeReply::ModeReply(self.mode_and_submode))?;
+        }
+        self.announce_mode(mode_requestor, false);
+        Ok(())
+    }
+
+    fn handle_mode_info(
+        &mut self,
+        requestor_info: MessageMetadata,
+        info: ModeAndSubmode,
+    ) -> Result<(), Self::Error> {
+        // TODO: Perform mode keeping.
+        Ok(())
+    }
+
+    fn send_mode_reply(
+        &self,
+        requestor: MessageMetadata,
+        reply: ModeReply,
+    ) -> Result<(), Self::Error> {
+        self.mode_node.send_mode_reply(requestor, reply)?;
+        Ok(())
+    }
+}

satrs-example/src/acs/mgm_assembly.rs

@@ -1,634 +0,0 @@
-use std::{sync::mpsc, time::Duration};
-
-use models::{
-    ComponentId, DeviceMode,
-    mgm_assembly::{AssemblyMode, request, response},
-};
-use satrs::spacepackets::CcsdsPacketIdAndPsc;
-use satrs_example::{ModeHelper, TmtcQueues};
-
-use crate::ccsds::pack_ccsds_tm_packet_for_now;
-
-pub struct ParentQueueHelper {
-    pub request_rx: mpsc::Receiver<request::ModeRequest>,
-    pub report_tx: mpsc::SyncSender<response::ModeReport>,
-}
-
-/// Helper component for communication with a parent component, which is usually as assembly.
-pub struct ChildrenQueueHelper {
-    pub request_tx_queues: [mpsc::SyncSender<models::mgm::request::ModeRequest>; 2],
-    pub report_rx_queues: [mpsc::Receiver<models::mgm::response::ModeResponse>; 2],
-}
-
-#[derive(Debug, Default, Clone, Copy, PartialEq, Eq)]
-pub enum TransitionState {
-    #[default]
-    Idle,
-    AwaitingReplies,
-}
-
-#[derive(Debug, Default, Copy, Clone)]
-pub struct MgmInfo {
-    reply_received: bool,
-    mode: Option<DeviceMode>,
-}
-
-/// MGM assembly component.
-pub struct Assembly {
-    mode_helper: ModeHelper<AssemblyMode, TransitionState>,
-    /// This boolean is used for the distinction between transitions commanded by the parent
-    /// or by ground, and transitions which were commanded autonomously as part of children
-    /// mode keeping.
-    mode_keeping_transition: bool,
-    tmtc_queues: TmtcQueues,
-    mgm_modes: [MgmInfo; 2],
-    parent_queues: ParentQueueHelper,
-    pub(crate) children_queues: ChildrenQueueHelper,
-}
-
-impl Assembly {
-    pub const ID: ComponentId = ComponentId::AcsMgmAssembly;
-
-    pub fn new(
-        parent_queues: ParentQueueHelper,
-        children_queues: ChildrenQueueHelper,
-        tmtc_queues: TmtcQueues,
-        mode_timeout: Duration,
-    ) -> Self {
-        Self {
-            mode_helper: ModeHelper::new(AssemblyMode::NoModeKeeping, mode_timeout),
-            mode_keeping_transition: false,
-            tmtc_queues,
-            mgm_modes: [MgmInfo::default(); 2],
-            parent_queues,
-            children_queues,
-        }
-    }
-
-    pub fn periodic_operation(&mut self) {
-        self.handle_telecommands();
-        self.handle_parent_mode_queue();
-        self.handle_children_mode_queues();
-
-        if self.mode_helper.transition_active() {
-            self.handle_mode_transition();
-        }
-    }
-
-    pub fn handle_telecommands(&mut self) {
-        loop {
-            match self.tmtc_queues.tc_rx.try_recv() {
-                Ok(packet) => {
-                    let tc_id = CcsdsPacketIdAndPsc::new_from_ccsds_packet(&packet.sp_header);
-                    match postcard::from_bytes::<models::mgm_assembly::request::Request>(
-                        &packet.payload,
-                    ) {
-                        Ok(request) => match request {
-                            models::mgm_assembly::request::Request::Ping => {
-                                self.send_telemetry(Some(tc_id), response::Response::Ok)
-                            }
-                            models::mgm_assembly::request::Request::Mode(request) => {
-                                match request {
-                                    request::ModeRequest::SetMode(assembly_mode) => {
-                                        self.start_transition(false, assembly_mode, Some(tc_id))
-                                    }
-                                    request::ModeRequest::ReadMode => self.send_telemetry(
-                                        Some(tc_id),
-                                        response::Response::Mode(response::ModeReport::Mode(
-                                            self.mode(),
-                                        )),
-                                    ),
-                                }
-                            }
-                        },
-                        Err(e) => {
-                            log::warn!("failed to deserialize request: {}", e);
-                        }
-                    }
-                }
-                Err(e) => match e {
-                    mpsc::TryRecvError::Empty => break,
-                    mpsc::TryRecvError::Disconnected => log::warn!("packet sender disconnected"),
-                },
-            }
-        }
-    }
-
-    pub fn send_telemetry(
-        &self,
-        tc_id: Option<CcsdsPacketIdAndPsc>,
-        response: models::mgm_assembly::response::Response,
-    ) {
-        match pack_ccsds_tm_packet_for_now(Self::ID, tc_id, &response) {
-            Ok(packet) => {
-                if let Err(e) = self.tmtc_queues.tm_tx.send(packet) {
-                    log::warn!("failed to send TM packet: {}", e);
-                }
-            }
-            Err(e) => {
-                log::warn!("failed to pack TM packet: {}", e);
-            }
-        }
-    }
-
-    pub fn handle_parent_mode_queue(&mut self) {
-        loop {
-            match self.parent_queues.request_rx.try_recv() {
-                Ok(request) => match request {
-                    request::ModeRequest::SetMode(assembly_mode) => match assembly_mode {
-                        AssemblyMode::Device(_device_mode) => {
-                            self.start_transition(false, assembly_mode, None);
-                        }
-                        AssemblyMode::NoModeKeeping => {
-                            self.mode_helper.current = AssemblyMode::NoModeKeeping;
-                        }
-                    },
-                    request::ModeRequest::ReadMode => self
-                        .parent_queues
-                        .report_tx
-                        .send(response::ModeReport::Mode(self.mode_helper.current))
-                        .unwrap(),
-                },
-                Err(e) => match e {
-                    mpsc::TryRecvError::Empty => break,
-                    mpsc::TryRecvError::Disconnected => {
-                        log::warn!("packet sender disconnected")
-                    }
-                },
-            }
-        }
-    }
-
-    pub fn handle_children_mode_queues(&mut self) {
-        let mut mode_report_received = false;
-        for (idx, rx) in self.children_queues.report_rx_queues.iter_mut().enumerate() {
-            loop {
-                match rx.try_recv() {
-                    Ok(report) => match report {
-                        models::mgm::response::ModeResponse::Mode(device_mode) => {
-                            self.mgm_modes[idx].mode = Some(device_mode);
-                            self.mgm_modes[idx].reply_received = true;
-                            mode_report_received = true;
-                        }
-                        models::mgm::response::ModeResponse::SetModeTimeout => {
-                            // Ignore, handle this with our own timeout.
-                            log::warn!("MGM {} mode timeout", idx);
-                        }
-                    },
-                    Err(e) => match e {
-                        mpsc::TryRecvError::Empty => break,
-                        mpsc::TryRecvError::Disconnected => {
-                            log::warn!("packet sender disconnected")
-                        }
-                    },
-                }
-            }
-        }
-        if !mode_report_received {
-            return;
-        }
-
-        // Transition is active, check for completion.
-        if self.mode_helper.transition_active()
-            && self.mgm_modes.iter().all(|i| i.reply_received)
-            && let AssemblyMode::Device(device_mode) = self.mode_helper.target.unwrap()
-        {
-            // If at least one child reached the correct mode, we are done.
-            if self.mgm_modes.iter().any(|i| i.mode == Some(device_mode)) {
-                self.handle_mode_reached(true);
-            } else {
-                let report = if self.mode_keeping_transition {
-                    response::ModeReport::CanNotKeepMode(self.mgm_modes.map(|info| info.mode))
-                } else {
-                    response::ModeReport::WrongMode(self.mgm_modes.map(|info| info.mode))
-                };
-                self.handle_mode_transition_failure(report);
-            }
-        }
-
-        // Mode keeping active: Check children modes.
-        if let AssemblyMode::Device(device_mode) = self.mode_helper.current
-            && self
-                .mgm_modes
-                .iter()
-                .all(|info| info.mode != Some(device_mode))
-        {
-            // Children lost mode. Try to command them back to the correct
-            // mode.
-            self.start_transition(true, self.mode_helper.current, None);
-        }
-    }
-
-    pub fn handle_mode_transition(&mut self) {
-        if self.mode_helper.target.is_none() {
-            self.handle_mode_reached(true);
-            return;
-        }
-        let target = self.mode_helper.target.unwrap();
-        let device_mode = match target {
-            AssemblyMode::Device(device_mode) => device_mode,
-            AssemblyMode::NoModeKeeping => {
-                self.handle_mode_reached(true);
-                return;
-            }
-        };
-        if self.mode_helper.transition_state == TransitionState::Idle {
-            self.command_children(device_mode);
-            self.mode_helper.transition_state = TransitionState::AwaitingReplies;
-        }
-        if self.mode_helper.transition_state == TransitionState::AwaitingReplies
-            && self.mode_helper.timed_out()
-        {
-            let report = if self.mode_keeping_transition {
-                response::ModeReport::CanNotKeepMode(self.mgm_modes.map(|info| info.mode))
-            } else {
-                response::ModeReport::SetModeTimeout(self.mgm_modes.map(|info| info.mode))
-            };
-            self.handle_mode_transition_failure(report);
-        }
-    }
-
-    pub fn handle_mode_reached(&mut self, success: bool) {
-        let tc_commander = self.mode_helper.finish(success);
-        self.announce_mode();
-        if tc_commander.is_some() {
-            self.send_telemetry(tc_commander, response::Response::Ok);
-        }
-        self.parent_queues
-            .report_tx
-            .send(response::ModeReport::Mode(self.mode_helper.current))
-            .unwrap();
-    }
-
-    pub fn handle_mode_transition_failure(&mut self, report: response::ModeReport) {
-        if self.mode_helper.tc_commander.is_some() {
-            self.send_telemetry(
-                self.mode_helper.tc_commander,
-                response::Response::Mode(response::ModeReport::SetModeTimeout(
-                    self.mgm_modes.map(|info| info.mode),
-                )),
-            );
-        }
-        self.parent_queues.report_tx.send(report).unwrap();
-        self.mode_helper.finish(false);
-    }
-
-    pub fn command_children(&self, mode: DeviceMode) {
-        for tx in &self.children_queues.request_tx_queues {
-            tx.send(models::mgm::request::ModeRequest::SetMode(mode))
-                .unwrap();
-        }
-    }
-
-    pub fn start_transition(
-        &mut self,
-        mode_keeping: bool,
-        target: AssemblyMode,
-        tc_id: Option<CcsdsPacketIdAndPsc>,
-    ) {
-        self.mode_keeping_transition = mode_keeping;
-        self.mode_helper.tc_commander = tc_id;
-        self.mgm_modes
-            .iter_mut()
-            .for_each(|m| m.reply_received = false);
-        self.mode_helper.start(target);
-    }
-
-    fn announce_mode(&self) {
-        // TODO: Event?
-        log::info!(
-            "{:?} announcing mode: {:?}",
-            Self::ID,
-            self.mode_helper.current
-        );
-    }
-
-    #[inline]
-    pub fn mode(&self) -> AssemblyMode {
-        self.mode_helper.current
-    }
-
-    #[inline]
-    #[cfg(test)]
-    fn mode_transition_active(&self) -> bool {
-        self.mode_helper.transition_active()
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use std::sync::mpsc::TryRecvError;
-
-    use arbitrary_int::u11;
-    use models::{
-        Apid, Message, MessageType, TcHeader,
-        ccsds::{CcsdsTcPacketOwned, CcsdsTmPacketOwned},
-        mgm_assembly,
-    };
-    use satrs::spacepackets::SpacePacketHeader;
-
-    use super::*;
-
-    pub struct Testbench {
-        subsystem_req_tx: mpsc::SyncSender<request::ModeRequest>,
-        subsystem_report_rx: mpsc::Receiver<response::ModeReport>,
-        mgm_request_rx: [mpsc::Receiver<models::mgm::request::ModeRequest>; 2],
-        mgm_report_tx: [mpsc::SyncSender<models::mgm::response::ModeResponse>; 2],
-        tc_tx: mpsc::SyncSender<CcsdsTcPacketOwned>,
-        tm_rx: mpsc::Receiver<CcsdsTmPacketOwned>,
-        assembly: Assembly,
-    }
-
-    impl Testbench {
-        pub fn new() -> Self {
-            let (subsystem_req_tx, subsystem_req_rx) = mpsc::sync_channel(5);
-            let (subsystem_report_tx, subsystem_report_rx) = mpsc::sync_channel(5);
-
-            let (mgm_0_mode_request_tx, mgm_0_mode_request_rx) = mpsc::sync_channel(5);
-            let (mgm_1_mode_request_tx, mgm_1_mode_request_rx) = mpsc::sync_channel(5);
-            let (mgm_0_mode_report_tx, mgm_0_mode_report_rx) = mpsc::sync_channel(5);
-            let (mgm_1_mode_report_tx, mgm_1_mode_report_rx) = mpsc::sync_channel(5);
-
-            let (tc_tx, tc_rx) = mpsc::sync_channel(5);
-            let (tm_tx, tm_rx) = mpsc::sync_channel(5);
-
-            Self {
-                subsystem_req_tx,
-                subsystem_report_rx,
-                mgm_request_rx: [mgm_0_mode_request_rx, mgm_1_mode_request_rx],
-                mgm_report_tx: [mgm_0_mode_report_tx, mgm_1_mode_report_tx],
-                tc_tx,
-                tm_rx,
-                assembly: Assembly::new(
-                    ParentQueueHelper {
-                        request_rx: subsystem_req_rx,
-                        report_tx: subsystem_report_tx,
-                    },
-                    ChildrenQueueHelper {
-                        request_tx_queues: [mgm_0_mode_request_tx, mgm_1_mode_request_tx],
-                        report_rx_queues: [mgm_0_mode_report_rx, mgm_1_mode_report_rx],
-                    },
-                    TmtcQueues { tc_rx, tm_tx },
-                    Duration::from_millis(20),
-                ),
-            }
-        }
-
-        pub fn assert_all_queues_empty(&self) {
-            assert!(
-                matches!(self.tm_rx.try_recv().unwrap_err(), TryRecvError::Empty),
-                "TM queue not empty"
-            );
-            assert!(
-                matches!(
-                    self.subsystem_report_rx.try_recv().unwrap_err(),
-                    TryRecvError::Empty
-                ),
-                "subsystem report queue not empty"
-            );
-            for rx in self.mgm_request_rx.iter() {
-                assert!(
-                    matches!(rx.try_recv().unwrap_err(), TryRecvError::Empty),
-                    "mgm request queue not empty"
-                )
-            }
-        }
-    }
-
-    pub fn create_request_tc(
-        request: models::mgm_assembly::request::Request,
-    ) -> models::ccsds::CcsdsTcPacketOwned {
-        models::ccsds::CcsdsTcPacketOwned::new_with_request(
-            SpacePacketHeader::new_from_apid(u11::new(Apid::Acs as u16)),
-            TcHeader::new(Assembly::ID, request.message_type()),
-            request,
-        )
-    }
-
-    #[test]
-    fn basic_test() {
-        let mut tb = Testbench::new();
-        tb.assert_all_queues_empty();
-        tb.assembly.periodic_operation();
-        tb.assert_all_queues_empty();
-        assert_eq!(tb.assembly.mode(), AssemblyMode::NoModeKeeping);
-    }
-
-    #[test]
-    fn test_tc_commanded_transition() {
-        let mut tb = Testbench::new();
-        tb.tc_tx
-            .send(create_request_tc(mgm_assembly::request::Request::Mode(
-                request::ModeRequest::SetMode(AssemblyMode::Device(DeviceMode::Normal)),
-            )))
-            .unwrap();
-        tb.assembly.periodic_operation();
-        assert!(tb.assembly.mode_transition_active());
-
-        for rx in tb.mgm_request_rx.iter() {
-            let request = rx.try_recv().unwrap();
-            assert_eq!(
-                request,
-                models::mgm::request::ModeRequest::SetMode(DeviceMode::Normal)
-            );
-        }
-
-        // Confirm the mode is set.
-        for tx in tb.mgm_report_tx.iter() {
-            tx.send(models::mgm::response::ModeResponse::Mode(
-                DeviceMode::Normal,
-            ))
-            .unwrap();
-        }
-
-        tb.assembly.periodic_operation();
-        assert!(!tb.assembly.mode_transition_active());
-        assert_eq!(tb.assembly.mode(), AssemblyMode::Device(DeviceMode::Normal));
-
-        let response = tb.tm_rx.try_recv().unwrap();
-        assert_eq!(response.tm_header.sender_id, Assembly::ID);
-        assert_eq!(response.tm_header.message_type, MessageType::Verification);
-        let response: response::Response = postcard::from_bytes(&response.payload).unwrap();
-        assert_eq!(response, response::Response::Ok);
-    }
-
-    #[test]
-    fn test_parent_commanded_transition() {
-        let mut tb = Testbench::new();
-        tb.subsystem_req_tx
-            .send(request::ModeRequest::SetMode(AssemblyMode::Device(
-                DeviceMode::Normal,
-            )))
-            .unwrap();
-        tb.assembly.periodic_operation();
-        assert!(tb.assembly.mode_transition_active());
-
-        for rx in tb.mgm_request_rx.iter() {
-            let request = rx.try_recv().unwrap();
-            assert_eq!(
-                request,
-                models::mgm::request::ModeRequest::SetMode(DeviceMode::Normal)
-            );
-        }
-
-        // Confirm the mode is set.
-        for tx in tb.mgm_report_tx.iter() {
-            tx.send(models::mgm::response::ModeResponse::Mode(
-                DeviceMode::Normal,
-            ))
-            .unwrap();
-        }
-
-        tb.assembly.periodic_operation();
-        assert!(!tb.assembly.mode_transition_active());
-        assert_eq!(tb.assembly.mode(), AssemblyMode::Device(DeviceMode::Normal));
-
-        let report = tb.subsystem_report_rx.try_recv().unwrap();
-        assert_eq!(
-            report,
-            response::ModeReport::Mode(AssemblyMode::Device(DeviceMode::Normal))
-        );
-    }
-
-    #[test]
-    fn test_one_mgm_is_sufficient() {
-        let mut tb = Testbench::new();
-        tb.subsystem_req_tx
-            .send(request::ModeRequest::SetMode(AssemblyMode::Device(
-                DeviceMode::Normal,
-            )))
-            .unwrap();
-        tb.assembly.periodic_operation();
-        assert!(tb.assembly.mode_transition_active());
-
-        for rx in tb.mgm_request_rx.iter() {
-            let request = rx.try_recv().unwrap();
-            assert_eq!(
-                request,
-                models::mgm::request::ModeRequest::SetMode(DeviceMode::Normal)
-            );
-        }
-
-        // One device is sufficient.
-        tb.mgm_report_tx[0]
-            .send(models::mgm::response::ModeResponse::Mode(
-                DeviceMode::Normal,
-            ))
-            .unwrap();
-        tb.mgm_report_tx[1]
-            .send(models::mgm::response::ModeResponse::Mode(DeviceMode::Off))
-            .unwrap();
-
-        tb.assembly.periodic_operation();
-        assert!(!tb.assembly.mode_transition_active());
-        assert_eq!(tb.assembly.mode(), AssemblyMode::Device(DeviceMode::Normal));
-
-        let report = tb.subsystem_report_rx.try_recv().unwrap();
-        assert_eq!(
-            report,
-            response::ModeReport::Mode(AssemblyMode::Device(DeviceMode::Normal))
-        );
-    }
-
-    #[test]
-    fn test_mode_commanding_fails() {
-        let mut tb = Testbench::new();
-        tb.subsystem_req_tx
-            .send(request::ModeRequest::SetMode(AssemblyMode::Device(
-                DeviceMode::Normal,
-            )))
-            .unwrap();
-        tb.assembly.periodic_operation();
-        assert!(tb.assembly.mode_transition_active());
-
-        for rx in tb.mgm_request_rx.iter() {
-            let request = rx.try_recv().unwrap();
-            assert_eq!(
-                request,
-                models::mgm::request::ModeRequest::SetMode(DeviceMode::Normal)
-            );
-        }
-
-        // Confirm the mode is set.
-        for tx in tb.mgm_report_tx.iter() {
-            tx.send(models::mgm::response::ModeResponse::Mode(DeviceMode::Off))
-                .unwrap();
-        }
-
-        tb.assembly.periodic_operation();
-        assert!(!tb.assembly.mode_transition_active());
-        assert_eq!(tb.assembly.mode(), AssemblyMode::NoModeKeeping);
-
-        let report = tb.subsystem_report_rx.try_recv().unwrap();
-        assert_eq!(
-            report,
-            response::ModeReport::WrongMode([Some(DeviceMode::Off), Some(DeviceMode::Off)])
-        );
-    }
-
-    #[test]
-    fn test_mode_keeping_fails() {
-        let mut tb = Testbench::new();
-        tb.subsystem_req_tx
-            .send(request::ModeRequest::SetMode(AssemblyMode::Device(
-                DeviceMode::Normal,
-            )))
-            .unwrap();
-        tb.assembly.periodic_operation();
-        assert!(tb.assembly.mode_transition_active());
-
-        for rx in tb.mgm_request_rx.iter() {
-            let request = rx.try_recv().unwrap();
-            assert_eq!(
-                request,
-                models::mgm::request::ModeRequest::SetMode(DeviceMode::Normal)
-            );
-        }
-
-        // Confirm the mode is set.
-        for tx in tb.mgm_report_tx.iter() {
-            tx.send(models::mgm::response::ModeResponse::Mode(
-                DeviceMode::Normal,
-            ))
-            .unwrap();
-        }
-
-        tb.assembly.periodic_operation();
-        assert!(!tb.assembly.mode_transition_active());
-        assert_eq!(tb.assembly.mode(), AssemblyMode::Device(DeviceMode::Normal));
-
-        let report = tb.subsystem_report_rx.try_recv().unwrap();
-        assert_eq!(
-            report,
-            response::ModeReport::Mode(AssemblyMode::Device(DeviceMode::Normal))
-        );
-
-        for tx in tb.mgm_report_tx.iter() {
-            tx.send(models::mgm::response::ModeResponse::Mode(DeviceMode::Off))
-                .unwrap();
-        }
-        // This should start mode keeping.
-        tb.assembly.periodic_operation();
-        assert!(tb.assembly.mode_transition_active());
-
-        for rx in tb.mgm_request_rx.iter() {
-            let request = rx.try_recv().unwrap();
-            assert_eq!(
-                request,
-                models::mgm::request::ModeRequest::SetMode(DeviceMode::Normal)
-            );
-        }
-
-        // Let the mode keeping fail.
-        for tx in tb.mgm_report_tx.iter() {
-            tx.send(models::mgm::response::ModeResponse::Mode(DeviceMode::Off))
-                .unwrap();
-        }
-        tb.assembly.periodic_operation();
-        let report = tb.subsystem_report_rx.try_recv().unwrap();
-        assert_eq!(
-            report,
-            response::ModeReport::CanNotKeepMode([Some(DeviceMode::Off), Some(DeviceMode::Off)])
-        );
-    }
-}

satrs-example/src/acs/mod.rs

@@ -1,6 +1,4 @@
+pub mod assembly;
 pub mod ctrl;
-
 pub mod mgm;
-pub mod mgm_assembly;
-
 pub mod subsystem;

satrs-example/src/bin/simpleclient.rs

@@ -0,0 +1,79 @@
+use satrs::pus::verification::RequestId;
+use satrs::spacepackets::ecss::tc::PusTcCreator;
+use satrs::spacepackets::ecss::tm::PusTmReader;
+use satrs::{spacepackets::ecss::PusPacket, spacepackets::SpHeader};
+use satrs_example::config::{OBSW_SERVER_ADDR, SERVER_PORT};
+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 pus_tc = PusTcCreator::new_simple(SpHeader::new_from_apid(0x02), 17, 1, &[], 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)
+        .unwrap_or_else(|_| panic!("Sending to {addr:?} failed"));
+    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 = PusTmReader::new(&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_empty() {
+                        println!("Invalid verification TM, no source data");
+                    }
+                    let src_data = pus_tm.source_data();
+                    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/test.rs

@@ -0,0 +1,66 @@
+#![allow(dead_code)]
+
+use crossbeam_channel::{bounded, Receiver, Sender};
+use std::sync::atomic::{AtomicU16, Ordering};
+use std::thread;
+use zerocopy::{FromBytes, Immutable, IntoBytes, 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, IntoBytes, Immutable, 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();
+    //let mut max_val: u16 = u16::MAX;
+    //max_val += 1;
+    //println!("Max val: {}", max_val);
+    let atomic_u16: AtomicU16 = AtomicU16::new(u16::MAX);
+    atomic_u16.fetch_add(1, Ordering::SeqCst);
+    println!(
+        "atomic after overflow: {}",
+        atomic_u16.load(Ordering::SeqCst)
+    );
+}

satrs-example/src/ccsds.rs

@@ -1,34 +0,0 @@
-use arbitrary_int::u11;
-use models::{Apid, ComponentId, Message, TmHeader, ccsds::CcsdsTmPacketOwned};
-use satrs::spacepackets::{
-    CcsdsPacketIdAndPsc, SpHeader,
-    time::{StdTimestampError, cds::CdsTime},
-};
-use serde::Serialize;
-
-#[derive(Debug, thiserror::Error)]
-pub enum CcsdsTmCreationError {
-    #[error("postcard error: {0}")]
-    Postcard(#[from] postcard::Error),
-    #[error("timestamp error: {0}")]
-    Time(#[from] StdTimestampError),
-}
-
-pub fn pack_ccsds_tm_packet_for_now(
-    sender_id: ComponentId,
-    tc_id: Option<CcsdsPacketIdAndPsc>,
-    payload: &(impl Serialize + Message),
-) -> Result<CcsdsTmPacketOwned, CcsdsTmCreationError> {
-    let now = CdsTime::now_with_u16_days()?;
-    let sp_header = SpHeader::new_from_apid(u11::new(Apid::Tmtc as u16));
-    let tm_header = TmHeader::new(
-        sender_id,
-        ComponentId::Ground,
-        payload.message_type(),
-        tc_id,
-        &now,
-    );
-    Ok(CcsdsTmPacketOwned::new_with_serde_payload(
-        sp_header, &tm_header, payload,
-    )?)
-}

satrs-example/src/config.rs

@@ -1,4 +1,3 @@
-use arbitrary_int::u11;
 use lazy_static::lazy_static;
 use satrs::{
     res_code::ResultU16,
@@ -7,10 +6,13 @@ use satrs::{
 use satrs_mib::res_code::ResultU16Info;
 use satrs_mib::resultcode;
 use std::{collections::HashSet, net::Ipv4Addr};
-use strum::IntoEnumIterator as _;
+use strum::IntoEnumIterator;
 
 use num_enum::{IntoPrimitive, TryFromPrimitive};
-use satrs::pool::{StaticMemoryPool, StaticPoolConfig};
+use satrs::{
+    events::{EventU32TypedSev, SeverityInfo},
+    pool::{StaticMemoryPool, StaticPoolConfig},
+};
 
 #[derive(Copy, Clone, PartialEq, Eq, Debug, TryFromPrimitive, IntoPrimitive)]
 #[repr(u8)]
@@ -36,17 +38,19 @@ pub enum GroupId {
 pub const OBSW_SERVER_ADDR: Ipv4Addr = Ipv4Addr::UNSPECIFIED;
 pub const SERVER_PORT: u16 = 7301;
 
+pub const TEST_EVENT: EventU32TypedSev<SeverityInfo> = EventU32TypedSev::<SeverityInfo>::new(0, 0);
+
 lazy_static! {
     pub static ref PACKET_ID_VALIDATOR: HashSet<PacketId> = {
         let mut set = HashSet::new();
-        for id in models::Apid::iter() {
-            set.insert(PacketId::new(PacketType::Tc, true, u11::new(id as u16)));
+        for id in crate::ids::Apid::iter() {
+            set.insert(PacketId::new(PacketType::Tc, true, id as u16));
         }
         set
     };
     pub static ref APID_VALIDATOR: HashSet<u16> = {
         let mut set = HashSet::new();
-        for id in models::Apid::iter() {
+        for id in crate::ids::Apid::iter() {
             set.insert(id as u16);
         }
         set
@@ -169,7 +173,7 @@ pub mod pool {
 
 pub mod tasks {
     pub const FREQ_MS_UDP_TMTC: u64 = 200;
-    pub const FREQ_MS_AOCS: u64 = 200;
-    pub const FREQ_MS_CONTROLLER: u64 = 200;
+    pub const FREQ_MS_AOCS: u64 = 500;
+    pub const FREQ_MS_PUS_STACK: u64 = 200;
     pub const SIM_CLIENT_IDLE_DELAY_MS: u64 = 5;
 }

satrs-example/src/control.rs

@@ -1,84 +0,0 @@
-use models::{
-    ComponentId,
-    ccsds::{CcsdsTcPacketOwned, CcsdsTmPacketOwned},
-    control,
-};
-use satrs::spacepackets::CcsdsPacketIdAndPsc;
-
-use crate::ccsds::pack_ccsds_tm_packet_for_now;
-
-pub struct Controller {
-    pub tc_rx: std::sync::mpsc::Receiver<CcsdsTcPacketOwned>,
-    pub tm_tx: std::sync::mpsc::SyncSender<CcsdsTmPacketOwned>,
-    pub event_ctrl_tx: std::sync::mpsc::SyncSender<control::Event>,
-}
-
-impl Controller {
-    pub fn new(
-        tc_rx: std::sync::mpsc::Receiver<CcsdsTcPacketOwned>,
-        tm_tx: std::sync::mpsc::SyncSender<CcsdsTmPacketOwned>,
-        event_ctrl_tx: std::sync::mpsc::SyncSender<control::Event>,
-    ) -> Self {
-        Self {
-            tc_rx,
-            tm_tx,
-            event_ctrl_tx,
-        }
-    }
-
-    pub fn periodic_operation(&mut self) {
-        self.handle_telecommands();
-    }
-
-    pub fn handle_telecommands(&mut self) {
-        loop {
-            match self.tc_rx.try_recv() {
-                Ok(packet) => {
-                    let tc_id = CcsdsPacketIdAndPsc::new_from_ccsds_packet(&packet.sp_header);
-                    match postcard::from_bytes::<control::request::Request>(&packet.payload) {
-                        Ok(request) => {
-                            log::info!(
-                                "received request {:?} with TC ID {:#010x}",
-                                request,
-                                tc_id.raw()
-                            );
-                            match request {
-                                control::request::Request::Ping => self
-                                    .send_telemetry(Some(tc_id), control::response::Response::Ok),
-                                control::request::Request::TestEvent => {
-                                    self.event_ctrl_tx.send(control::Event::TestEvent).unwrap()
-                                }
-                            }
-                        }
-                        Err(e) => {
-                            log::warn!("failed to deserialize request: {}", e);
-                        }
-                    }
-                }
-                Err(e) => match e {
-                    std::sync::mpsc::TryRecvError::Empty => break,
-                    std::sync::mpsc::TryRecvError::Disconnected => {
-                        log::warn!("packet sender disconnected")
-                    }
-                },
-            }
-        }
-    }
-
-    pub fn send_telemetry(
-        &self,
-        tc_id: Option<CcsdsPacketIdAndPsc>,
-        response: control::response::Response,
-    ) {
-        match pack_ccsds_tm_packet_for_now(ComponentId::Controller, tc_id, &response) {
-            Ok(packet) => {
-                if let Err(e) = self.tm_tx.send(packet) {
-                    log::warn!("failed to send TM packet: {}", e);
-                }
-            }
-            Err(e) => {
-                log::warn!("failed to pack TM packet: {}", e);
-            }
-        }
-    }
-}

satrs-example/src/eps/mod.rs

@@ -1,15 +1,16 @@
 use derive_new::new;
-use models::pcdu::{SwitchId, SwitchRequest, SwitchState, SwitchStateBinary};
 use std::{cell::RefCell, collections::VecDeque, sync::mpsc, time::Duration};
 
 use satrs::{
+    power::{
+        PowerSwitchInfo, PowerSwitcherCommandSender, SwitchRequest, SwitchState, SwitchStateBinary,
+    },
     queue::GenericSendError,
     request::{GenericMessage, MessageMetadata},
 };
+use satrs_minisim::eps::{PcduSwitch, SwitchMapWrapper};
 use thiserror::Error;
 
-use crate::eps::pcdu::SwitchMapWrapper;
-
 use self::pcdu::SharedSwitchSet;
 
 pub mod pcdu;
@@ -21,7 +22,6 @@ pub struct PowerSwitchHelper {
 }
 
 #[derive(Debug, Error, Copy, Clone, PartialEq, Eq)]
-#[allow(dead_code)]
 pub enum SwitchCommandingError {
     #[error("send error: {0}")]
     Send(#[from] GenericSendError),
@@ -31,72 +31,18 @@ pub enum SwitchCommandingError {
 pub enum SwitchInfoError {
     /// This is a configuration error which should not occur.
     #[error("switch ID not in map")]
-    SwitchIdNotInMap(SwitchId),
+    SwitchIdNotInMap(PcduSwitch),
     #[error("switch set invalid")]
     SwitchSetInvalid,
 }
 
-impl PowerSwitchHelper {
-    pub fn send_switch_on_cmd(
-        &self,
-        requestor_info: satrs::request::MessageMetadata,
-        switch_id: SwitchId,
-    ) -> Result<(), GenericSendError> {
-        self.switcher_tx.send(GenericMessage::new(
-            requestor_info,
-            SwitchRequest::new(switch_id, SwitchStateBinary::On),
-        ))?;
-        Ok(())
-    }
-
-    #[allow(dead_code)]
-    pub fn send_switch_off_cmd(
-        &self,
-        requestor_info: satrs::request::MessageMetadata,
-        switch_id: SwitchId,
-    ) -> Result<(), GenericSendError> {
-        self.switcher_tx.send(GenericMessage::new(
-            requestor_info,
-            SwitchRequest::new(switch_id, SwitchStateBinary::Off),
-        ))?;
-        Ok(())
-    }
-
-    pub fn switch_state(&self, switch_id: SwitchId) -> Result<SwitchState, SwitchInfoError> {
-        let switch_set = self
-            .shared_switch_set
-            .lock()
-            .expect("failed to lock switch set");
-        if !switch_set.valid {
-            return Err(SwitchInfoError::SwitchSetInvalid);
-        }
-
-        if let Some(state) = switch_set.switch_map.get(&switch_id) {
-            return Ok(*state);
-        }
-        Err(SwitchInfoError::SwitchIdNotInMap(switch_id))
-    }
-
-    #[allow(dead_code)]
-    fn switch_delay_ms(&self) -> Duration {
-        // Here, we could set device specific switch delays theoretically. Set it to this value
-        // for now.
-        Duration::from_millis(1000)
-    }
-
-    pub fn is_switch_on(&self, switch_id: SwitchId) -> bool {
-        if let Ok(state) = self.switch_state(switch_id) {
-            state == SwitchState::On
-        } else {
-            false
-        }
-    }
-}
-/*
-impl PowerSwitchInfo<SwitchId> for PowerSwitchHelper {
+impl PowerSwitchInfo<PcduSwitch> for PowerSwitchHelper {
     type Error = SwitchInfoError;
 
-    fn switch_state(&self, switch_id: SwitchId) -> Result<SwitchState, Self::Error> {
+    fn switch_state(
+        &self,
+        switch_id: PcduSwitch,
+    ) -> Result<satrs::power::SwitchState, Self::Error> {
         let switch_set = self
             .shared_switch_set
             .lock()
@@ -117,51 +63,43 @@ impl PowerSwitchInfo<SwitchId> for PowerSwitchHelper {
         Duration::from_millis(1000)
     }
 }
-*/
 
-/*
-impl PowerSwitcherCommandSender<SwitchId> for PowerSwitchHelper {
+impl PowerSwitcherCommandSender<PcduSwitch> for PowerSwitchHelper {
     type Error = SwitchCommandingError;
 
     fn send_switch_on_cmd(
         &self,
         requestor_info: satrs::request::MessageMetadata,
-        switch_id: SwitchId,
+        switch_id: PcduSwitch,
     ) -> Result<(), Self::Error> {
-        self.switcher_tx.send(GenericMessage::new(
-            requestor_info,
-            SwitchRequest::new(switch_id, SwitchStateBinary::On),
-        ));
+        self.switcher_tx
+            .send_switch_on_cmd(requestor_info, switch_id)?;
         Ok(())
     }
 
     fn send_switch_off_cmd(
         &self,
         requestor_info: satrs::request::MessageMetadata,
-        switch_id: SwitchId,
+        switch_id: PcduSwitch,
     ) -> Result<(), Self::Error> {
-        self.switcher_tx.send(GenericMessage::new(
-            requestor_info,
-            SwitchRequest::new(switch_id, SwitchStateBinary::Off),
-        ));
+        self.switcher_tx
+            .send_switch_off_cmd(requestor_info, switch_id)?;
         Ok(())
     }
 }
-*/
 
 #[allow(dead_code)]
 #[derive(new)]
 pub struct SwitchRequestInfo {
     pub requestor_info: MessageMetadata,
-    pub switch_id: SwitchId,
-    pub target_state: SwitchStateBinary,
+    pub switch_id: PcduSwitch,
+    pub target_state: satrs::power::SwitchStateBinary,
 }
 
 // Test switch helper which can be used for unittests.
-#[allow(dead_code)]
 pub struct TestSwitchHelper {
     pub switch_requests: RefCell<VecDeque<SwitchRequestInfo>>,
-    pub switch_info_requests: RefCell<VecDeque<SwitchId>>,
+    pub switch_info_requests: RefCell<VecDeque<PcduSwitch>>,
     #[allow(dead_code)]
     pub switch_delay_request_count: u32,
     pub next_switch_delay: Duration,
@@ -182,11 +120,13 @@ impl Default for TestSwitchHelper {
     }
 }
 
-/*
-impl PowerSwitchInfo<SwitchId> for TestSwitchHelper {
+impl PowerSwitchInfo<PcduSwitch> for TestSwitchHelper {
     type Error = SwitchInfoError;
 
-    fn switch_state(&self, switch_id: SwitchId) -> Result<satrs::power::SwitchState, Self::Error> {
+    fn switch_state(
+        &self,
+        switch_id: PcduSwitch,
+    ) -> Result<satrs::power::SwitchState, Self::Error> {
         let mut switch_info_requests_mut = self.switch_info_requests.borrow_mut();
         switch_info_requests_mut.push_back(switch_id);
         if !self.switch_map_valid {
@@ -204,13 +144,13 @@ impl PowerSwitchInfo<SwitchId> for TestSwitchHelper {
     }
 }
 
-impl PowerSwitcherCommandSender<SwitchId> for TestSwitchHelper {
+impl PowerSwitcherCommandSender<PcduSwitch> for TestSwitchHelper {
     type Error = SwitchCommandingError;
 
     fn send_switch_on_cmd(
         &self,
         requestor_info: MessageMetadata,
-        switch_id: SwitchId,
+        switch_id: PcduSwitch,
     ) -> Result<(), Self::Error> {
         let mut switch_requests_mut = self.switch_requests.borrow_mut();
         switch_requests_mut.push_back(SwitchRequestInfo {
@@ -230,7 +170,7 @@ impl PowerSwitcherCommandSender<SwitchId> for TestSwitchHelper {
     fn send_switch_off_cmd(
         &self,
         requestor_info: MessageMetadata,
-        switch_id: SwitchId,
+        switch_id: PcduSwitch,
     ) -> Result<(), Self::Error> {
         let mut switch_requests_mut = self.switch_requests.borrow_mut();
         switch_requests_mut.push_back(SwitchRequestInfo {
@@ -247,12 +187,11 @@ impl PowerSwitcherCommandSender<SwitchId> for TestSwitchHelper {
         Ok(())
     }
 }
-*/
 
 #[allow(dead_code)]
 impl TestSwitchHelper {
     // Helper function which can be used to force a switch to another state for test purposes.
-    pub fn set_switch_state(&mut self, switch: SwitchId, state: SwitchState) {
+    pub fn set_switch_state(&mut self, switch: PcduSwitch, state: SwitchState) {
         self.switch_map.get_mut().0.insert(switch, state);
     }
 }

satrs-example/src/eps/pcdu.rs

@@ -1,109 +1,43 @@
 use std::{
     cell::RefCell,
-    collections::{HashMap, VecDeque},
-    sync::{Arc, Mutex, mpsc},
+    collections::VecDeque,
+    sync::{mpsc, Arc, Mutex},
 };
 
 use derive_new::new;
-use models::{
-    ComponentId, DeviceMode,
-    ccsds::{CcsdsTcPacketOwned, CcsdsTmPacketOwned},
-    pcdu::{
-        self, SwitchId, SwitchMapBinary, SwitchMapBinaryWrapper, SwitchRequest, SwitchState,
-        SwitchStateBinary, SwitchesBitfield,
-    },
-};
 use num_enum::{IntoPrimitive, TryFromPrimitive};
-use satrs::{request::GenericMessage, spacepackets::CcsdsPacketIdAndPsc};
-use satrs_example::TimestampHelper;
+use satrs::{
+    hk::{HkRequest, HkRequestVariant},
+    mode::{
+        ModeAndSubmode, ModeError, ModeProvider, ModeReply, ModeRequestHandler,
+        ModeRequestHandlerMpscBounded,
+    },
+    mode_tree::{ModeChild, ModeNode},
+    power::SwitchRequest,
+    pus::{EcssTmSender, PusTmVariant},
+    queue::GenericSendError,
+    request::{GenericMessage, MessageMetadata, UniqueApidTargetId},
+    spacepackets::ByteConversionError,
+};
+use satrs_example::{
+    config::components::NO_SENDER,
+    ids::{eps::PCDU, generic_pus::PUS_MODE},
+    DeviceMode, TimestampHelper,
+};
 use satrs_minisim::{
+    eps::{
+        PcduReply, PcduRequest, PcduSwitch, SwitchMap, SwitchMapBinaryWrapper, SwitchMapWrapper,
+    },
     SerializableSimMsgPayload, SimReply, SimRequest,
-    eps::{PcduReply, PcduRequest},
 };
 use serde::{Deserialize, Serialize};
-use strum::IntoEnumIterator as _;
 
-use crate::ccsds::pack_ccsds_tm_packet_for_now;
-
-#[derive(Clone, PartialEq, Eq, Serialize, Deserialize)]
-pub struct SwitchSet {
-    pub valid: bool,
-    pub switch_map: SwitchMap,
-}
-
-impl SwitchSet {
-    pub fn new(switch_map: SwitchMap) -> Self {
-        Self {
-            valid: true,
-            switch_map,
-        }
-    }
-
-    pub fn new_with_init_switches_unknown() -> Self {
-        let wrapper = SwitchMapWrapper::default();
-        Self::new(wrapper.0)
-    }
-
-    pub fn as_bitfield(&self) -> Option<SwitchesBitfield> {
-        for entry in SwitchId::iter() {
-            if !self.switch_map.contains_key(&entry) {
-                return None;
-            }
-        }
-        Some(
-            SwitchesBitfield::builder()
-                .with_magnetorquer(*self.switch_map.get(&SwitchId::Mgt).unwrap() == SwitchState::On)
-                .with_mgm1(*self.switch_map.get(&SwitchId::Mgm1).unwrap() == SwitchState::On)
-                .with_mgm0(*self.switch_map.get(&SwitchId::Mgm0).unwrap() == SwitchState::On)
-                .build(),
-        )
-    }
-
-    #[allow(dead_code)]
-    pub fn set_switch_state(&mut self, switch_id: SwitchId, state: SwitchState) -> bool {
-        if !self.switch_map.contains_key(&switch_id) {
-            return false;
-        }
-        *self.switch_map.get_mut(&switch_id).unwrap() = state;
-        true
-    }
-}
-
-pub type SwitchMap = HashMap<SwitchId, SwitchState>;
-
-pub struct SwitchMapWrapper(pub SwitchMap);
-
-impl Default for SwitchMapWrapper {
-    fn default() -> Self {
-        let mut switch_map = SwitchMap::default();
-        for entry in SwitchId::iter() {
-            switch_map.insert(entry, SwitchState::Unknown);
-        }
-        Self(switch_map)
-    }
-}
-
-impl SwitchMapWrapper {
-    #[allow(dead_code)]
-    pub fn new_with_init_switches_off() -> Self {
-        let mut switch_map = SwitchMap::default();
-        for entry in SwitchId::iter() {
-            switch_map.insert(entry, SwitchState::Off);
-        }
-        Self(switch_map)
-    }
-
-    pub fn from_binary_switch_map_ref(switch_map: &SwitchMapBinary) -> Self {
-        Self(
-            switch_map
-                .iter()
-                .map(|(key, value)| (*key, SwitchState::from(*value)))
-                .collect(),
-        )
-    }
-}
-
-pub type SharedSwitchSet = Arc<Mutex<SwitchSet>>;
+use crate::{
+    hk::PusHkHelper,
+    pus::hk::{HkReply, HkReplyVariant},
+    requests::CompositeRequest,
+    tmtc::sender::TmTcSender,
+};
 
 pub trait SerialInterface {
     type Error: core::fmt::Debug;
@@ -260,50 +194,49 @@ pub enum OpCode {
     PollAndRecvReplies = 1,
 }
 
+#[derive(Clone, PartialEq, Eq, Default, Serialize, Deserialize)]
+pub struct SwitchSet {
+    pub valid: bool,
+    pub switch_map: SwitchMap,
+}
+
+pub type SharedSwitchSet = Arc<Mutex<SwitchSet>>;
+
 /// Example PCDU device handler.
+#[derive(new)]
 #[allow(clippy::too_many_arguments)]
 pub struct PcduHandler<ComInterface: SerialInterface> {
+    id: UniqueApidTargetId,
     dev_str: &'static str,
+    mode_node: ModeRequestHandlerMpscBounded,
+    composite_request_rx: mpsc::Receiver<GenericMessage<CompositeRequest>>,
+    hk_reply_tx: mpsc::SyncSender<GenericMessage<HkReply>>,
     switch_request_rx: mpsc::Receiver<GenericMessage<SwitchRequest>>,
-    tc_rx: std::sync::mpsc::Receiver<CcsdsTcPacketOwned>,
-    tm_tx: mpsc::SyncSender<CcsdsTmPacketOwned>,
+    tm_sender: TmTcSender,
     pub com_interface: ComInterface,
     shared_switch_map: Arc<Mutex<SwitchSet>>,
-    mode: DeviceMode,
+    #[new(value = "PusHkHelper::new(id)")]
+    hk_helper: PusHkHelper,
+    #[new(value = "ModeAndSubmode::new(satrs_example::DeviceMode::Off as u32, 0)")]
+    mode_and_submode: ModeAndSubmode,
+    #[new(default)]
     stamp_helper: TimestampHelper,
+    #[new(value = "[0; 256]")]
+    tm_buf: [u8; 256],
 }
 
 impl<ComInterface: SerialInterface> PcduHandler<ComInterface> {
-    pub fn new(
-        tc_rx: std::sync::mpsc::Receiver<CcsdsTcPacketOwned>,
-        tm_tx: std::sync::mpsc::SyncSender<CcsdsTmPacketOwned>,
-        switch_request_rx: mpsc::Receiver<GenericMessage<SwitchRequest>>,
-        com_interface: ComInterface,
-        shared_switch_map: Arc<Mutex<SwitchSet>>,
-        init_mode: DeviceMode,
-    ) -> Self {
-        Self {
-            dev_str: "PCDU",
-            tc_rx,
-            switch_request_rx,
-            tm_tx,
-            com_interface,
-            shared_switch_map,
-            stamp_helper: TimestampHelper::default(),
-            // Start in normal mode by default. Assume that the PCDU itself is on by default.
-            mode: init_mode,
-        }
-    }
-
     pub fn periodic_operation(&mut self, op_code: OpCode) {
         match op_code {
             OpCode::RegularOp => {
                 self.stamp_helper.update_from_now();
                 // Handle requests.
-                self.handle_telecommands();
+                self.handle_composite_requests();
+                self.handle_mode_requests();
                 self.handle_switch_requests();
                 // Poll the switch states and/or telemetry regularly here.
-                if self.mode() == DeviceMode::Normal || self.mode() == DeviceMode::On {
+                if self.mode() == DeviceMode::Normal as u32 || self.mode() == DeviceMode::On as u32
+                {
                     self.handle_periodic_commands();
                 }
             }
@@ -313,122 +246,75 @@ impl<ComInterface: SerialInterface> PcduHandler<ComInterface> {
         }
     }
 
-    #[inline]
-    pub fn mode(&self) -> DeviceMode {
-        self.mode
-    }
-
-    pub fn handle_telecommands(&mut self) {
+    pub fn handle_composite_requests(&mut self) {
         loop {
-            match self.tc_rx.try_recv() {
-                Ok(packet) => {
-                    let tc_id = CcsdsPacketIdAndPsc::new_from_ccsds_packet(&packet.sp_header);
-                    match postcard::from_bytes::<pcdu::request::Request>(&packet.payload) {
-                        Ok(request) => {
-                            log::info!(
-                                "received request {:?} with TC ID {:#010x}",
-                                request,
-                                tc_id.raw()
-                            );
-                            match request {
-                                pcdu::request::Request::Ping => {
-                                    self.send_tm(Some(tc_id), pcdu::response::Response::Ok)
-                                }
-                                pcdu::request::Request::GetSwitches => self.send_tm(
-                                    Some(tc_id),
-                                    pcdu::response::Response::Switches(
-                                        self.shared_switch_map
-                                            .lock()
-                                            .unwrap()
-                                            .as_bitfield()
-                                            .expect("could not build switches response"),
-                                    ),
-                                ),
-                                pcdu::request::Request::EnableSwitches(switches) => {
-                                    self.handle_switches_bitfield_request(
-                                        switches,
-                                        SwitchStateBinary::On,
-                                    );
-                                }
-                                pcdu::request::Request::DisableSwitches(switches) => {
-                                    self.handle_switches_bitfield_request(
-                                        switches,
-                                        SwitchStateBinary::Off,
-                                    );
-                                }
-                                pcdu::request::Request::Mode(device_mode) => {
-                                    self.switch_mode(tc_id, device_mode)
-                                }
-                            }
-                        }
-                        Err(e) => {
-                            log::warn!("failed to deserialize request: {}", e);
-                        }
-                    }
-                }
-                Err(e) => match e {
-                    std::sync::mpsc::TryRecvError::Empty => break,
-                    std::sync::mpsc::TryRecvError::Disconnected => {
-                        log::warn!("packet sender disconnected")
+            match self.composite_request_rx.try_recv() {
+                Ok(ref msg) => match &msg.message {
+                    CompositeRequest::Hk(hk_request) => {
+                        self.handle_hk_request(&msg.requestor_info, hk_request)
                     }
+                    // TODO: This object does not have actions (yet).. Still send back completion failure
+                    // reply.
+                    CompositeRequest::Action(_action_req) => {}
                 },
-            }
-        }
-    }
 
-    pub fn handle_switches_bitfield_request(
-        &mut self,
-        switches: SwitchesBitfield,
-        state: SwitchStateBinary,
-    ) {
-        if switches.mgm0() {
-            self.handle_device_switching(SwitchId::Mgm0, state);
-        }
-        if switches.mgm1() {
-            self.handle_device_switching(SwitchId::Mgm1, state);
-        }
-        if switches.magnetorquer() {
-            self.handle_device_switching(SwitchId::Mgt, state);
-        }
-    }
-
-    pub fn send_tm(&self, tc_id: Option<CcsdsPacketIdAndPsc>, response: pcdu::response::Response) {
-        match pack_ccsds_tm_packet_for_now(ComponentId::EpsPcdu, tc_id, &response) {
-            Ok(packet) => {
-                if let Err(e) = self.tm_tx.send(packet) {
-                    log::warn!("failed to send TM packet: {}", e);
+                Err(e) => {
+                    if e != mpsc::TryRecvError::Empty {
+                        log::warn!(
+                            "{}: failed to receive composite request: {:?}",
+                            self.dev_str,
+                            e
+                        );
+                    } else {
+                        break;
+                    }
                 }
             }
-            Err(e) => {
-                log::warn!("failed to pack TM packet: {}", e);
-            }
         }
     }
 
-    fn switch_mode(&mut self, requestor: CcsdsPacketIdAndPsc, mode: DeviceMode) {
-        log::info!("{}: transitioning to mode {:?}", self.dev_str, mode);
-        self.mode = mode;
-        if self.mode() == DeviceMode::Off {
-            self.shared_switch_map.lock().unwrap().valid = false;
-        }
-        log::info!("{} announcing mode: {:?}", self.dev_str, self.mode);
-        self.send_telemetry(Some(requestor), pcdu::response::Response::Ok);
-    }
-
-    pub fn send_telemetry(
-        &self,
-        tc_id: Option<CcsdsPacketIdAndPsc>,
-        response: pcdu::response::Response,
-    ) {
-        match pack_ccsds_tm_packet_for_now(ComponentId::EpsPcdu, tc_id, &response) {
-            Ok(packet) => {
-                if let Err(e) = self.tm_tx.send(packet) {
-                    log::warn!("failed to send TM packet: {}", e);
+    pub fn handle_hk_request(&mut self, requestor_info: &MessageMetadata, hk_request: &HkRequest) {
+        match hk_request.variant {
+            HkRequestVariant::OneShot => {
+                if hk_request.unique_id == SetId::SwitcherSet as u32 {
+                    if let Ok(hk_tm) = self.hk_helper.generate_hk_report_packet(
+                        self.stamp_helper.stamp(),
+                        SetId::SwitcherSet as u32,
+                        &mut |hk_buf| {
+                            // Send TM down as JSON.
+                            let switch_map_snapshot = self
+                                .shared_switch_map
+                                .lock()
+                                .expect("failed to lock switch map")
+                                .clone();
+                            let switch_map_json = serde_json::to_string(&switch_map_snapshot)
+                                .expect("failed to serialize switch map");
+                            if switch_map_json.len() > hk_buf.len() {
+                                log::error!("switch map JSON too large for HK buffer");
+                                return Err(ByteConversionError::ToSliceTooSmall {
+                                    found: hk_buf.len(),
+                                    expected: switch_map_json.len(),
+                                });
+                            }
+                            Ok(switch_map_json.len())
+                        },
+                        &mut self.tm_buf,
+                    ) {
+                        self.tm_sender
+                            .send_tm(self.id.id(), PusTmVariant::Direct(hk_tm))
+                            .expect("failed to send HK TM");
+                        self.hk_reply_tx
+                            .send(GenericMessage::new(
+                                *requestor_info,
+                                HkReply::new(hk_request.unique_id, HkReplyVariant::Ack),
+                            ))
+                            .expect("failed to send HK reply");
+                    }
                 }
             }
-            Err(e) => {
-                log::warn!("failed to pack TM packet: {}", e);
-            }
+            HkRequestVariant::EnablePeriodic => todo!(),
+            HkRequestVariant::DisablePeriodic => todo!(),
+            HkRequestVariant::ModifyCollectionInterval(_) => todo!(),
         }
     }
 
@@ -440,7 +326,6 @@ impl<ComInterface: SerialInterface> PcduHandler<ComInterface> {
         }
     }
 
-    /*
     pub fn handle_mode_requests(&mut self) {
         loop {
             // TODO: Only allow one set mode request per cycle?
@@ -471,28 +356,23 @@ impl<ComInterface: SerialInterface> PcduHandler<ComInterface> {
             }
         }
     }
-    */
-
-    pub fn handle_device_switching(&mut self, switch_id: SwitchId, state: SwitchStateBinary) {
-        let pcdu_req = PcduRequest::SwitchDevice {
-            switch: switch_id,
-            state,
-        };
-        let pcdu_req_ser = serde_json::to_string(&pcdu_req).unwrap();
-        self.com_interface
-            .send(pcdu_req_ser.as_bytes())
-            .expect("failed to send switch request to PCDU");
-    }
 
     pub fn handle_switch_requests(&mut self) {
         loop {
             match self.switch_request_rx.try_recv() {
-                Ok(switch_req) => {
-                    self.handle_device_switching(
-                        switch_req.message.switch_id(),
-                        switch_req.message.target_state(),
-                    );
-                }
+                Ok(switch_req) => match PcduSwitch::try_from(switch_req.message.switch_id()) {
+                    Ok(pcdu_switch) => {
+                        let pcdu_req = PcduRequest::SwitchDevice {
+                            switch: pcdu_switch,
+                            state: switch_req.message.target_state(),
+                        };
+                        let pcdu_req_ser = serde_json::to_string(&pcdu_req).unwrap();
+                        self.com_interface
+                            .send(pcdu_req_ser.as_bytes())
+                            .expect("failed to send switch request to PCDU");
+                    }
+                    Err(e) => todo!("failed to convert switch ID {:?} to typed PCDU switch", e),
+                },
                 Err(e) => match e {
                     mpsc::TryRecvError::Empty => break,
                     mpsc::TryRecvError::Disconnected => {
@@ -521,38 +401,119 @@ impl<ComInterface: SerialInterface> PcduHandler<ComInterface> {
                 }
             }
         }) {
-            log::warn!("receiving PCDU replies failed: {e:?}");
+            log::warn!("receiving PCDU replies failed: {:?}", e);
         }
     }
 }
 
+impl<ComInterface: SerialInterface> ModeProvider for PcduHandler<ComInterface> {
+    fn mode_and_submode(&self) -> ModeAndSubmode {
+        self.mode_and_submode
+    }
+}
+
+impl<ComInterface: SerialInterface> ModeRequestHandler for PcduHandler<ComInterface> {
+    type Error = ModeError;
+    fn start_transition(
+        &mut self,
+        requestor: MessageMetadata,
+        mode_and_submode: ModeAndSubmode,
+        _forced: bool,
+    ) -> Result<(), satrs::mode::ModeError> {
+        log::info!(
+            "{}: transitioning to mode {:?}",
+            self.dev_str,
+            mode_and_submode
+        );
+        self.mode_and_submode = mode_and_submode;
+        if mode_and_submode.mode() == DeviceMode::Off as u32 {
+            self.shared_switch_map.lock().unwrap().valid = false;
+        }
+        self.handle_mode_reached(Some(requestor))?;
+        Ok(())
+    }
+
+    fn announce_mode(&self, _requestor_info: Option<MessageMetadata>, _recursive: bool) {
+        log::info!(
+            "{} announcing mode: {:?}",
+            self.dev_str,
+            self.mode_and_submode
+        );
+    }
+
+    fn handle_mode_reached(
+        &mut self,
+        requestor: Option<MessageMetadata>,
+    ) -> Result<(), Self::Error> {
+        self.announce_mode(requestor, false);
+        if let Some(requestor) = requestor {
+            if requestor.sender_id() == NO_SENDER {
+                return Ok(());
+            }
+            if requestor.sender_id() != PUS_MODE.id() {
+                log::warn!(
+                    "can not send back mode reply to sender {}",
+                    requestor.sender_id()
+                );
+            } else {
+                self.send_mode_reply(requestor, ModeReply::ModeReply(self.mode_and_submode()))?;
+            }
+        }
+        Ok(())
+    }
+
+    fn send_mode_reply(
+        &self,
+        requestor: MessageMetadata,
+        reply: ModeReply,
+    ) -> Result<(), Self::Error> {
+        if requestor.sender_id() != PUS_MODE.id() {
+            log::warn!(
+                "can not send back mode reply to sender {}",
+                requestor.sender_id()
+            );
+        }
+        self.mode_node
+            .send_mode_reply(requestor, reply)
+            .map_err(|_| GenericSendError::RxDisconnected)?;
+        Ok(())
+    }
+
+    fn handle_mode_info(
+        &mut self,
+        _requestor_info: MessageMetadata,
+        _info: ModeAndSubmode,
+    ) -> Result<(), Self::Error> {
+        Ok(())
+    }
+}
+
+impl<ComInterface: SerialInterface> ModeNode for PcduHandler<ComInterface> {
+    fn id(&self) -> satrs::ComponentId {
+        PCDU.into()
+    }
+}
+
+impl<ComInterface: SerialInterface> ModeChild for PcduHandler<ComInterface> {
+    type Sender = mpsc::SyncSender<GenericMessage<ModeReply>>;
+
+    fn add_mode_parent(&mut self, id: satrs::ComponentId, reply_sender: Self::Sender) {
+        self.mode_node.add_message_target(id, reply_sender);
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use std::sync::mpsc;
 
-    use arbitrary_int::u11;
-    use models::{
-        Apid, TcHeader,
-        pcdu::{SwitchMapBinary, SwitchStateBinary},
-    };
     use satrs::{
-        mode::{ModeReply, ModeRequest},
-        request::{GenericMessage, MessageMetadata},
-        spacepackets::SpacePacketHeader,
+        mode::ModeRequest, power::SwitchStateBinary, request::GenericMessage, tmtc::PacketAsVec,
     };
+    use satrs_example::ids::{self, Apid};
+    use satrs_minisim::eps::SwitchMapBinary;
 
     use super::*;
 
-    pub fn create_request_tc(
-        request: models::pcdu::request::Request,
-    ) -> models::ccsds::CcsdsTcPacketOwned {
-        models::ccsds::CcsdsTcPacketOwned::new_with_request(
-            SpacePacketHeader::new_from_apid(u11::new(Apid::Eps as u16)),
-            TcHeader::new(ComponentId::EpsPcdu, request.message_type()),
-            request,
-        )
-    }
-
     #[derive(Default)]
     pub struct SerialInterfaceTest {
         pub inner: SerialInterfaceDummy,
@@ -588,37 +549,47 @@ mod tests {
         }
     }
 
-    #[allow(dead_code)]
     pub struct PcduTestbench {
         pub mode_request_tx: mpsc::SyncSender<GenericMessage<ModeRequest>>,
+        pub mode_reply_rx_to_pus: mpsc::Receiver<GenericMessage<ModeReply>>,
         pub mode_reply_rx_to_parent: mpsc::Receiver<GenericMessage<ModeReply>>,
-        pub tc_tx: mpsc::SyncSender<CcsdsTcPacketOwned>,
-        pub tm_rx: mpsc::Receiver<CcsdsTmPacketOwned>,
+        pub composite_request_tx: mpsc::Sender<GenericMessage<CompositeRequest>>,
+        pub hk_reply_rx: mpsc::Receiver<GenericMessage<HkReply>>,
+        pub tm_rx: mpsc::Receiver<PacketAsVec>,
         pub switch_request_tx: mpsc::Sender<GenericMessage<SwitchRequest>>,
         pub handler: PcduHandler<SerialInterfaceTest>,
     }
 
     impl PcduTestbench {
         pub fn new() -> Self {
-            let (mode_request_tx, _mode_request_rx) = mpsc::sync_channel(5);
-            let (_mode_reply_tx_to_parent, mode_reply_rx_to_parent) = mpsc::sync_channel(5);
-            let (tc_tx, tc_rx) = mpsc::sync_channel(5);
-            let (tm_tx, tm_rx) = mpsc::sync_channel(5);
+            let (mode_request_tx, mode_request_rx) = mpsc::sync_channel(5);
+            let (mode_reply_tx_to_pus, mode_reply_rx_to_pus) = mpsc::sync_channel(5);
+            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 (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::new_with_init_switches_unknown()));
-            let handler = PcduHandler::new(
-                tc_rx,
-                tm_tx.clone(),
+            let shared_switch_map = Arc::new(Mutex::new(SwitchSet::default()));
+            let mut handler = PcduHandler::new(
+                UniqueApidTargetId::new(Apid::Eps as u16, 0),
+                "TEST_PCDU",
+                mode_node,
+                composite_request_rx,
+                hk_reply_tx,
                 switch_reqest_rx,
+                TmTcSender::Heap(tm_tx.clone()),
                 SerialInterfaceTest::default(),
                 shared_switch_map,
-                DeviceMode::Off,
             );
+            handler.add_mode_parent(ids::eps::SUBSYSTEM.into(), mode_reply_tx_to_parent);
+            handler.add_mode_parent(PUS_MODE.into(), mode_reply_tx_to_pus);
             Self {
                 mode_request_tx,
+                mode_reply_rx_to_pus,
                 mode_reply_rx_to_parent,
-                tc_tx,
+                composite_request_tx,
+                hk_reply_rx,
                 tm_rx,
                 switch_request_tx,
                 handler,
@@ -638,7 +609,7 @@ mod tests {
         pub fn verify_switch_req_was_sent(
             &self,
             expected_queue_len: usize,
-            switch_id: SwitchId,
+            switch_id: PcduSwitch,
             target_state: SwitchStateBinary,
         ) {
             // Check that there is now communication happening.
@@ -679,7 +650,11 @@ mod tests {
             testbench.handler.com_interface.reply_queue.borrow().len(),
             0
         );
-        assert_eq!(testbench.handler.mode(), DeviceMode::Off);
+        assert_eq!(
+            testbench.handler.mode_and_submode().mode(),
+            DeviceMode::Off as u32
+        );
+        assert_eq!(testbench.handler.mode_and_submode().submode(), 0_u16);
         testbench.handler.periodic_operation(OpCode::RegularOp);
         testbench
             .handler
@@ -690,27 +665,39 @@ mod tests {
             testbench.handler.com_interface.reply_queue.borrow().len(),
             0
         );
-        assert_eq!(testbench.handler.mode(), DeviceMode::Off);
+        assert_eq!(
+            testbench.handler.mode_and_submode().mode(),
+            DeviceMode::Off as u32
+        );
+        assert_eq!(testbench.handler.mode_and_submode().submode(), 0_u16);
     }
 
     #[test]
     fn test_normal_mode() {
         let mut testbench = PcduTestbench::new();
         testbench
-            .tc_tx
-            .send(create_request_tc(pcdu::request::Request::Mode(
-                DeviceMode::Normal,
-            )))
-            .unwrap();
+            .mode_request_tx
+            .send(GenericMessage::new(
+                MessageMetadata::new(0, PUS_MODE.id()),
+                ModeRequest::SetMode {
+                    mode_and_submode: ModeAndSubmode::new(DeviceMode::Normal as u32, 0),
+                    forced: false,
+                },
+            ))
+            .expect("failed to send mode request");
         let switch_map_shared = testbench.handler.shared_switch_map.lock().unwrap();
-        assert!(switch_map_shared.valid);
+        assert!(!switch_map_shared.valid);
         drop(switch_map_shared);
         testbench.handler.periodic_operation(OpCode::RegularOp);
         testbench
             .handler
             .periodic_operation(OpCode::PollAndRecvReplies);
         // Check correctness of mode.
-        assert_eq!(testbench.handler.mode(), DeviceMode::Normal);
+        assert_eq!(
+            testbench.handler.mode_and_submode().mode(),
+            DeviceMode::Normal as u32
+        );
+        assert_eq!(testbench.handler.mode_and_submode().submode(), 0);
 
         testbench.verify_switch_info_req_was_sent(1);
         testbench.verify_switch_reply_received(1, SwitchMapBinaryWrapper::default().0);
@@ -724,16 +711,20 @@ mod tests {
     fn test_switch_request_handling() {
         let mut testbench = PcduTestbench::new();
         testbench
-            .tc_tx
-            .send(create_request_tc(pcdu::request::Request::Mode(
-                DeviceMode::Normal,
-            )))
-            .unwrap();
+            .mode_request_tx
+            .send(GenericMessage::new(
+                MessageMetadata::new(0, PUS_MODE.id()),
+                ModeRequest::SetMode {
+                    mode_and_submode: ModeAndSubmode::new(DeviceMode::Normal as u32, 0),
+                    forced: false,
+                },
+            ))
+            .expect("failed to send mode request");
         testbench
             .switch_request_tx
             .send(GenericMessage::new(
-                MessageMetadata::new(0, ComponentId::AcsMgm0 as u32),
-                SwitchRequest::new(SwitchId::Mgm0, SwitchStateBinary::On),
+                MessageMetadata::new(0, ids::acs::MGM0.id()),
+                SwitchRequest::new(0, SwitchStateBinary::On),
             ))
             .expect("failed to send switch request");
         testbench.handler.periodic_operation(OpCode::RegularOp);
@@ -741,11 +732,11 @@ mod tests {
             .handler
             .periodic_operation(OpCode::PollAndRecvReplies);
 
-        testbench.verify_switch_req_was_sent(2, SwitchId::Mgm0, SwitchStateBinary::On);
+        testbench.verify_switch_req_was_sent(2, PcduSwitch::Mgm, SwitchStateBinary::On);
         testbench.verify_switch_info_req_was_sent(1);
         let mut switch_map = SwitchMapBinaryWrapper::default().0;
         *switch_map
-            .get_mut(&SwitchId::Mgm0)
+            .get_mut(&PcduSwitch::Mgm)
             .expect("switch state setting failed") = SwitchStateBinary::On;
         testbench.verify_switch_reply_received(1, switch_map);
 

satrs-example/src/event_manager.rs

@@ -1,35 +0,0 @@
-use models::{ComponentId, Event, Message, ccsds::CcsdsTmPacketOwned, control};
-
-use crate::ccsds::pack_ccsds_tm_packet_for_now;
-
-// TODO: We should add the capability to enable/disable the TM generation of individual events and
-// event groups as well.
-pub struct EventManager {
-    pub ctrl_rx: std::sync::mpsc::Receiver<control::Event>,
-    pub tm_tx: std::sync::mpsc::SyncSender<CcsdsTmPacketOwned>,
-}
-
-impl EventManager {
-    pub fn periodic_operation(&mut self) {
-        if let Ok(event) = self.ctrl_rx.try_recv() {
-            self.event_to_tm(ComponentId::Controller, &Event::ControllerEvent(event));
-        }
-    }
-
-    pub fn event_to_tm(
-        &mut self,
-        sender_id: ComponentId,
-        event: &(impl serde::Serialize + Message),
-    ) {
-        match pack_ccsds_tm_packet_for_now(sender_id, None, event) {
-            Ok(packet) => {
-                if let Err(e) = self.tm_tx.send(packet) {
-                    log::warn!("error sending event TM packet: {:?}", e);
-                }
-            }
-            Err(e) => {
-                log::warn!("error packing event TM packet: {:?}", e);
-            }
-        }
-    }
-}

satrs-example/src/events.rs

@@ -1,12 +1,13 @@
-use arbitrary_int::traits::Integer as _;
-use arbitrary_int::u11;
-use satrs::event_man_legacy::{EventMessageU32, EventRoutingError};
-use satrs::pus::event::EventTmHook;
+use std::sync::mpsc::{self};
+
+use crate::pus::create_verification_reporter;
+use satrs::event_man::{EventMessageU32, EventRoutingError};
+use satrs::pus::event::EventTmHookProvider;
 use satrs::pus::verification::VerificationReporter;
 use satrs::pus::EcssTmSender;
 use satrs::request::UniqueApidTargetId;
 use satrs::{
-    event_man_legacy::{EventManagerWithBoundedMpsc, EventSendProvider, EventU32SenderMpscBounded},
+    event_man::{EventManagerWithBoundedMpsc, EventSendProvider, EventU32SenderMpscBounded},
     pus::{
         event_man::{
             DefaultPusEventU32TmCreator, EventReporter, EventRequest, EventRequestWithToken,
@@ -22,16 +23,15 @@ use crate::update_time;
 // This helper sets the APID of the event sender for the PUS telemetry.
 #[derive(Default)]
 pub struct EventApidSetter {
-    pub next_apid: u11,
+    pub next_apid: u16,
 }
 
-impl EventTmHook for EventApidSetter {
+impl EventTmHookProvider for EventApidSetter {
     fn modify_tm(&self, tm: &mut satrs::spacepackets::ecss::tm::PusTmCreator) {
         tm.set_apid(self.next_apid);
     }
 }
 
-/*
 /// The PUS event handler subscribes for all events and converts them into ECSS PUS 5 event
 /// packets. It also handles the verification completion of PUS event service requests.
 pub struct PusEventHandler<TmSender: EcssTmSender> {
@@ -59,11 +59,12 @@ impl<TmSender: EcssTmSender> PusEventHandler<TmSender> {
         // telemetry for each event.
         let event_reporter = EventReporter::new_with_hook(
             PUS_EVENT_MANAGEMENT.raw(),
-            u11::ZERO,
+            0,
             0,
             128,
             EventApidSetter::default(),
-        );
+        )
+        .unwrap();
         let pus_event_dispatcher =
             DefaultPusEventU32TmCreator::new_with_default_backend(event_reporter);
         let pus_event_man_send_provider = EventU32SenderMpscBounded::new(
@@ -216,18 +217,20 @@ impl<TmSender: EcssTmSender> EventHandler<TmSender> {
 
 #[cfg(test)]
 mod tests {
-    use arbitrary_int::u21;
     use satrs::{
-        events_legacy::EventU32,
-        pus::verification::VerificationReporterConfig,
-        spacepackets::ecss::{tm::PusTmReader, PusPacket},
+        events::EventU32,
+        pus::verification::VerificationReporterCfg,
+        spacepackets::{
+            ecss::{tm::PusTmReader, PusPacket},
+            CcsdsPacket,
+        },
         tmtc::PacketAsVec,
     };
 
     use super::*;
 
-    const TEST_CREATOR_ID: UniqueApidTargetId = UniqueApidTargetId::new(u11::new(1), u21::new(2));
-    const TEST_EVENT: EventU32 = EventU32::new(satrs::events_legacy::Severity::Info, 1, 1);
+    const TEST_CREATOR_ID: UniqueApidTargetId = UniqueApidTargetId::new(1, 2);
+    const TEST_EVENT: EventU32 = EventU32::new(satrs::events::Severity::Info, 1, 1);
 
     pub struct EventManagementTestbench {
         pub event_tx: mpsc::SyncSender<EventMessageU32>,
@@ -241,7 +244,7 @@ mod tests {
             let (event_tx, event_rx) = mpsc::sync_channel(10);
             let (_event_req_tx, event_req_rx) = mpsc::sync_channel(10);
             let (tm_sender, tm_receiver) = mpsc::channel();
-            let verif_reporter_cfg = VerificationReporterConfig::new(u11::new(0x05), 2, 2, 128);
+            let verif_reporter_cfg = VerificationReporterCfg::new(0x05, 2, 2, 128).unwrap();
             let verif_reporter =
                 VerificationReporter::new(PUS_EVENT_MANAGEMENT.id(), &verif_reporter_cfg);
             let mut event_manager = EventManagerWithBoundedMpsc::new(event_rx);
@@ -267,7 +270,7 @@ mod tests {
             .event_tx
             .send(EventMessageU32::new(
                 TEST_CREATOR_ID.id(),
-                EventU32::new(satrs::events_legacy::Severity::Info, 1, 1),
+                EventU32::new(satrs::events::Severity::Info, 1, 1),
             ))
             .expect("failed to send event");
         testbench.pus_event_handler.handle_event_requests();
@@ -290,4 +293,3 @@ mod tests {
         // TODO: Add test.
     }
 }
-*/

satrs-example/src/hk.rs

@@ -1,9 +1,8 @@
-use arbitrary_int::traits::Integer as _;
 use derive_new::new;
 use satrs::hk::UniqueId;
 use satrs::request::UniqueApidTargetId;
+use satrs::spacepackets::ecss::hk;
 use satrs::spacepackets::ecss::tm::{PusTmCreator, PusTmSecondaryHeader};
-use satrs::spacepackets::ecss::{hk, CreatorConfig, MessageTypeId};
 use satrs::spacepackets::{ByteConversionError, SpHeader};
 
 #[derive(Debug, new, Copy, Clone)]
@@ -30,7 +29,7 @@ impl HkUniqueId {
                 expected: 8,
             });
         }
-        buf[0..4].copy_from_slice(&self.target_id.unique_id.as_u32().to_be_bytes());
+        buf[0..4].copy_from_slice(&self.target_id.unique_id.to_be_bytes());
         buf[4..8].copy_from_slice(&self.set_id.to_be_bytes());
 
         Ok(8)
@@ -54,13 +53,9 @@ impl PusHkHelper {
         hk_data_writer: &mut HkWriter,
         buf: &'b mut [u8],
     ) -> Result<PusTmCreator<'a, 'b>, ByteConversionError> {
-        let sec_header = PusTmSecondaryHeader::new(
-            MessageTypeId::new(3, hk::MessageSubtypeId::TmHkPacket as u8),
-            0,
-            0,
-            timestamp,
-        );
-        buf[0..4].copy_from_slice(&self.component_id.unique_id.as_u32().to_be_bytes());
+        let sec_header =
+            PusTmSecondaryHeader::new(3, hk::Subservice::TmHkPacket as u8, 0, 0, timestamp);
+        buf[0..4].copy_from_slice(&self.component_id.unique_id.to_be_bytes());
         buf[4..8].copy_from_slice(&set_id.to_be_bytes());
         let (_, second_half) = buf.split_at_mut(8);
         let hk_data_len = hk_data_writer(second_half)?;
@@ -68,7 +63,7 @@ impl PusHkHelper {
             SpHeader::new_from_apid(self.component_id.apid),
             sec_header,
             &buf[0..8 + hk_data_len],
-            CreatorConfig::default(),
+            true,
         ))
     }
 }

satrs-example/src/ids.rs

@@ -0,0 +1,94 @@
+//! This is an auto-generated configuration module.
+use satrs::request::UniqueApidTargetId;
+
+#[derive(Debug, Copy, Clone, PartialEq, Eq, strum::EnumIter)]
+pub enum Apid {
+    Sched = 1,
+    GenericPus = 2,
+    Acs = 3,
+    Cfdp = 4,
+    Tmtc = 5,
+    Eps = 6,
+}
+
+pub mod acs {
+    #[derive(Debug, Copy, Clone, PartialEq, Eq)]
+    pub enum Id {
+        Subsystem = 1,
+        MgmAssembly = 2,
+        Mgm0 = 3,
+        Mgm1 = 4,
+    }
+
+    pub const SUBSYSTEM: super::UniqueApidTargetId =
+        super::UniqueApidTargetId::new(super::Apid::Acs as u16, Id::Subsystem as u32);
+    pub const MGM_ASSEMBLY: super::UniqueApidTargetId =
+        super::UniqueApidTargetId::new(super::Apid::Acs as u16, Id::MgmAssembly as u32);
+    pub const MGM0: super::UniqueApidTargetId =
+        super::UniqueApidTargetId::new(super::Apid::Acs as u16, Id::Mgm0 as u32);
+    pub const MGM1: super::UniqueApidTargetId =
+        super::UniqueApidTargetId::new(super::Apid::Acs as u16, Id::Mgm1 as u32);
+}
+
+pub mod eps {
+    #[derive(Debug, Copy, Clone, PartialEq, Eq)]
+    pub enum Id {
+        Pcdu = 0,
+        Subsystem = 1,
+    }
+
+    pub const PCDU: super::UniqueApidTargetId =
+        super::UniqueApidTargetId::new(super::Apid::Eps as u16, Id::Pcdu as u32);
+    pub const SUBSYSTEM: super::UniqueApidTargetId =
+        super::UniqueApidTargetId::new(super::Apid::Eps as u16, Id::Subsystem as u32);
+}
+
+pub mod generic_pus {
+    #[derive(Debug, Copy, Clone, PartialEq, Eq)]
+    pub enum Id {
+        PusEventManagement = 0,
+        PusRouting = 1,
+        PusTest = 2,
+        PusAction = 3,
+        PusMode = 4,
+        PusHk = 5,
+    }
+
+    pub const PUS_EVENT_MANAGEMENT: super::UniqueApidTargetId = super::UniqueApidTargetId::new(
+        super::Apid::GenericPus as u16,
+        Id::PusEventManagement as u32,
+    );
+    pub const PUS_ROUTING: super::UniqueApidTargetId =
+        super::UniqueApidTargetId::new(super::Apid::GenericPus as u16, Id::PusRouting as u32);
+    pub const PUS_TEST: super::UniqueApidTargetId =
+        super::UniqueApidTargetId::new(super::Apid::GenericPus as u16, Id::PusTest as u32);
+    pub const PUS_ACTION: super::UniqueApidTargetId =
+        super::UniqueApidTargetId::new(super::Apid::GenericPus as u16, Id::PusAction as u32);
+    pub const PUS_MODE: super::UniqueApidTargetId =
+        super::UniqueApidTargetId::new(super::Apid::GenericPus as u16, Id::PusMode as u32);
+    pub const PUS_HK: super::UniqueApidTargetId =
+        super::UniqueApidTargetId::new(super::Apid::GenericPus as u16, Id::PusHk as u32);
+}
+
+pub mod sched {
+    #[derive(Debug, Copy, Clone, PartialEq, Eq)]
+    pub enum Id {
+        PusSched = 0,
+    }
+
+    pub const PUS_SCHED: super::UniqueApidTargetId =
+        super::UniqueApidTargetId::new(super::Apid::Sched as u16, Id::PusSched as u32);
+}
+
+pub mod tmtc {
+    #[derive(Debug, Copy, Clone, PartialEq, Eq)]
+    pub enum Id {
+        UdpServer = 0,
+        TcpServer = 1,
+    }
+
+    pub const UDP_SERVER: super::UniqueApidTargetId =
+        super::UniqueApidTargetId::new(super::Apid::Tmtc as u16, Id::UdpServer as u32);
+    pub const TCP_SERVER: super::UniqueApidTargetId =
+        super::UniqueApidTargetId::new(super::Apid::Tmtc as u16, Id::TcpServer as u32);
+}

satrs-example/src/interface/sim_client_udp.rs

@@ -7,8 +7,8 @@ use std::{
 
 use satrs::pus::HandlingStatus;
 use satrs_minisim::{
-    SerializableSimMsgPayload, SimComponent, SimMessageProvider, SimReply, SimRequest,
-    udp::SIM_CTRL_PORT,
+    udp::SIM_CTRL_PORT, SerializableSimMsgPayload, SimComponent, SimMessageProvider, SimReply,
+    SimRequest,
 };
 use satrs_minisim::{SimCtrlReply, SimCtrlRequest};
 
@@ -24,7 +24,7 @@ pub fn create_sim_client(sim_request_rx: mpsc::Receiver<SimRequest>) -> Option<S
             return Some(sim_client);
         }
         Err(e) => {
-            log::warn!("sim client creation error: {e}");
+            log::warn!("sim client creation error: {}", e);
         }
     }
     None
@@ -116,7 +116,7 @@ impl SimClientUdp {
                         .udp_client
                         .send_to(request_json.as_bytes(), self.simulator_addr)
                     {
-                        log::error!("error sending data to UDP SIM server: {e}");
+                        log::error!("error sending data to UDP SIM server: {}", e);
                         break;
                     } else {
                         no_sim_requests_handled = false;
@@ -151,7 +151,7 @@ impl SimClientUdp {
                             }
                         }
                         Err(e) => {
-                            log::warn!("failed to deserialize SIM reply: {e}");
+                            log::warn!("failed to deserialize SIM reply: {}", e);
                         }
                     }
                 }
@@ -161,7 +161,7 @@ impl SimClientUdp {
                     {
                         break;
                     }
-                    log::error!("error receiving data from UDP SIM server: {e}");
+                    log::error!("error receiving data from UDP SIM server: {}", e);
                     break;
                 }
             }
@@ -187,17 +187,16 @@ pub mod tests {
         collections::HashMap,
         net::{SocketAddr, UdpSocket},
         sync::{
-            Arc,
             atomic::{AtomicBool, Ordering},
-            mpsc,
+            mpsc, Arc,
         },
         time::Duration,
     };
 
     use satrs_minisim::{
+        eps::{PcduReply, PcduRequest},
         SerializableSimMsgPayload, SimComponent, SimCtrlReply, SimCtrlRequest, SimMessageProvider,
         SimReply, SimRequest,
-        eps::{PcduReply, PcduRequest},
     };
 
     use super::SimClientUdp;

satrs-example/src/interface/tcp.rs

@@ -5,7 +5,7 @@ use std::{
 };
 
 use log::{info, warn};
-use satrs::hal::std::tcp_spacepackets_server::CcsdsPacketParser;
+use satrs::tmtc::StoreAndSendError;
 use satrs::{
     encoding::ccsds::{SpValidity, SpacePacketValidator},
     hal::std::tcp_server::{HandledConnectionHandler, ServerConfig, TcpSpacepacketsServer},
@@ -31,7 +31,7 @@ impl SpacePacketValidator for SimplePacketValidator {
         if self.valid_ids.contains(&sp_header.packet_id()) {
             return SpValidity::Valid;
         }
-        log::warn!("ignoring space packet with header {sp_header:?}");
+        log::warn!("ignoring space packet with header {:?}", sp_header);
         // We could perform a CRC check.. but lets keep this simple and assume that TCP ensures
         // data integrity.
         SpValidity::Skip
@@ -103,14 +103,16 @@ impl PacketSource for SyncTcpTmSource {
     }
 }
 
-pub type TcpServer<ReceivesTc> = TcpSpacepacketsServer<
+pub type TcpServer<ReceivesTc, SendError> = TcpSpacepacketsServer<
     SyncTcpTmSource,
     ReceivesTc,
     SimplePacketValidator,
     ConnectionFinishedHandler,
+    (),
+    SendError,
 >;
 
-pub struct TcpTask(pub TcpServer<TmTcSender>);
+pub struct TcpTask(pub TcpServer<TmTcSender, StoreAndSendError>);
 
 impl TcpTask {
     pub fn new(
@@ -122,20 +124,23 @@ impl TcpTask {
         Ok(Self(TcpSpacepacketsServer::new(
             cfg,
             tm_source,
-            CcsdsPacketParser::new(cfg.id, 2048, tc_sender, SimplePacketValidator { valid_ids }),
+            tc_sender,
+            SimplePacketValidator { valid_ids },
             ConnectionFinishedHandler::default(),
             None,
         )?))
     }
 
     pub fn periodic_operation(&mut self) {
-        let result = self
-            .0
-            .handle_all_connections(Some(Duration::from_millis(400)));
-        match result {
-            Ok(_conn_result) => (),
-            Err(e) => {
-                warn!("TCP server error: {e:?}");
+        loop {
+            let result = self
+                .0
+                .handle_all_connections(Some(Duration::from_millis(400)));
+            match result {
+                Ok(_conn_result) => (),
+                Err(e) => {
+                    warn!("TCP server error: {e:?}");
+                }
             }
         }
     }

satrs-example/src/interface/udp.rs

@@ -1,29 +1,42 @@
-#![allow(dead_code)]
-use std::collections::VecDeque;
 use std::net::{SocketAddr, UdpSocket};
-use std::sync::{Arc, Mutex, mpsc};
+use std::sync::mpsc;
 
-use log::warn;
-use models::ccsds::CcsdsTmPacketOwned;
-use satrs::hal::std::udp_server::{ReceiveResult, UdpTcServer};
+use log::{info, warn};
 use satrs::pus::HandlingStatus;
-use satrs::queue::GenericSendError;
+use satrs::tmtc::{PacketAsVec, PacketInPool, StoreAndSendError};
+use satrs::{
+    hal::std::udp_server::{ReceiveResult, UdpTcServer},
+    pool::{PoolProviderWithGuards, SharedStaticMemoryPool},
+};
 
 use crate::tmtc::sender::TmTcSender;
 
-pub trait UdpTmHandlerProvider {
+pub trait UdpTmHandler {
     fn send_tm_to_udp_client(&mut self, socket: &UdpSocket, recv_addr: &SocketAddr);
 }
 
-pub struct UdpTmHandlerWithChannel {
-    pub tm_rx: mpsc::Receiver<CcsdsTmPacketOwned>,
+pub struct StaticUdpTmHandler {
+    pub tm_rx: mpsc::Receiver<PacketInPool>,
+    pub tm_store: SharedStaticMemoryPool,
 }
 
-impl UdpTmHandlerProvider for UdpTmHandlerWithChannel {
-    fn send_tm_to_udp_client(&mut self, socket: &UdpSocket, recv_addr: &SocketAddr) {
-        while let Ok(tm) = self.tm_rx.try_recv() {
-            log::debug!("sending TM from sender {:?}", tm.tm_header.sender_id);
-            let result = socket.send_to(&tm.to_vec(), recv_addr);
+impl UdpTmHandler for StaticUdpTmHandler {
+    fn send_tm_to_udp_client(&mut self, socket: &UdpSocket, &recv_addr: &SocketAddr) {
+        while let Ok(pus_tm_in_pool) = self.tm_rx.try_recv() {
+            let store_lock = self.tm_store.write();
+            if store_lock.is_err() {
+                warn!("Locking TM store failed");
+                continue;
+            }
+            let mut store_lock = store_lock.unwrap();
+            let pg = store_lock.read_with_guard(pus_tm_in_pool.store_addr);
+            let read_res = pg.read_as_vec();
+            if read_res.is_err() {
+                warn!("Error reading TM pool data");
+                continue;
+            }
+            let buf = read_res.unwrap();
+            let result = socket.send_to(&buf, recv_addr);
             if let Err(e) = result {
                 warn!("Sending TM with UDP socket failed: {e}")
             }
@@ -31,49 +44,34 @@ impl UdpTmHandlerProvider for UdpTmHandlerWithChannel {
     }
 }
 
-#[derive(Default, Debug, Clone)]
-pub struct TestTmHandler {
-    addrs_to_send_to: Arc<Mutex<VecDeque<SocketAddr>>>,
+pub struct DynamicUdpTmHandler {
+    pub tm_rx: mpsc::Receiver<PacketAsVec>,
 }
 
-impl UdpTmHandlerProvider for TestTmHandler {
-    fn send_tm_to_udp_client(&mut self, _socket: &UdpSocket, recv_addr: &SocketAddr) {
-        self.addrs_to_send_to.lock().unwrap().push_back(*recv_addr);
-    }
-}
-
-pub enum UdpTmHandler {
-    Normal(UdpTmHandlerWithChannel),
-    Test(TestTmHandler),
-}
-
-impl From<UdpTmHandlerWithChannel> for UdpTmHandler {
-    fn from(handler: UdpTmHandlerWithChannel) -> Self {
-        UdpTmHandler::Normal(handler)
-    }
-}
-
-impl From<TestTmHandler> for UdpTmHandler {
-    fn from(handler: TestTmHandler) -> Self {
-        UdpTmHandler::Test(handler)
-    }
-}
-
-impl UdpTmHandlerProvider for UdpTmHandler {
+impl UdpTmHandler for DynamicUdpTmHandler {
     fn send_tm_to_udp_client(&mut self, socket: &UdpSocket, recv_addr: &SocketAddr) {
-        match self {
-            UdpTmHandler::Normal(handler) => handler.send_tm_to_udp_client(socket, recv_addr),
-            UdpTmHandler::Test(handler) => handler.send_tm_to_udp_client(socket, recv_addr),
+        while let Ok(tm) = self.tm_rx.try_recv() {
+            if tm.packet.len() > 9 {
+                let service = tm.packet[7];
+                let subservice = tm.packet[8];
+                info!("Sending PUS TM[{service},{subservice}]")
+            } else {
+                info!("Sending PUS TM");
+            }
+            let result = socket.send_to(&tm.packet, recv_addr);
+            if let Err(e) = result {
+                warn!("Sending TM with UDP socket failed: {e}")
+            }
         }
     }
 }
 
-pub struct UdpTmtcServer {
-    pub udp_tc_server: UdpTcServer<TmTcSender, GenericSendError>,
-    pub tm_handler: UdpTmHandler,
+pub struct UdpTmtcServer<TmHandler: UdpTmHandler> {
+    pub udp_tc_server: UdpTcServer<TmTcSender, StoreAndSendError>,
+    pub tm_handler: TmHandler,
 }
 
-impl UdpTmtcServer {
+impl<TmHandler: UdpTmHandler> UdpTmtcServer<TmHandler> {
     pub fn periodic_operation(&mut self) {
         loop {
             if self.poll_tc_server() == HandlingStatus::Empty {
@@ -107,28 +105,40 @@ impl UdpTmtcServer {
 
 #[cfg(test)]
 mod tests {
-    use std::net::IpAddr;
     use std::net::Ipv4Addr;
+    use std::{
+        collections::VecDeque,
+        net::IpAddr,
+        sync::{Arc, Mutex},
+    };
 
-    use arbitrary_int::traits::Integer as _;
-    use arbitrary_int::u14;
-    use models::Apid;
-    use satrs::spacepackets::ecss::{CreatorConfig, MessageTypeId};
     use satrs::{
-        ComponentId,
         spacepackets::{
+            ecss::{tc::PusTcCreator, WritablePusPacket},
             SpHeader,
-            ecss::{WritablePusPacket, tc::PusTcCreator},
         },
+        ComponentId,
     };
     use satrs_example::config::OBSW_SERVER_ADDR;
+    use satrs_example::ids;
 
-    use crate::tmtc::sender::MockSender;
+    use crate::tmtc::sender::{MockSender, TmTcSender};
 
     use super::*;
 
     const UDP_SERVER_ID: ComponentId = 0x05;
 
+    #[derive(Default, Debug, Clone)]
+    pub struct TestTmHandler {
+        addrs_to_send_to: Arc<Mutex<VecDeque<SocketAddr>>>,
+    }
+
+    impl UdpTmHandler for TestTmHandler {
+        fn send_tm_to_udp_client(&mut self, _socket: &UdpSocket, recv_addr: &SocketAddr) {
+            self.addrs_to_send_to.lock().unwrap().push_back(*recv_addr);
+        }
+    }
+
     #[test]
     fn test_basic() {
         let sock_addr = SocketAddr::new(IpAddr::V4(OBSW_SERVER_ADDR), 0);
@@ -139,7 +149,7 @@ mod tests {
         let tm_handler_calls = tm_handler.addrs_to_send_to.clone();
         let mut udp_dyn_server = UdpTmtcServer {
             udp_tc_server,
-            tm_handler: tm_handler.into(),
+            tm_handler,
         };
         udp_dyn_server.periodic_operation();
         let queue = udp_dyn_server
@@ -164,17 +174,12 @@ mod tests {
         let tm_handler_calls = tm_handler.addrs_to_send_to.clone();
         let mut udp_dyn_server = UdpTmtcServer {
             udp_tc_server,
-            tm_handler: tm_handler.into(),
+            tm_handler,
         };
-        let sph = SpHeader::new_for_unseg_tc(Apid::Tmtc.raw_value(), u14::ZERO, 0);
-        let ping_tc = PusTcCreator::new_simple(
-            sph,
-            MessageTypeId::new(17, 1),
-            &[],
-            CreatorConfig::default(),
-        )
-        .to_vec()
-        .unwrap();
+        let sph = SpHeader::new_for_unseg_tc(ids::Apid::GenericPus as u16, 0, 0);
+        let ping_tc = PusTcCreator::new_simple(sph, 17, 1, &[], true)
+            .to_vec()
+            .unwrap();
         let client = UdpSocket::bind("127.0.0.1:0").expect("Connecting to UDP server failed");
         let client_addr = client.local_addr().unwrap();
         println!("{}", server_addr);

satrs-example/src/lib.rs

@@ -1,28 +1,13 @@
-extern crate alloc;
-
-use std::{
-    sync::mpsc,
-    time::{Duration, Instant},
-};
-
-pub use models::ComponentId;
-use models::ccsds::{CcsdsTcPacketOwned, CcsdsTmPacketOwned};
-use satrs::spacepackets::{CcsdsPacketIdAndPsc, time::cds::CdsTime};
+use satrs::spacepackets::time::{cds::CdsTime, TimeWriter};
 
 pub mod config;
+pub mod ids;
 
-/// Simple type modelling packet stored in the heap. This structure is intended to
-/// be used when sending a packet via a message queue, so it also contains the sender ID.
-#[derive(Debug, PartialEq, Eq, Clone)]
-pub struct PacketAsVec {
-    pub sender_id: ComponentId,
-    pub packet: Vec<u8>,
-}
-
-impl PacketAsVec {
-    pub fn new(sender_id: ComponentId, packet: Vec<u8>) -> Self {
-        Self { sender_id, packet }
-    }
+#[derive(Debug, PartialEq, Eq, Copy, Clone)]
+pub enum DeviceMode {
+    Off = 0,
+    On = 1,
+    Normal = 2,
 }
 
 pub struct TimestampHelper {
@@ -53,105 +38,3 @@ impl Default for TimestampHelper {
         }
     }
 }
-
-/// Helper structure for periodic HK generation of a single set.
-#[derive(Debug)]
-pub struct HkHelperSingleSet {
-    pub enabled: bool,
-    pub frequency: Duration,
-    pub last_generated: Option<Instant>,
-}
-
-impl HkHelperSingleSet {
-    #[inline]
-    pub const fn new(enabled: bool, init_frequency: Duration) -> Self {
-        Self {
-            enabled,
-            frequency: init_frequency,
-            last_generated: None,
-        }
-    }
-
-    #[inline]
-    pub const fn enabled(&self) -> bool {
-        self.enabled
-    }
-
-    /// Check whether a new HK packet needs to be generated.
-    pub fn needs_generation(&mut self) -> bool {
-        if !self.enabled {
-            return false;
-        }
-        if self.last_generated.is_none() {
-            self.last_generated = Some(Instant::now());
-            return true;
-        }
-        let last_generated = self.last_generated.unwrap();
-        if Instant::now() - last_generated >= self.frequency {
-            self.last_generated = Some(Instant::now());
-            return true;
-        }
-        false
-    }
-}
-
-pub struct TmtcQueues {
-    pub tc_rx: mpsc::Receiver<CcsdsTcPacketOwned>,
-    pub tm_tx: mpsc::SyncSender<CcsdsTmPacketOwned>,
-}
-
-#[derive(Debug)]
-pub struct ModeHelper<Mode, TransitionState> {
-    pub current: Mode,
-    pub target: Option<Mode>,
-    pub tc_commander: Option<CcsdsPacketIdAndPsc>,
-    pub transition_start: Option<Instant>,
-    pub timeout: Duration,
-    pub transition_state: TransitionState,
-}
-
-impl<Mode: Copy + Clone, TransitionState: Default> ModeHelper<Mode, TransitionState> {
-    pub fn new(init_mode: Mode, timeout: Duration) -> Self {
-        Self {
-            current: init_mode,
-            target: Default::default(),
-            tc_commander: Default::default(),
-            transition_start: None,
-            timeout,
-            transition_state: Default::default(),
-        }
-    }
-
-    pub fn start(&mut self, target: Mode) {
-        self.target = Some(target);
-        self.transition_start = Some(Instant::now());
-        self.transition_state = TransitionState::default();
-    }
-
-    #[inline]
-    pub fn transition_active(&self) -> bool {
-        self.target.is_some()
-    }
-
-    pub fn timed_out(&self) -> bool {
-        if self.target.is_none() {
-            return false;
-        }
-        if let Some(transition_start) = self.transition_start {
-            return Instant::now() - transition_start >= self.timeout;
-        }
-        false
-    }
-
-    pub fn finish(&mut self, success: bool) -> Option<CcsdsPacketIdAndPsc> {
-        self.target?;
-        if success {
-            self.current = self.target.take().unwrap();
-        } else {
-            self.target = None;
-        }
-        self.transition_state = Default::default();
-        self.transition_start = None;
-        self.tc_commander.take()
-    }
-}

satrs-example/src/logger.rs

@@ -1,13 +1,4 @@
-use std::str::FromStr as _;
-
 pub fn setup_logger() -> Result<(), fern::InitError> {
-    // Read the RUST_LOG environment variable and parse it.
-    // If the variable is not set or is invalid, default to Debug.
-    let mut log_level = log::LevelFilter::Info;
-    if let Ok(log_level_str) = std::env::var("RUST_LOG") {
-        log_level = log::LevelFilter::from_str(&log_level_str).unwrap_or(log::LevelFilter::Info);
-    }
-
     fern::Dispatch::new()
         .format(|out, message, record| {
             out.finish(format_args!(
@@ -18,7 +9,7 @@ pub fn setup_logger() -> Result<(), fern::InitError> {
                 message
             ))
         })
-        .level(log_level)
+        .level(log::LevelFilter::Debug)
         .chain(std::io::stdout())
         .chain(fern::log_file("output.log")?)
         .apply()?;

satrs-example/src/main.rs

@@ -1,18 +1,19 @@
 use std::{
     net::{IpAddr, SocketAddr},
-    sync::{
-        Arc, Mutex,
-        atomic::{AtomicBool, Ordering},
-        mpsc,
-    },
+    sync::{mpsc, Arc, Mutex},
     thread,
     time::Duration,
 };
 
-use eps::{
-    PowerSwitchHelper,
-    pcdu::{PcduHandler, SerialInterfaceDummy, SerialInterfaceToSim, SerialSimInterfaceWrapper},
+use acs::{
+    assembly::MgmAssembly,
+    mgm::{MgmHandlerLis3Mdl, SpiDummyInterface, SpiSimInterface, SpiSimInterfaceWrapper},
 };
+use eps::{
+    pcdu::{PcduHandler, SerialInterfaceDummy, SerialInterfaceToSim, SerialSimInterfaceWrapper},
+    PowerSwitchHelper,
+};
+use events::EventHandler;
 use interface::{
     sim_client_udp::create_sim_client,
     tcp::{SyncTcpTmSource, TcpTask},
@@ -20,117 +21,259 @@ use interface::{
 };
 use log::info;
 use logger::setup_logger;
-use models::{ComponentId, DeviceMode};
+use pus::{
+    action::create_action_service,
+    event::create_event_service,
+    hk::create_hk_service,
+    mode::create_mode_service,
+    scheduler::{create_scheduler_service, TcReleaser},
+    stack::PusStack,
+    test::create_test_service,
+    PusTcDistributor, PusTcMpscRouter,
+};
+use requests::GenericRequestRouter;
 use satrs::{
     hal::std::{tcp_server::ServerConfig, udp_server::UdpTcServer},
-    mode::{Mode, ModeAndSubmode, ModeRequest},
-    pus::HandlingStatus,
+    mode::{
+        Mode, ModeAndSubmode, ModeRequest, ModeRequestHandlerMpscBounded,
+        ModeRequestorAndHandlerMpscBounded,
+    },
+    mode_tree::connect_mode_nodes,
+    pus::{event_man::EventRequestWithToken, EcssTcInMemConverter, HandlingStatus},
     request::{GenericMessage, MessageMetadata},
-    spacepackets::time::cds::CdsTime,
+    spacepackets::time::{cds::CdsTime, TimeWriter},
 };
 use satrs_example::{
-    TmtcQueues,
     config::{
-        OBSW_SERVER_ADDR, PACKET_ID_VALIDATOR, SERVER_PORT,
         components::NO_SENDER,
-        tasks::{FREQ_MS_AOCS, FREQ_MS_CONTROLLER, FREQ_MS_UDP_TMTC, SIM_CLIENT_IDLE_DELAY_MS},
+        pool::create_sched_tc_pool,
+        tasks::{FREQ_MS_AOCS, FREQ_MS_PUS_STACK, FREQ_MS_UDP_TMTC, SIM_CLIENT_IDLE_DELAY_MS},
+        OBSW_SERVER_ADDR, PACKET_ID_VALIDATOR, SERVER_PORT,
     },
+    ids::{
+        acs::*,
+        eps::*,
+        tmtc::{TCP_SERVER, UDP_SERVER},
+    },
+    DeviceMode,
 };
 use tmtc::sender::TmTcSender;
 use tmtc::{tc_source::TcSourceTask, tm_sink::TmSink};
 
-use crate::{
-    acs::{mgm, mgm_assembly},
-    control::Controller,
-    eps::pcdu::SwitchSet,
-    event_manager::EventManager,
-    interface::udp::UdpTmHandlerWithChannel,
-    tmtc::tc_source::CcsdsDistributor,
-};
+cfg_if::cfg_if! {
+    if #[cfg(feature = "heap_tmtc")] {
+        use interface::udp::DynamicUdpTmHandler;
+        use satrs::pus::EcssTcInVecConverter;
+        use tmtc::{tc_source::TcSourceTaskDynamic, tm_sink::TmSinkDynamic};
+    } else {
+        use std::sync::RwLock;
+        use interface::udp::StaticUdpTmHandler;
+        use satrs::pus::EcssTcInSharedPoolConverter;
+        use satrs::tmtc::{PacketSenderWithSharedPool, SharedPacketPool};
+        use satrs_example::config::pool::create_static_pools;
+        use tmtc::{
+            tc_source::TcSourceTaskStatic,
+            tm_sink::TmSinkStatic,
+        };
+    }
+}
 
 mod acs;
-mod ccsds;
-mod control;
 mod eps;
-mod event_manager;
+mod events;
+mod hk;
 mod interface;
 mod logger;
+mod pus;
+mod requests;
+mod spi;
 mod tmtc;
-fn main() {
-    static KILL_SIGNAL: AtomicBool = AtomicBool::new(false);
 
+fn main() {
     setup_logger().expect("setting up logging with fern failed");
-    println!("Runng OBSW example");
-    ctrlc::set_handler(move || {
-        log::info!("Received Ctrl-C, shutting down");
-        KILL_SIGNAL.store(true, Ordering::Relaxed);
-    })
-    .expect("Error setting Ctrl-C handler");
+    println!("Running OBSW example");
+
+    cfg_if::cfg_if! {
+        if #[cfg(not(feature = "heap_tmtc"))] {
+            let (tm_pool, tc_pool) = create_static_pools();
+            let shared_tm_pool = Arc::new(RwLock::new(tm_pool));
+            let shared_tc_pool = Arc::new(RwLock::new(tc_pool));
+            let shared_tm_pool_wrapper = SharedPacketPool::new(&shared_tm_pool);
+            let shared_tc_pool_wrapper = SharedPacketPool::new(&shared_tc_pool);
+        }
+    }
 
     let (tc_source_tx, tc_source_rx) = mpsc::sync_channel(50);
     let (tm_sink_tx, tm_sink_rx) = mpsc::sync_channel(50);
     let (tm_server_tx, tm_server_rx) = mpsc::sync_channel(50);
 
+    cfg_if::cfg_if! {
+        if #[cfg(not(feature = "heap_tmtc"))] {
+            let tm_sender = TmTcSender::Static(
+                PacketSenderWithSharedPool::new(tm_sink_tx.clone(), shared_tm_pool_wrapper.clone())
+            );
+        } else if #[cfg(feature = "heap_tmtc")] {
+            let tm_sender = TmTcSender::Heap(tm_sink_tx.clone());
+        }
+    }
+
     let (sim_request_tx, sim_request_rx) = mpsc::channel();
     let (mgm_0_sim_reply_tx, mgm_0_sim_reply_rx) = mpsc::channel();
     let (mgm_1_sim_reply_tx, mgm_1_sim_reply_rx) = mpsc::channel();
     let (pcdu_sim_reply_tx, pcdu_sim_reply_rx) = mpsc::channel();
     let mut opt_sim_client = create_sim_client(sim_request_rx);
 
-    let (mgm_0_handler_tc_tx, mgm_0_handler_tc_rx) = mpsc::sync_channel(10);
-    let (mgm_1_handler_tc_tx, mgm_1_handler_tc_rx) = mpsc::sync_channel(10);
-    let (mgm_assembly_tc_tx, mgm_assembly_tc_rx) = mpsc::sync_channel(10);
-    let (pcdu_handler_tc_tx, pcdu_handler_tc_rx) = mpsc::sync_channel(30);
-    let (controller_tc_tx, controller_tc_rx) = mpsc::sync_channel(10);
+    let (mgm_0_handler_composite_tx, mgm_0_handler_composite_rx) = mpsc::sync_channel(10);
+    let (mgm_1_handler_composite_tx, mgm_1_handler_composite_rx) = mpsc::sync_channel(10);
+    let (pcdu_handler_composite_tx, pcdu_handler_composite_rx) = mpsc::sync_channel(30);
+    let (mgm_0_handler_mode_tx, mgm_0_handler_mode_rx) = mpsc::sync_channel(5);
+    let (mgm_1_handler_mode_tx, mgm_1_handler_mode_rx) = mpsc::sync_channel(5);
+    let (pcdu_handler_mode_tx, pcdu_handler_mode_rx) = mpsc::sync_channel(5);
 
-    // These message handles need to go into the MGM assembly and ACS subsystem.
-    let (_mgm_assembly_request_tx, mgm_assembly_request_rx) = mpsc::sync_channel(5);
-    let (mgm_assembly_report_tx, _mgm_assembly_report_rx) = mpsc::sync_channel(5);
+    // Some request are targetable. This map is used to retrieve sender handles based on a target ID.
+    let mut request_map = GenericRequestRouter::default();
+    request_map
+        .composite_router_map
+        .insert(MGM0.id(), mgm_0_handler_composite_tx);
+    request_map
+        .composite_router_map
+        .insert(MGM1.id(), mgm_1_handler_composite_tx);
+    request_map
+        .composite_router_map
+        .insert(PCDU.id(), pcdu_handler_composite_tx);
 
-    // These message handles need to go into the MGM assembly and MGM devices.
-    let (mgm_0_mode_request_tx, mgm_0_mode_request_rx) = mpsc::sync_channel(5);
-    let (mgm_1_mode_request_tx, mgm_1_mode_request_rx) = mpsc::sync_channel(5);
-    let (mgm_0_mode_report_tx, mgm_0_mode_report_rx) = mpsc::sync_channel(5);
-    let (mgm_1_mode_report_tx, mgm_1_mode_report_rx) = mpsc::sync_channel(5);
+    // This helper structure is used by all telecommand providers which need to send telecommands
+    // to the TC source.
+    cfg_if::cfg_if! {
+        if #[cfg(not(feature = "heap_tmtc"))] {
+            let tc_sender_with_shared_pool =
+                PacketSenderWithSharedPool::new(tc_source_tx, shared_tc_pool_wrapper.clone());
+            let tc_in_mem_converter =
+                EcssTcInMemConverter::Static(EcssTcInSharedPoolConverter::new(shared_tc_pool, 4096));
+        } else if #[cfg(feature = "heap_tmtc")] {
+            let tc_in_mem_converter = EcssTcInMemConverter::Heap(EcssTcInVecConverter::default());
+        }
+    }
 
-    let (pcdu_handler_mode_tx, _pcdu_handler_mode_rx) = mpsc::sync_channel(5);
+    // Create event handling components
+    // These sender handles are used to send event requests, for example to enable or disable
+    // certain events.
+    let (event_tx, event_rx) = mpsc::sync_channel(100);
+    let (event_request_tx, event_request_rx) = mpsc::channel::<EventRequestWithToken>();
 
-    let (event_ctrl_tx, event_ctrl_rx) = mpsc::sync_channel(10);
-    let mut event_manager = EventManager {
-        ctrl_rx: event_ctrl_rx,
-        tm_tx: tm_sink_tx.clone(),
+    // The event task is the core handler to perform the event routing and TM handling as specified
+    // in the sat-rs documentation.
+    let mut event_handler = EventHandler::new(tm_sink_tx.clone(), event_rx, event_request_rx);
+
+    let (pus_test_tx, pus_test_rx) = mpsc::sync_channel(20);
+    let (pus_event_tx, pus_event_rx) = mpsc::sync_channel(10);
+    let (pus_sched_tx, pus_sched_rx) = mpsc::sync_channel(50);
+    let (pus_hk_tx, pus_hk_rx) = mpsc::sync_channel(50);
+    let (pus_action_tx, pus_action_rx) = mpsc::sync_channel(50);
+    let (pus_mode_tx, pus_mode_rx) = mpsc::sync_channel(50);
+
+    let (_pus_action_reply_tx, pus_action_reply_rx) = mpsc::channel();
+    let (pus_hk_reply_tx, pus_hk_reply_rx) = mpsc::sync_channel(50);
+    let (pus_mode_reply_tx, pus_mode_reply_rx) = mpsc::sync_channel(30);
+
+    cfg_if::cfg_if! {
+        if #[cfg(not(feature = "heap_tmtc"))] {
+            let tc_releaser = TcReleaser::Static(tc_sender_with_shared_pool.clone());
+        } else if #[cfg(feature = "heap_tmtc")] {
+            let tc_releaser = TcReleaser::Heap(tc_source_tx.clone());
+        }
+    }
+    let pus_router = PusTcMpscRouter {
+        test_tc_sender: pus_test_tx,
+        event_tc_sender: pus_event_tx,
+        sched_tc_sender: pus_sched_tx,
+        hk_tc_sender: pus_hk_tx,
+        action_tc_sender: pus_action_tx,
+        mode_tc_sender: pus_mode_tx,
     };
+    let pus_test_service = create_test_service(
+        tm_sender.clone(),
+        tc_in_mem_converter.clone(),
+        event_tx.clone(),
+        pus_test_rx,
+    );
+    let pus_scheduler_service = create_scheduler_service(
+        tm_sender.clone(),
+        tc_in_mem_converter.clone(),
+        tc_releaser,
+        pus_sched_rx,
+        create_sched_tc_pool(),
+    );
+    let pus_event_service = create_event_service(
+        tm_sender.clone(),
+        tc_in_mem_converter.clone(),
+        pus_event_rx,
+        event_request_tx,
+    );
+    let pus_action_service = create_action_service(
+        tm_sender.clone(),
+        tc_in_mem_converter.clone(),
+        pus_action_rx,
+        request_map.clone(),
+        pus_action_reply_rx,
+    );
+    let pus_hk_service = create_hk_service(
+        tm_sender.clone(),
+        tc_in_mem_converter.clone(),
+        pus_hk_rx,
+        request_map.clone(),
+        pus_hk_reply_rx,
+    );
+    let pus_mode_service = create_mode_service(
+        tm_sender.clone(),
+        tc_in_mem_converter.clone(),
+        pus_mode_rx,
+        request_map,
+        pus_mode_reply_rx,
+    );
+    let mut pus_stack = PusStack::new(
+        pus_test_service,
+        pus_hk_service,
+        pus_event_service,
+        pus_action_service,
+        pus_scheduler_service,
+        pus_mode_service,
+    );
 
-    let mut controller = Controller::new(controller_tc_rx, tm_sink_tx.clone(), event_ctrl_tx);
-
-    let ccsds_distributor = CcsdsDistributor::default();
-    let mut tc_source = TcSourceTask::new(tc_source_rx, ccsds_distributor);
-    tc_source.add_target(ComponentId::EpsPcdu, pcdu_handler_tc_tx);
-    tc_source.add_target(ComponentId::Controller, controller_tc_tx);
-    tc_source.add_target(ComponentId::AcsMgm0, mgm_0_handler_tc_tx);
-    tc_source.add_target(ComponentId::AcsMgm1, mgm_1_handler_tc_tx);
-    tc_source.add_target(ComponentId::AcsMgmAssembly, mgm_assembly_tc_tx);
-
-    let tc_sender = TmTcSender::Normal(tc_source_tx.clone());
-    let udp_tm_handler = UdpTmHandlerWithChannel {
-        tm_rx: tm_server_rx,
-    };
+    cfg_if::cfg_if! {
+        if #[cfg(not(feature = "heap_tmtc"))] {
+            let mut tmtc_task = TcSourceTask::Static(TcSourceTaskStatic::new(
+                shared_tc_pool_wrapper.clone(),
+                tc_source_rx,
+                PusTcDistributor::new(tm_sender.clone(), pus_router),
+            ));
+            let tc_sender = TmTcSender::Static(tc_sender_with_shared_pool);
+            let udp_tm_handler = StaticUdpTmHandler {
+                tm_rx: tm_server_rx,
+                tm_store: shared_tm_pool.clone(),
+            };
+        } else if #[cfg(feature = "heap_tmtc")] {
+            let mut tmtc_task = TcSourceTask::Heap(TcSourceTaskDynamic::new(
+                tc_source_rx,
+                PusTcDistributor::new(tm_sender.clone(), pus_router),
+            ));
+            let tc_sender = TmTcSender::Heap(tc_source_tx.clone());
+            let udp_tm_handler = DynamicUdpTmHandler {
+                tm_rx: tm_server_rx,
+            };
+        }
+    }
 
     let sock_addr = SocketAddr::new(IpAddr::V4(OBSW_SERVER_ADDR), SERVER_PORT);
-    let udp_tc_server = UdpTcServer::new(
-        ComponentId::UdpServer as u32,
-        sock_addr,
-        2048,
-        tc_sender.clone(),
-    )
-    .expect("creating UDP TMTC server failed");
+    let udp_tc_server = UdpTcServer::new(UDP_SERVER.id(), sock_addr, 2048, tc_sender.clone())
+        .expect("creating UDP TMTC server failed");
     let mut udp_tmtc_server = UdpTmtcServer {
         udp_tc_server,
-        tm_handler: udp_tm_handler.into(),
+        tm_handler: udp_tm_handler,
     };
 
     let tcp_server_cfg = ServerConfig::new(
-        ComponentId::TcpServer as u32,
+        TCP_SERVER.id(),
         sock_addr,
         Duration::from_millis(400),
         4096,
@@ -145,14 +288,40 @@ fn main() {
     )
     .expect("tcp server creation failed");
 
-    let mut tm_sink = TmSink::new(sync_tm_tcp_source, tm_sink_rx, tm_server_tx);
+    cfg_if::cfg_if! {
+        if #[cfg(not(feature = "heap_tmtc"))] {
+            let mut tm_sink = TmSink::Static(TmSinkStatic::new(
+                shared_tm_pool_wrapper,
+                sync_tm_tcp_source,
+                tm_sink_rx,
+                tm_server_tx,
+            ));
+        } else if #[cfg(feature = "heap_tmtc")] {
+            let mut tm_sink = TmSink::Heap(TmSinkDynamic::new(
+                sync_tm_tcp_source,
+                tm_sink_rx,
+                tm_server_tx,
+            ));
+        }
+    }
 
-    let shared_switch_set = Arc::new(Mutex::new(SwitchSet::new_with_init_switches_unknown()));
+    let shared_switch_set = Arc::new(Mutex::default());
     let (switch_request_tx, switch_request_rx) = mpsc::sync_channel(20);
     let switch_helper = PowerSwitchHelper::new(switch_request_tx, shared_switch_set.clone());
 
+    let (mgm_assy_mode_req_tx, mgm_assy_mode_req_rx) = mpsc::sync_channel(20);
+    let (mgm_assy_mode_reply_tx, mgm_assy_mode_reply_rx) = mpsc::sync_channel(20);
+    let mgm_assembly_mode_node = ModeRequestorAndHandlerMpscBounded::new(
+        MgmAssembly::id(),
+        mgm_assy_mode_req_rx,
+        mgm_assy_mode_reply_rx,
+    );
+    let mut mgm_assembly = MgmAssembly::new(mgm_assembly_mode_node);
+
     let shared_mgm_0_set = Arc::default();
     let shared_mgm_1_set = Arc::default();
+    let mgm_0_mode_node = ModeRequestHandlerMpscBounded::new(MGM0.into(), mgm_0_handler_mode_rx);
+    let mgm_1_mode_node = ModeRequestHandlerMpscBounded::new(MGM1.into(), mgm_1_handler_mode_rx);
     let (mgm_0_spi_interface, mgm_1_spi_interface) =
         if let Some(sim_client) = opt_sim_client.as_mut() {
             sim_client
@@ -160,65 +329,68 @@ fn main() {
             sim_client
                 .add_reply_recipient(satrs_minisim::SimComponent::Mgm1Lis3Mdl, mgm_1_sim_reply_tx);
             (
-                mgm::SpiCommunication::Sim(mgm::SpiSimInterface {
+                SpiSimInterfaceWrapper::Sim(SpiSimInterface {
                     sim_request_tx: sim_request_tx.clone(),
                     sim_reply_rx: mgm_0_sim_reply_rx,
                 }),
-                mgm::SpiCommunication::Sim(mgm::SpiSimInterface {
+                SpiSimInterfaceWrapper::Sim(SpiSimInterface {
                     sim_request_tx: sim_request_tx.clone(),
                     sim_reply_rx: mgm_1_sim_reply_rx,
                 }),
             )
         } else {
             (
-                mgm::SpiCommunication::Dummy(mgm::SpiDummyInterface::default()),
-                mgm::SpiCommunication::Dummy(mgm::SpiDummyInterface::default()),
+                SpiSimInterfaceWrapper::Dummy(SpiDummyInterface::default()),
+                SpiSimInterfaceWrapper::Dummy(SpiDummyInterface::default()),
             )
         };
-    let mut mgm_0_handler = mgm::MgmHandlerLis3Mdl::new(
-        mgm::MgmId::_0,
-        TmtcQueues {
-            tc_rx: mgm_0_handler_tc_rx,
-            tm_tx: tm_sink_tx.clone(),
-        },
+    let mut mgm_0_handler = MgmHandlerLis3Mdl::new(
+        MGM0,
+        "MGM_0",
+        mgm_0_mode_node,
+        mgm_0_handler_composite_rx,
+        pus_hk_reply_tx.clone(),
         switch_helper.clone(),
+        tm_sender.clone(),
         mgm_0_spi_interface,
         shared_mgm_0_set,
-        mgm::ModeLeafHelper {
-            request_rx: mgm_0_mode_request_rx,
-            report_tx: mgm_0_mode_report_tx,
-        },
-        Duration::from_millis(1000)
     );
-    let mut mgm_1_handler = mgm::MgmHandlerLis3Mdl::new(
-        mgm::MgmId::_1,
-        TmtcQueues {
-            tc_rx: mgm_1_handler_tc_rx,
-            tm_tx: tm_sink_tx.clone(),
-        },
+    let mut mgm_1_handler = MgmHandlerLis3Mdl::new(
+        MGM1,
+        "MGM_1",
+        mgm_1_mode_node,
+        mgm_1_handler_composite_rx,
+        pus_hk_reply_tx.clone(),
         switch_helper.clone(),
+        tm_sender.clone(),
         mgm_1_spi_interface,
         shared_mgm_1_set,
-        mgm::ModeLeafHelper {
-            request_rx: mgm_1_mode_request_rx,
-            report_tx: mgm_1_mode_report_tx,
-        },
-        Duration::from_millis(1000)
     );
-    let mut mgm_assembly = mgm_assembly::Assembly::new(
-        mgm_assembly::ParentQueueHelper {
-            request_rx: mgm_assembly_request_rx,
-            report_tx: mgm_assembly_report_tx,
-        },
-        mgm_assembly::ChildrenQueueHelper {
-            request_tx_queues: [mgm_0_mode_request_tx, mgm_1_mode_request_tx],
-            report_rx_queues: [mgm_0_mode_report_rx, mgm_1_mode_report_rx],
-        },
-        TmtcQueues {
-            tc_rx: mgm_assembly_tc_rx,
-            tm_tx: tm_sink_tx.clone(),
-        },
-        Duration::from_millis(2000),
+    // Connect PUS service to device handlers.
+    connect_mode_nodes(
+        &mut pus_stack.mode_srv,
+        mgm_0_handler_mode_tx,
+        &mut mgm_0_handler,
+        pus_mode_reply_tx.clone(),
+    );
+    connect_mode_nodes(
+        &mut pus_stack.mode_srv,
+        mgm_1_handler_mode_tx,
+        &mut mgm_1_handler,
+        pus_mode_reply_tx.clone(),
+    );
+    // Connect assembly to device handlers.
+    connect_mode_nodes(
+        &mut mgm_assembly,
+        mgm_assy_mode_req_tx.clone(),
+        &mut mgm_1_handler,
+        mgm_assy_mode_reply_tx.clone(),
+    );
+    connect_mode_nodes(
+        &mut mgm_assembly,
+        mgm_assy_mode_req_tx,
+        &mut mgm_1_handler,
+        mgm_assy_mode_reply_tx,
     );
 
     let pcdu_serial_interface = if let Some(sim_client) = opt_sim_client.as_mut() {
@@ -230,13 +402,23 @@ fn main() {
     } else {
         SerialSimInterfaceWrapper::Dummy(SerialInterfaceDummy::default())
     };
+    let pcdu_mode_node = ModeRequestHandlerMpscBounded::new(PCDU.into(), pcdu_handler_mode_rx);
     let mut pcdu_handler = PcduHandler::new(
-        pcdu_handler_tc_rx,
-        tm_sink_tx.clone(),
+        PCDU,
+        "PCDU",
+        pcdu_mode_node,
+        pcdu_handler_composite_rx,
+        pus_hk_reply_tx,
         switch_request_rx,
+        tm_sender.clone(),
         pcdu_serial_interface,
         shared_switch_set,
-        DeviceMode::Normal,
+    );
+    connect_mode_nodes(
+        &mut pus_stack.mode_srv,
+        pcdu_handler_mode_tx.clone(),
+        &mut pcdu_handler,
+        pus_mode_reply_tx,
     );
 
     // The PCDU is a critical component which should be in normal mode immediately.
@@ -252,15 +434,12 @@ fn main() {
 
     info!("Starting TMTC and UDP task");
     let jh_udp_tmtc = thread::Builder::new()
-        .name("TMTC & UDP".to_string())
+        .name("SATRS tmtc-udp".to_string())
         .spawn(move || {
             info!("Running UDP server on port {SERVER_PORT}");
             loop {
-                if KILL_SIGNAL.load(Ordering::Relaxed) {
-                    break;
-                }
                 udp_tmtc_server.periodic_operation();
-                tc_source.periodic_operation();
+                tmtc_task.periodic_operation();
                 thread::sleep(Duration::from_millis(FREQ_MS_UDP_TMTC));
             }
         })
@@ -268,13 +447,10 @@ fn main() {
 
     info!("Starting TCP task");
     let jh_tcp = thread::Builder::new()
-        .name("TCP".to_string())
+        .name("sat-rs tcp".to_string())
         .spawn(move || {
             info!("Running TCP server on port {SERVER_PORT}");
             loop {
-                if KILL_SIGNAL.load(Ordering::Relaxed) {
-                    break;
-                }
                 tcp_server.periodic_operation();
             }
         })
@@ -282,14 +458,9 @@ fn main() {
 
     info!("Starting TM funnel task");
     let jh_tm_funnel = thread::Builder::new()
-        .name("TM SINK".to_string())
-        .spawn(move || {
-            loop {
-                if KILL_SIGNAL.load(Ordering::Relaxed) {
-                    break;
-                }
-                tm_sink.operation();
-            }
+        .name("tm sink".to_string())
+        .spawn(move || loop {
+            tm_sink.operation();
         })
         .unwrap();
 
@@ -298,15 +469,10 @@ fn main() {
         info!("Starting UDP sim client task");
         opt_jh_sim_client = Some(
             thread::Builder::new()
-                .name("SIM ADAPTER".to_string())
-                .spawn(move || {
-                    loop {
-                        if KILL_SIGNAL.load(Ordering::Relaxed) {
-                            break;
-                        }
-                        if sim_client.operation() == HandlingStatus::Empty {
-                            std::thread::sleep(Duration::from_millis(SIM_CLIENT_IDLE_DELAY_MS));
-                        }
+                .name("sat-rs sim adapter".to_string())
+                .spawn(move || loop {
+                    if sim_client.operation() == HandlingStatus::Empty {
+                        std::thread::sleep(Duration::from_millis(SIM_CLIENT_IDLE_DELAY_MS));
                     }
                 })
                 .unwrap(),
@@ -315,55 +481,39 @@ fn main() {
 
     info!("Starting AOCS thread");
     let jh_aocs = thread::Builder::new()
-        .name("AOCS".to_string())
-        .spawn(move || {
-            loop {
-                if KILL_SIGNAL.load(Ordering::Relaxed) {
-                    break;
-                }
-                mgm_0_handler.periodic_operation();
-                mgm_1_handler.periodic_operation();
-                mgm_assembly.periodic_operation();
-                thread::sleep(Duration::from_millis(FREQ_MS_AOCS));
-            }
+        .name("sat-rs aocs".to_string())
+        .spawn(move || loop {
+            mgm_assembly.periodic_operation();
+            mgm_0_handler.periodic_operation();
+            mgm_1_handler.periodic_operation();
+            thread::sleep(Duration::from_millis(FREQ_MS_AOCS));
         })
         .unwrap();
 
     info!("Starting EPS thread");
     let jh_eps = thread::Builder::new()
-        .name("EPS".to_string())
-        .spawn(move || {
-            loop {
-                if KILL_SIGNAL.load(Ordering::Relaxed) {
-                    break;
-                }
-                // TODO: We should introduce something like a fixed timeslot helper to allow a more
-                // declarative API. It would also be very useful for the AOCS task.
-                //
-                // TODO: The fixed timeslot handler exists.. use it.
-                // TODO: Why not just use sync code in the PCDU handler, and fully delay there?
-                pcdu_handler.periodic_operation(crate::eps::pcdu::OpCode::RegularOp);
-                thread::sleep(Duration::from_millis(50));
-                pcdu_handler.periodic_operation(crate::eps::pcdu::OpCode::PollAndRecvReplies);
-                thread::sleep(Duration::from_millis(50));
-                pcdu_handler.periodic_operation(crate::eps::pcdu::OpCode::PollAndRecvReplies);
-                thread::sleep(Duration::from_millis(300));
-            }
+        .name("sat-rs eps".to_string())
+        .spawn(move || loop {
+            // TODO: We should introduce something like a fixed timeslot helper to allow a more
+            // declarative API. It would also be very useful for the AOCS task.
+            //
+            // TODO: The fixed timeslot handler exists.. use it.
+            pcdu_handler.periodic_operation(crate::eps::pcdu::OpCode::RegularOp);
+            thread::sleep(Duration::from_millis(50));
+            pcdu_handler.periodic_operation(crate::eps::pcdu::OpCode::PollAndRecvReplies);
+            thread::sleep(Duration::from_millis(50));
+            pcdu_handler.periodic_operation(crate::eps::pcdu::OpCode::PollAndRecvReplies);
+            thread::sleep(Duration::from_millis(300));
         })
         .unwrap();
 
-    info!("Starting controller thread");
-    let jh_controller_thread = thread::Builder::new()
-        .name("CTRL".to_string())
-        .spawn(move || {
-            loop {
-                if KILL_SIGNAL.load(Ordering::Relaxed) {
-                    break;
-                }
-                controller.periodic_operation();
-                event_manager.periodic_operation();
-                thread::sleep(Duration::from_millis(FREQ_MS_CONTROLLER));
-            }
+    info!("Starting PUS handler thread");
+    let jh_pus_handler = thread::Builder::new()
+        .name("sat-rs pus".to_string())
+        .spawn(move || loop {
+            event_handler.periodic_operation();
+            pus_stack.periodic_operation();
+            thread::sleep(Duration::from_millis(FREQ_MS_PUS_STACK));
         })
         .unwrap();
 
@@ -383,7 +533,7 @@ fn main() {
     }
     jh_aocs.join().expect("Joining AOCS thread failed");
     jh_eps.join().expect("Joining EPS thread failed");
-    jh_controller_thread
+    jh_pus_handler
         .join()
         .expect("Joining PUS handler thread failed");
 }

satrs-example/src/pus/action.rs

@@ -9,7 +9,7 @@ use satrs::pus::verification::{
     VerificationReportingProvider, VerificationToken,
 };
 use satrs::pus::{
-    ActiveRequest, EcssTcAndToken, EcssTcCacher, EcssTmSender, EcssTmtcError,
+    ActiveRequestProvider, EcssTcAndToken, EcssTcInMemConverter, EcssTmSender, EcssTmtcError,
     GenericConversionError, MpscTcReceiver, PusPacketHandlingError, PusReplyHandler,
     PusServiceHelper, PusTcToRequestConverter,
 };
@@ -161,7 +161,7 @@ impl PusTcToRequestConverter<ActivePusActionRequestStd, ActionRequest> for Actio
         verif_reporter: &impl VerificationReportingProvider,
         time_stamp: &[u8],
     ) -> Result<(ActivePusActionRequestStd, ActionRequest), Self::Error> {
-        let subservice = tc.message_subtype_id();
+        let subservice = tc.subservice();
         let user_data = tc.user_data();
         if user_data.len() < 8 {
             verif_reporter
@@ -208,7 +208,7 @@ impl PusTcToRequestConverter<ActivePusActionRequestStd, ActionRequest> for Actio
 
 pub fn create_action_service(
     tm_sender: TmTcSender,
-    tc_in_mem_converter: EcssTcCacher,
+    tc_in_mem_converter: EcssTcInMemConverter,
     pus_action_rx: mpsc::Receiver<EcssTcAndToken>,
     action_router: GenericRequestRouter,
     reply_receiver: mpsc::Receiver<GenericMessage<ActionReplyPus>>,
@@ -270,14 +270,12 @@ impl TargetedPusService for ActionServiceWrapper {
 
 #[cfg(test)]
 mod tests {
-    use arbitrary_int::traits::Integer as _;
     use satrs::pus::test_util::{
         TEST_APID, TEST_COMPONENT_ID_0, TEST_COMPONENT_ID_1, TEST_UNIQUE_ID_0, TEST_UNIQUE_ID_1,
     };
     use satrs::pus::verification::test_util::TestVerificationReporter;
-    use satrs::pus::{verification, EcssTcVecCacher};
+    use satrs::pus::{verification, EcssTcInVecConverter};
     use satrs::request::MessageMetadata;
-    use satrs::spacepackets::ecss::{CreatorConfig, MessageTypeId};
     use satrs::tmtc::PacketAsVec;
     use satrs::ComponentId;
     use satrs::{
@@ -327,7 +325,7 @@ mod tests {
                         pus_action_rx,
                         TmTcSender::Heap(tm_funnel_tx.clone()),
                         verif_reporter,
-                        EcssTcCacher::Heap(EcssTcVecCacher::default()),
+                        EcssTcInMemConverter::Heap(EcssTcInVecConverter::default()),
                     ),
                     ActionRequestConverter::default(),
                     DefaultActiveActionRequestMap::default(),
@@ -450,13 +448,12 @@ mod tests {
         );
         // Create a basic action request and verify forwarding.
         let sp_header = SpHeader::new_from_apid(TEST_APID);
-        let sec_header = PusTcSecondaryHeader::new_simple(MessageTypeId::new(8, 128));
+        let sec_header = PusTcSecondaryHeader::new_simple(8, 128);
         let action_id = 5_u32;
         let mut app_data: [u8; 8] = [0; 8];
-        app_data[0..4].copy_from_slice(&TEST_UNIQUE_ID_1.as_u32().to_be_bytes());
+        app_data[0..4].copy_from_slice(&TEST_UNIQUE_ID_1.to_be_bytes());
         app_data[4..8].copy_from_slice(&action_id.to_be_bytes());
-        let pus8_packet =
-            PusTcCreator::new(sp_header, sec_header, &app_data, CreatorConfig::default());
+        let pus8_packet = PusTcCreator::new(sp_header, sec_header, &app_data, true);
         testbench.add_tc(&pus8_packet);
         let time_stamp: [u8; 7] = [0; 7];
         testbench.verify_next_tc_is_handled_properly(&time_stamp);
@@ -492,7 +489,7 @@ mod tests {
             TEST_COMPONENT_ID_1.id(),
         );
         // Create a basic action request and verify forwarding.
-        let sec_header = PusTcSecondaryHeader::new_simple(MessageTypeId::new(8, 128));
+        let sec_header = PusTcSecondaryHeader::new_simple(8, 128);
         let action_id = 5_u32;
         let mut app_data: [u8; 8] = [0; 8];
         // Invalid ID, routing should fail.
@@ -502,7 +499,7 @@ mod tests {
             SpHeader::new_from_apid(TEST_APID),
             sec_header,
             &app_data,
-            CreatorConfig::default(),
+            true,
         );
         testbench.add_tc(&pus8_packet);
         let time_stamp: [u8; 7] = [0; 7];
@@ -518,17 +515,17 @@ mod tests {
             TEST_COMPONENT_ID_0.raw(),
             ActionRequestConverter::default(),
         );
-        let sec_header = PusTcSecondaryHeader::new_simple(MessageTypeId::new(8, 128));
+        let sec_header = PusTcSecondaryHeader::new_simple(8, 128);
         let action_id = 5_u32;
         let mut app_data: [u8; 8] = [0; 8];
         // Invalid ID, routing should fail.
-        app_data[0..4].copy_from_slice(&TEST_UNIQUE_ID_0.as_u32().to_be_bytes());
+        app_data[0..4].copy_from_slice(&TEST_UNIQUE_ID_0.to_be_bytes());
         app_data[4..8].copy_from_slice(&action_id.to_be_bytes());
         let pus8_packet = PusTcCreator::new(
             SpHeader::new_from_apid(TEST_APID),
             sec_header,
             &app_data,
-            CreatorConfig::default(),
+            true,
         );
         let token = testbench.add_tc(&pus8_packet);
         let result = testbench.convert(token, &[], TEST_APID, TEST_UNIQUE_ID_0);
@@ -554,11 +551,11 @@ mod tests {
     fn converter_action_req_with_data() {
         let mut testbench =
             PusConverterTestbench::new(TEST_COMPONENT_ID_0.id(), ActionRequestConverter::default());
-        let sec_header = PusTcSecondaryHeader::new_simple(MessageTypeId::new(8, 128));
+        let sec_header = PusTcSecondaryHeader::new_simple(8, 128);
         let action_id = 5_u32;
         let mut app_data: [u8; 16] = [0; 16];
         // Invalid ID, routing should fail.
-        app_data[0..4].copy_from_slice(&TEST_UNIQUE_ID_0.as_u32().to_be_bytes());
+        app_data[0..4].copy_from_slice(&TEST_UNIQUE_ID_0.to_be_bytes());
         app_data[4..8].copy_from_slice(&action_id.to_be_bytes());
         for i in 0..8 {
             app_data[i + 8] = i as u8;
@@ -567,7 +564,7 @@ mod tests {
             SpHeader::new_from_apid(TEST_APID),
             sec_header,
             &app_data,
-            CreatorConfig::default(),
+            true,
         );
         let token = testbench.add_tc(&pus8_packet);
         let result = testbench.convert(token, &[], TEST_APID, TEST_UNIQUE_ID_0);
@@ -697,7 +694,7 @@ mod tests {
             ReplyHandlerTestbench::new(TEST_COMPONENT_ID_0.id(), ActionReplyHandler::default());
         let action_reply = ActionReplyPus::new(5_u32, ActionReplyVariant::Completed);
         let unrequested_reply =
-            GenericMessage::new(MessageMetadata::new(10_u32, 15_u32), action_reply);
+            GenericMessage::new(MessageMetadata::new(10_u32, 15_u64), action_reply);
         // Right now this function does not do a lot. We simply check that it does not panic or do
         // weird stuff.
         let result = testbench.handle_unrequested_reply(&unrequested_reply);

satrs-example/src/pus/event.rs

@@ -6,7 +6,7 @@ use satrs::pus::event_man::EventRequestWithToken;
 use satrs::pus::event_srv::PusEventServiceHandler;
 use satrs::pus::verification::VerificationReporter;
 use satrs::pus::{
-    DirectPusPacketHandlerResult, EcssTcAndToken, EcssTcCacher, MpscTcReceiver,
+    DirectPusPacketHandlerResult, EcssTcAndToken, EcssTcInMemConverter, MpscTcReceiver,
     PartialPusHandlingError, PusServiceHelper,
 };
 use satrs::spacepackets::ecss::PusServiceId;
@@ -16,7 +16,7 @@ use super::{DirectPusService, HandlingStatus};
 
 pub fn create_event_service(
     tm_sender: TmTcSender,
-    tm_in_pool_converter: EcssTcCacher,
+    tm_in_pool_converter: EcssTcInMemConverter,
     pus_event_rx: mpsc::Receiver<EcssTcAndToken>,
     event_request_tx: mpsc::Sender<EventRequestWithToken>,
 ) -> EventServiceWrapper {
@@ -36,8 +36,12 @@ pub fn create_event_service(
 }
 
 pub struct EventServiceWrapper {
-    pub handler:
-        PusEventServiceHandler<MpscTcReceiver, TmTcSender, EcssTcCacher, VerificationReporter>,
+    pub handler: PusEventServiceHandler<
+        MpscTcReceiver,
+        TmTcSender,
+        EcssTcInMemConverter,
+        VerificationReporter,
+    >,
 }
 
 impl DirectPusService for EventServiceWrapper {

satrs-example/src/pus/hk.rs

@@ -5,9 +5,9 @@ use satrs::pus::verification::{
     VerificationReportingProvider, VerificationToken,
 };
 use satrs::pus::{
-    ActivePusRequestStd, ActiveRequest, DefaultActiveRequestMap, EcssTcAndToken, EcssTcCacher,
-    EcssTmSender, EcssTmtcError, GenericConversionError, MpscTcReceiver, PusPacketHandlingError,
-    PusReplyHandler, PusServiceHelper, PusTcToRequestConverter,
+    ActivePusRequestStd, ActiveRequestProvider, DefaultActiveRequestMap, EcssTcAndToken,
+    EcssTcInMemConverter, EcssTmSender, EcssTmtcError, GenericConversionError, MpscTcReceiver,
+    PusPacketHandlingError, PusReplyHandler, PusServiceHelper, PusTcToRequestConverter,
 };
 use satrs::request::{GenericMessage, UniqueApidTargetId};
 use satrs::res_code::ResultU16;
@@ -164,11 +164,11 @@ impl PusTcToRequestConverter<ActivePusRequestStd, HkRequest> for HkRequestConver
                 found: 4,
             });
         }
-        let subservice = tc.message_subtype_id();
+        let subservice = tc.subservice();
         let target_id_and_apid = UniqueApidTargetId::from_pus_tc(tc).expect("invalid tc format");
         let unique_id = u32::from_be_bytes(tc.user_data()[4..8].try_into().unwrap());
 
-        let standard_subservice = hk::MessageSubtypeId::try_from(subservice);
+        let standard_subservice = hk::Subservice::try_from(subservice);
         if standard_subservice.is_err() {
             verif_reporter
                 .start_failure(
@@ -180,22 +180,19 @@ impl PusTcToRequestConverter<ActivePusRequestStd, HkRequest> for HkRequestConver
             return Err(GenericConversionError::InvalidSubservice(subservice));
         }
         let request = match standard_subservice.unwrap() {
-            hk::MessageSubtypeId::TcEnableHkGeneration
-            | hk::MessageSubtypeId::TcEnableDiagGeneration => {
+            hk::Subservice::TcEnableHkGeneration | hk::Subservice::TcEnableDiagGeneration => {
                 HkRequest::new(unique_id, HkRequestVariant::EnablePeriodic)
             }
-            hk::MessageSubtypeId::TcDisableHkGeneration
-            | hk::MessageSubtypeId::TcDisableDiagGeneration => {
+            hk::Subservice::TcDisableHkGeneration | hk::Subservice::TcDisableDiagGeneration => {
                 HkRequest::new(unique_id, HkRequestVariant::DisablePeriodic)
             }
-            hk::MessageSubtypeId::TcReportHkReportStructures => todo!(),
-            hk::MessageSubtypeId::TmHkPacket => todo!(),
-            hk::MessageSubtypeId::TcGenerateOneShotHk
-            | hk::MessageSubtypeId::TcGenerateOneShotDiag => {
+            hk::Subservice::TcReportHkReportStructures => todo!(),
+            hk::Subservice::TmHkPacket => todo!(),
+            hk::Subservice::TcGenerateOneShotHk | hk::Subservice::TcGenerateOneShotDiag => {
                 HkRequest::new(unique_id, HkRequestVariant::OneShot)
             }
-            hk::MessageSubtypeId::TcModifyDiagCollectionInterval
-            | hk::MessageSubtypeId::TcModifyHkCollectionInterval => {
+            hk::Subservice::TcModifyDiagCollectionInterval
+            | hk::Subservice::TcModifyHkCollectionInterval => {
                 if user_data.len() < 12 {
                     verif_reporter
                         .start_failure(
@@ -245,7 +242,7 @@ impl PusTcToRequestConverter<ActivePusRequestStd, HkRequest> for HkRequestConver
 
 pub fn create_hk_service(
     tm_sender: TmTcSender,
-    tc_in_mem_converter: EcssTcCacher,
+    tc_in_mem_converter: EcssTcInMemConverter,
     pus_hk_rx: mpsc::Receiver<EcssTcAndToken>,
     request_router: GenericRequestRouter,
     reply_receiver: mpsc::Receiver<GenericMessage<HkReply>>,
@@ -305,19 +302,16 @@ impl TargetedPusService for HkServiceWrapper {
 
 #[cfg(test)]
 mod tests {
-    use arbitrary_int::traits::Integer as _;
-    use arbitrary_int::{u14, u21};
     use satrs::pus::test_util::{
         TEST_COMPONENT_ID_0, TEST_COMPONENT_ID_1, TEST_UNIQUE_ID_0, TEST_UNIQUE_ID_1,
     };
     use satrs::request::MessageMetadata;
-    use satrs::spacepackets::ecss::{CreatorConfig, MessageTypeId};
     use satrs::{
         hk::HkRequestVariant,
         pus::test_util::TEST_APID,
         request::GenericMessage,
         spacepackets::{
-            ecss::{hk::MessageSubtypeId, tc::PusTcCreator},
+            ecss::{hk::Subservice, tc::PusTcCreator},
             SpHeader,
         },
     };
@@ -334,18 +328,19 @@ mod tests {
     fn hk_converter_one_shot_req() {
         let mut hk_bench =
             PusConverterTestbench::new(TEST_COMPONENT_ID_0.id(), HkRequestConverter::default());
-        let sp_header = SpHeader::new_for_unseg_tc(TEST_APID, u14::ZERO, 0);
+        let sp_header = SpHeader::new_for_unseg_tc(TEST_APID, 0, 0);
         let target_id = TEST_UNIQUE_ID_0;
         let unique_id = 5_u32;
         let mut app_data: [u8; 8] = [0; 8];
-        app_data[0..4].copy_from_slice(&target_id.as_u32().to_be_bytes());
+        app_data[0..4].copy_from_slice(&target_id.to_be_bytes());
         app_data[4..8].copy_from_slice(&unique_id.to_be_bytes());
 
         let hk_req = PusTcCreator::new_simple(
             sp_header,
-            MessageTypeId::new(3, MessageSubtypeId::TcGenerateOneShotHk as u8),
+            3,
+            Subservice::TcGenerateOneShotHk as u8,
             &app_data,
-            CreatorConfig::default(),
+            true,
         );
         let accepted_token = hk_bench.add_tc(&hk_req);
         let (_active_req, req) = hk_bench
@@ -363,11 +358,11 @@ mod tests {
     fn hk_converter_enable_periodic_generation() {
         let mut hk_bench =
             PusConverterTestbench::new(TEST_COMPONENT_ID_0.id(), HkRequestConverter::default());
-        let sp_header = SpHeader::new_for_unseg_tc(TEST_APID, u14::ZERO, 0);
+        let sp_header = SpHeader::new_for_unseg_tc(TEST_APID, 0, 0);
         let target_id = TEST_UNIQUE_ID_0;
         let unique_id = 5_u32;
         let mut app_data: [u8; 8] = [0; 8];
-        app_data[0..4].copy_from_slice(&target_id.as_u32().to_be_bytes());
+        app_data[0..4].copy_from_slice(&target_id.to_be_bytes());
         app_data[4..8].copy_from_slice(&unique_id.to_be_bytes());
         let mut generic_check = |tc: &PusTcCreator| {
             let accepted_token = hk_bench.add_tc(tc);
@@ -382,16 +377,18 @@ mod tests {
         };
         let tc0 = PusTcCreator::new_simple(
             sp_header,
-            MessageTypeId::new(3, MessageSubtypeId::TcEnableHkGeneration as u8),
+            3,
+            Subservice::TcEnableHkGeneration as u8,
             &app_data,
-            CreatorConfig::default(),
+            true,
         );
         generic_check(&tc0);
         let tc1 = PusTcCreator::new_simple(
             sp_header,
-            MessageTypeId::new(3, MessageSubtypeId::TcEnableDiagGeneration as u8),
+            3,
+            Subservice::TcEnableDiagGeneration as u8,
             &app_data,
-            CreatorConfig::default(),
+            true,
         );
         generic_check(&tc1);
     }
@@ -400,11 +397,11 @@ mod tests {
     fn hk_conversion_disable_periodic_generation() {
         let mut hk_bench =
             PusConverterTestbench::new(TEST_COMPONENT_ID_0.id(), HkRequestConverter::default());
-        let sp_header = SpHeader::new_for_unseg_tc(TEST_APID, u14::ZERO, 0);
+        let sp_header = SpHeader::new_for_unseg_tc(TEST_APID, 0, 0);
         let target_id = TEST_UNIQUE_ID_0;
         let unique_id = 5_u32;
         let mut app_data: [u8; 8] = [0; 8];
-        app_data[0..4].copy_from_slice(&target_id.as_u32().to_be_bytes());
+        app_data[0..4].copy_from_slice(&target_id.to_be_bytes());
         app_data[4..8].copy_from_slice(&unique_id.to_be_bytes());
         let mut generic_check = |tc: &PusTcCreator| {
             let accepted_token = hk_bench.add_tc(tc);
@@ -419,16 +416,18 @@ mod tests {
         };
         let tc0 = PusTcCreator::new_simple(
             sp_header,
-            MessageTypeId::new(3, MessageSubtypeId::TcDisableHkGeneration as u8),
+            3,
+            Subservice::TcDisableHkGeneration as u8,
             &app_data,
-            CreatorConfig::default(),
+            true,
         );
         generic_check(&tc0);
         let tc1 = PusTcCreator::new_simple(
             sp_header,
-            MessageTypeId::new(3, MessageSubtypeId::TcDisableDiagGeneration as u8),
+            3,
+            Subservice::TcDisableDiagGeneration as u8,
             &app_data,
-            CreatorConfig::default(),
+            true,
         );
         generic_check(&tc1);
     }
@@ -437,12 +436,12 @@ mod tests {
     fn hk_conversion_modify_interval() {
         let mut hk_bench =
             PusConverterTestbench::new(TEST_COMPONENT_ID_0.id(), HkRequestConverter::default());
-        let sp_header = SpHeader::new_for_unseg_tc(TEST_APID, u14::ZERO, 0);
+        let sp_header = SpHeader::new_for_unseg_tc(TEST_APID, 0, 0);
         let target_id = TEST_UNIQUE_ID_0;
         let unique_id = 5_u32;
         let mut app_data: [u8; 12] = [0; 12];
         let collection_interval_factor = 5_u32;
-        app_data[0..4].copy_from_slice(&target_id.as_u32().to_be_bytes());
+        app_data[0..4].copy_from_slice(&target_id.to_be_bytes());
         app_data[4..8].copy_from_slice(&unique_id.to_be_bytes());
         app_data[8..12].copy_from_slice(&collection_interval_factor.to_be_bytes());
 
@@ -460,16 +459,18 @@ mod tests {
         };
         let tc0 = PusTcCreator::new_simple(
             sp_header,
-            MessageTypeId::new(3, MessageSubtypeId::TcModifyHkCollectionInterval as u8),
+            3,
+            Subservice::TcModifyHkCollectionInterval as u8,
             &app_data,
-            CreatorConfig::default(),
+            true,
         );
         generic_check(&tc0);
         let tc1 = PusTcCreator::new_simple(
             sp_header,
-            MessageTypeId::new(3, MessageSubtypeId::TcModifyDiagCollectionInterval as u8),
+            3,
+            Subservice::TcModifyDiagCollectionInterval as u8,
             &app_data,
-            CreatorConfig::default(),
+            true,
         );
         generic_check(&tc1);
     }
@@ -478,8 +479,8 @@ mod tests {
     fn hk_reply_handler() {
         let mut reply_testbench =
             ReplyHandlerTestbench::new(TEST_COMPONENT_ID_0.id(), HkReplyHandler::default());
-        let sender_id = 2_u32;
-        let apid_target_id = u21::new(3);
+        let sender_id = 2_u64;
+        let apid_target_id = 3_u32;
         let unique_id = 5_u32;
         let (req_id, active_req) = reply_testbench.add_tc(TEST_APID, apid_target_id, &[]);
         let reply = GenericMessage::new(
@@ -500,7 +501,7 @@ mod tests {
             ReplyHandlerTestbench::new(TEST_COMPONENT_ID_1.id(), HkReplyHandler::default());
         let action_reply = HkReply::new(5_u32, HkReplyVariant::Ack);
         let unrequested_reply =
-            GenericMessage::new(MessageMetadata::new(10_u32, 15_u32), action_reply);
+            GenericMessage::new(MessageMetadata::new(10_u32, 15_u64), action_reply);
         // Right now this function does not do a lot. We simply check that it does not panic or do
         // weird stuff.
         let result = testbench.handle_unrequested_reply(&unrequested_reply);

satrs-example/src/pus/mod.rs

@@ -4,13 +4,13 @@ use log::warn;
 use satrs::pool::PoolAddr;
 use satrs::pus::verification::{
     self, FailParams, TcStateAccepted, TcStateStarted, VerificationReporter,
-    VerificationReporterConfig, VerificationReportingProvider, VerificationToken,
+    VerificationReporterCfg, VerificationReportingProvider, VerificationToken,
 };
 use satrs::pus::{
-    ActiveRequest, ActiveRequestStore, CacheAndReadRawEcssTc, EcssTcAndToken, EcssTcCacher,
-    EcssTcReceiver, EcssTmSender, EcssTmtcError, GenericConversionError, GenericRoutingError,
-    HandlingStatus, PusPacketHandlingError, PusReplyHandler, PusRequestRouter, PusServiceHelper,
-    PusTcToRequestConverter, TcInMemory,
+    ActiveRequestMapProvider, ActiveRequestProvider, EcssTcAndToken, EcssTcInMemConversionProvider,
+    EcssTcInMemConverter, EcssTcReceiver, EcssTmSender, EcssTmtcError, GenericConversionError,
+    GenericRoutingError, HandlingStatus, PusPacketHandlingError, PusReplyHandler, PusRequestRouter,
+    PusServiceHelper, PusTcToRequestConverter, TcInMemory,
 };
 use satrs::queue::{GenericReceiveError, GenericSendError};
 use satrs::request::{Apid, GenericMessage, MessageMetadata};
@@ -33,13 +33,12 @@ pub mod stack;
 pub mod test;
 
 pub fn create_verification_reporter(owner_id: ComponentId, apid: Apid) -> VerificationReporter {
-    let verif_cfg = VerificationReporterConfig::new(apid, 1, 2, 8);
+    let verif_cfg = VerificationReporterCfg::new(apid, 1, 2, 8).unwrap();
     // Every software component which needs to generate verification telemetry, gets a cloned
     // verification reporter.
     VerificationReporter::new(owner_id, &verif_cfg)
 }
 
-/*
 /// Simple router structure which forwards PUS telecommands to dedicated handlers.
 pub struct PusTcMpscRouter {
     pub test_tc_sender: mpsc::SyncSender<EcssTcAndToken>,
@@ -103,7 +102,7 @@ impl PusTcDistributor {
                 sender_id,
                 pus_tc_result.unwrap_err()
             );
-            log::warn!("raw data: {raw_tc:x?}");
+            log::warn!("raw data: {:x?}", raw_tc);
             // TODO: Shouldn't this be an error?
             return Ok(HandlingStatus::HandledOne);
         }
@@ -114,7 +113,7 @@ impl PusTcDistributor {
             .verif_reporter
             .acceptance_success(&self.tm_sender, init_token, self.stamp_helper.stamp())
             .expect("Acceptance success failure");
-        let service = PusServiceId::try_from(pus_tc.service_type_id());
+        let service = PusServiceId::try_from(pus_tc.service());
         let tc_in_memory: TcInMemory = if let Some(store_addr) = addr_opt {
             PacketInPool::new(sender_id, store_addr).into()
         } else {
@@ -188,7 +187,6 @@ impl PusTcDistributor {
         Ok(HandlingStatus::HandledOne)
     }
 }
-*/
 
 pub trait TargetedPusService {
     const SERVICE_ID: u8;
@@ -271,16 +269,16 @@ pub struct PusTargetedRequestService<
     VerificationReporter: VerificationReportingProvider,
     RequestConverter: PusTcToRequestConverter<ActiveRequestInfo, RequestType, Error = GenericConversionError>,
     ReplyHandler: PusReplyHandler<ActiveRequestInfo, ReplyType, Error = EcssTmtcError>,
-    ActiveRequestMapInstance: ActiveRequestStore<ActiveRequestInfo>,
-    ActiveRequestInfo: ActiveRequest,
+    ActiveRequestMap: ActiveRequestMapProvider<ActiveRequestInfo>,
+    ActiveRequestInfo: ActiveRequestProvider,
     RequestType,
     ReplyType,
 > {
     pub service_helper:
-        PusServiceHelper<TcReceiver, TmTcSender, EcssTcCacher, VerificationReporter>,
+        PusServiceHelper<TcReceiver, TmTcSender, EcssTcInMemConverter, VerificationReporter>,
     pub request_router: GenericRequestRouter,
     pub request_converter: RequestConverter,
-    pub active_request_map: ActiveRequestMapInstance,
+    pub active_request_map: ActiveRequestMap,
     pub reply_handler: ReplyHandler,
     pub reply_receiver: mpsc::Receiver<GenericMessage<ReplyType>>,
     phantom: std::marker::PhantomData<(RequestType, ActiveRequestInfo, ReplyType)>,
@@ -291,8 +289,8 @@ impl<
         VerificationReporter: VerificationReportingProvider,
         RequestConverter: PusTcToRequestConverter<ActiveRequestInfo, RequestType, Error = GenericConversionError>,
         ReplyHandler: PusReplyHandler<ActiveRequestInfo, ReplyType, Error = EcssTmtcError>,
-        ActiveRequestMapInstance: ActiveRequestStore<ActiveRequestInfo>,
-        ActiveRequestInfo: ActiveRequest,
+        ActiveRequestMap: ActiveRequestMapProvider<ActiveRequestInfo>,
+        ActiveRequestInfo: ActiveRequestProvider,
         RequestType,
         ReplyType,
     >
@@ -301,7 +299,7 @@ impl<
         VerificationReporter,
         RequestConverter,
         ReplyHandler,
-        ActiveRequestMapInstance,
+        ActiveRequestMap,
         ActiveRequestInfo,
         RequestType,
         ReplyType,
@@ -313,11 +311,11 @@ where
         service_helper: PusServiceHelper<
             TcReceiver,
             TmTcSender,
-            EcssTcCacher,
+            EcssTcInMemConverter,
             VerificationReporter,
         >,
         request_converter: RequestConverter,
-        active_request_map: ActiveRequestMapInstance,
+        active_request_map: ActiveRequestMap,
         reply_hook: ReplyHandler,
         request_router: GenericRequestRouter,
         reply_receiver: mpsc::Receiver<GenericMessage<ReplyType>>,
@@ -511,7 +509,7 @@ where
 /// and also log the error.
 pub fn generic_pus_request_timeout_handler(
     sender: &(impl EcssTmSender + ?Sized),
-    active_request: &(impl ActiveRequest + Debug),
+    active_request: &(impl ActiveRequestProvider + Debug),
     verification_handler: &impl VerificationReportingProvider,
     time_stamp: &[u8],
     service_str: &'static str,
@@ -533,15 +531,13 @@ pub fn generic_pus_request_timeout_handler(
 pub(crate) mod tests {
     use std::time::Duration;
 
-    use arbitrary_int::{u11, u21};
     use satrs::pus::test_util::TEST_COMPONENT_ID_0;
     use satrs::pus::{MpscTmAsVecSender, PusTmVariant};
     use satrs::request::RequestId;
-    use satrs::spacepackets::ecss::{CreatorConfig, MessageTypeId};
     use satrs::{
         pus::{
             verification::test_util::TestVerificationReporter, ActivePusRequestStd,
-            ActiveRequestStore, MpscTcReceiver,
+            ActiveRequestMapProvider, MpscTcReceiver,
         },
         request::UniqueApidTargetId,
         spacepackets::{
@@ -560,7 +556,7 @@ pub(crate) mod tests {
     // Testbench dedicated to the testing of [PusReplyHandler]s
     pub struct ReplyHandlerTestbench<
         ReplyHandler: PusReplyHandler<ActiveRequestInfo, Reply, Error = EcssTmtcError>,
-        ActiveRequestInfo: ActiveRequest,
+        ActiveRequestInfo: ActiveRequestProvider,
         Reply,
     > {
         pub id: ComponentId,
@@ -574,7 +570,7 @@ pub(crate) mod tests {
 
     impl<
             ReplyHandler: PusReplyHandler<ActiveRequestInfo, Reply, Error = EcssTmtcError>,
-            ActiveRequestInfo: ActiveRequest,
+            ActiveRequestInfo: ActiveRequestProvider,
             Reply,
         > ReplyHandlerTestbench<ReplyHandler, ActiveRequestInfo, Reply>
     {
@@ -594,17 +590,17 @@ pub(crate) mod tests {
 
         pub fn add_tc(
             &mut self,
-            apid: u11,
-            apid_target: u21,
+            apid: u16,
+            apid_target: u32,
             time_stamp: &[u8],
         ) -> (verification::RequestId, ActivePusRequestStd) {
             let sp_header = SpHeader::new_from_apid(apid);
-            let sec_header_dummy = PusTcSecondaryHeader::new_simple(MessageTypeId::new(0, 0));
+            let sec_header_dummy = PusTcSecondaryHeader::new_simple(0, 0);
             let init = self.verif_reporter.start_verification(&PusTcCreator::new(
                 sp_header,
                 sec_header_dummy,
                 &[],
-                CreatorConfig::default(),
+                true,
             ));
             let accepted = self
                 .verif_reporter
@@ -675,7 +671,7 @@ pub(crate) mod tests {
     // Testbench dedicated to the testing of [PusTcToRequestConverter]s
     pub struct PusConverterTestbench<
         Converter: PusTcToRequestConverter<ActiveRequestInfo, Request, Error = GenericConversionError>,
-        ActiveRequestInfo: ActiveRequest,
+        ActiveRequestInfo: ActiveRequestProvider,
         Request,
     > {
         pub id: ComponentId,
@@ -689,7 +685,7 @@ pub(crate) mod tests {
 
     impl<
             Converter: PusTcToRequestConverter<ActiveRequestInfo, Request, Error = GenericConversionError>,
-            ActiveRequestInfo: ActiveRequest,
+            ActiveRequestInfo: ActiveRequestProvider,
             Request,
         > PusConverterTestbench<Converter, ActiveRequestInfo, Request>
     {
@@ -723,8 +719,8 @@ pub(crate) mod tests {
             &mut self,
             token: VerificationToken<TcStateAccepted>,
             time_stamp: &[u8],
-            expected_apid: u11,
-            expected_apid_target: u21,
+            expected_apid: u16,
+            expected_apid_target: u32,
         ) -> Result<(ActiveRequestInfo, Request), Converter::Error> {
             if self.current_packet.is_none() {
                 return Err(GenericConversionError::InvalidAppData(
@@ -755,8 +751,8 @@ pub(crate) mod tests {
     pub struct TargetedPusRequestTestbench<
         RequestConverter: PusTcToRequestConverter<ActiveRequestInfo, RequestType, Error = GenericConversionError>,
         ReplyHandler: PusReplyHandler<ActiveRequestInfo, ReplyType, Error = EcssTmtcError>,
-        ActiveRequestMapInstance: ActiveRequestStore<ActiveRequestInfo>,
-        ActiveRequestInfo: ActiveRequest,
+        ActiveRequestMap: ActiveRequestMapProvider<ActiveRequestInfo>,
+        ActiveRequestInfo: ActiveRequestProvider,
         RequestType,
         ReplyType,
     > {
@@ -765,7 +761,7 @@ pub(crate) mod tests {
             TestVerificationReporter,
             RequestConverter,
             ReplyHandler,
-            ActiveRequestMapInstance,
+            ActiveRequestMap,
             ActiveRequestInfo,
             RequestType,
             ReplyType,

satrs-example/src/pus/mode.rs

@@ -1,8 +1,5 @@
-use arbitrary_int::traits::Integer as _;
-use arbitrary_int::u14;
 use derive_new::new;
 use satrs::mode_tree::{ModeNode, ModeParent};
-use satrs::spacepackets::ecss::{CreatorConfig, MessageTypeId};
 use satrs_example::ids;
 use std::sync::mpsc;
 use std::time::Duration;
@@ -11,8 +8,8 @@ use crate::requests::GenericRequestRouter;
 use crate::tmtc::sender::TmTcSender;
 use satrs::pus::verification::VerificationReporter;
 use satrs::pus::{
-    DefaultActiveRequestMap, EcssTcAndToken, EcssTcCacher, MpscTcReceiver, PusPacketHandlingError,
-    PusServiceHelper,
+    DefaultActiveRequestMap, EcssTcAndToken, EcssTcInMemConverter, MpscTcReceiver,
+    PusPacketHandlingError, PusServiceHelper,
 };
 use satrs::request::GenericMessage;
 use satrs::{
@@ -23,8 +20,8 @@ use satrs::{
             self, FailParams, TcStateAccepted, TcStateStarted, VerificationReportingProvider,
             VerificationToken,
         },
-        ActivePusRequestStd, ActiveRequest, EcssTmSender, EcssTmtcError, GenericConversionError,
-        PusReplyHandler, PusTcToRequestConverter, PusTmVariant,
+        ActivePusRequestStd, ActiveRequestProvider, EcssTmSender, EcssTmtcError,
+        GenericConversionError, PusReplyHandler, PusTcToRequestConverter, PusTmVariant,
     },
     request::UniqueApidTargetId,
     spacepackets::{
@@ -80,19 +77,10 @@ impl PusReplyHandler<ActivePusRequestStd, ModeReply> for ModeReplyHandler {
                     .write_to_be_bytes(&mut source_data)
                     .expect("writing mode reply failed");
                 let req_id = verification::RequestId::from(reply.request_id());
-                let sp_header = SpHeader::new_for_unseg_tm(req_id.packet_id().apid(), u14::ZERO, 0);
-                let sec_header = PusTmSecondaryHeader::new(
-                    MessageTypeId::new(200, Subservice::TmModeReply as u8),
-                    0,
-                    0,
-                    time_stamp,
-                );
-                let pus_tm = PusTmCreator::new(
-                    sp_header,
-                    sec_header,
-                    &source_data,
-                    CreatorConfig::default(),
-                );
+                let sp_header = SpHeader::new_for_unseg_tm(req_id.packet_id().apid(), 0, 0);
+                let sec_header =
+                    PusTmSecondaryHeader::new(200, Subservice::TmModeReply as u8, 0, 0, time_stamp);
+                let pus_tm = PusTmCreator::new(sp_header, sec_header, &source_data, true);
                 tm_sender.send_tm(self.owner_id, PusTmVariant::Direct(pus_tm))?;
                 verification_handler.completion_success(tm_sender, started_token, time_stamp)?;
             }
@@ -158,7 +146,7 @@ impl PusTcToRequestConverter<ActivePusRequestStd, ModeRequest> for ModeRequestCo
         verif_reporter: &impl VerificationReportingProvider,
         time_stamp: &[u8],
     ) -> Result<(ActivePusRequestStd, ModeRequest), Self::Error> {
-        let subservice = tc.message_subtype_id();
+        let subservice = tc.subservice();
         let user_data = tc.user_data();
         let not_enough_app_data = |expected: usize| {
             verif_reporter
@@ -222,7 +210,7 @@ impl PusTcToRequestConverter<ActivePusRequestStd, ModeRequest> for ModeRequestCo
 
 pub fn create_mode_service(
     tm_sender: TmTcSender,
-    tc_in_mem_converter: EcssTcCacher,
+    tc_in_mem_converter: EcssTcInMemConverter,
     pus_action_rx: mpsc::Receiver<EcssTcAndToken>,
     mode_router: GenericRequestRouter,
     reply_receiver: mpsc::Receiver<GenericMessage<ModeReply>>,
@@ -302,11 +290,8 @@ impl TargetedPusService for ModeServiceWrapper {
 
 #[cfg(test)]
 mod tests {
-    use arbitrary_int::traits::Integer;
-    use arbitrary_int::u14;
     use satrs::pus::test_util::{TEST_APID, TEST_COMPONENT_ID_0, TEST_UNIQUE_ID_0};
     use satrs::request::MessageMetadata;
-    use satrs::spacepackets::ecss::{CreatorConfig, MessageTypeId};
     use satrs::{
         mode::{ModeAndSubmode, ModeReply, ModeRequest},
         pus::mode::Subservice,
@@ -329,12 +314,11 @@ mod tests {
     fn mode_converter_read_mode_request() {
         let mut testbench =
             PusConverterTestbench::new(TEST_COMPONENT_ID_0.id(), ModeRequestConverter::default());
-        let sp_header = SpHeader::new_for_unseg_tc(TEST_APID, u14::ZERO, 0);
-        let sec_header =
-            PusTcSecondaryHeader::new_simple(MessageTypeId::new(200, Subservice::TcReadMode as u8));
+        let sp_header = SpHeader::new_for_unseg_tc(TEST_APID, 0, 0);
+        let sec_header = PusTcSecondaryHeader::new_simple(200, Subservice::TcReadMode as u8);
         let mut app_data: [u8; 4] = [0; 4];
-        app_data[0..4].copy_from_slice(&TEST_UNIQUE_ID_0.as_u32().to_be_bytes());
-        let tc = PusTcCreator::new(sp_header, sec_header, &app_data, CreatorConfig::default());
+        app_data[0..4].copy_from_slice(&TEST_UNIQUE_ID_0.to_be_bytes());
+        let tc = PusTcCreator::new(sp_header, sec_header, &app_data, true);
         let token = testbench.add_tc(&tc);
         let (_active_req, req) = testbench
             .convert(token, &[], TEST_APID, TEST_UNIQUE_ID_0)
@@ -346,16 +330,15 @@ mod tests {
     fn mode_converter_set_mode_request() {
         let mut testbench =
             PusConverterTestbench::new(TEST_COMPONENT_ID_0.id(), ModeRequestConverter::default());
-        let sp_header = SpHeader::new_for_unseg_tc(TEST_APID, u14::ZERO, 0);
-        let sec_header =
-            PusTcSecondaryHeader::new_simple(MessageTypeId::new(200, Subservice::TcSetMode as u8));
+        let sp_header = SpHeader::new_for_unseg_tc(TEST_APID, 0, 0);
+        let sec_header = PusTcSecondaryHeader::new_simple(200, Subservice::TcSetMode as u8);
         let mut app_data: [u8; 4 + ModeAndSubmode::RAW_LEN] = [0; 4 + ModeAndSubmode::RAW_LEN];
         let mode_and_submode = ModeAndSubmode::new(2, 1);
-        app_data[0..4].copy_from_slice(&TEST_UNIQUE_ID_0.as_u32().to_be_bytes());
+        app_data[0..4].copy_from_slice(&TEST_UNIQUE_ID_0.to_be_bytes());
         mode_and_submode
             .write_to_be_bytes(&mut app_data[4..])
             .unwrap();
-        let tc = PusTcCreator::new(sp_header, sec_header, &app_data, CreatorConfig::default());
+        let tc = PusTcCreator::new(sp_header, sec_header, &app_data, true);
         let token = testbench.add_tc(&tc);
         let (_active_req, req) = testbench
             .convert(token, &[], TEST_APID, TEST_UNIQUE_ID_0)
@@ -373,14 +356,11 @@ mod tests {
     fn mode_converter_announce_mode() {
         let mut testbench =
             PusConverterTestbench::new(TEST_COMPONENT_ID_0.id(), ModeRequestConverter::default());
-        let sp_header = SpHeader::new_for_unseg_tc(TEST_APID, u14::ZERO, 0);
-        let sec_header = PusTcSecondaryHeader::new_simple(MessageTypeId::new(
-            200,
-            Subservice::TcAnnounceMode as u8,
-        ));
+        let sp_header = SpHeader::new_for_unseg_tc(TEST_APID, 0, 0);
+        let sec_header = PusTcSecondaryHeader::new_simple(200, Subservice::TcAnnounceMode as u8);
         let mut app_data: [u8; 4] = [0; 4];
-        app_data[0..4].copy_from_slice(&TEST_UNIQUE_ID_0.as_u32().to_be_bytes());
-        let tc = PusTcCreator::new(sp_header, sec_header, &app_data, CreatorConfig::default());
+        app_data[0..4].copy_from_slice(&TEST_UNIQUE_ID_0.to_be_bytes());
+        let tc = PusTcCreator::new(sp_header, sec_header, &app_data, true);
         let token = testbench.add_tc(&tc);
         let (_active_req, req) = testbench
             .convert(token, &[], TEST_APID, TEST_UNIQUE_ID_0)
@@ -392,14 +372,12 @@ mod tests {
     fn mode_converter_announce_mode_recursively() {
         let mut testbench =
             PusConverterTestbench::new(TEST_COMPONENT_ID_0.id(), ModeRequestConverter::default());
-        let sp_header = SpHeader::new_for_unseg_tc(TEST_APID, u14::ZERO, 0);
-        let sec_header = PusTcSecondaryHeader::new_simple(MessageTypeId::new(
-            200,
-            Subservice::TcAnnounceModeRecursive as u8,
-        ));
+        let sp_header = SpHeader::new_for_unseg_tc(TEST_APID, 0, 0);
+        let sec_header =
+            PusTcSecondaryHeader::new_simple(200, Subservice::TcAnnounceModeRecursive as u8);
         let mut app_data: [u8; 4] = [0; 4];
-        app_data[0..4].copy_from_slice(&TEST_UNIQUE_ID_0.as_u32().to_be_bytes());
-        let tc = PusTcCreator::new(sp_header, sec_header, &app_data, CreatorConfig::default());
+        app_data[0..4].copy_from_slice(&TEST_UNIQUE_ID_0.to_be_bytes());
+        let tc = PusTcCreator::new(sp_header, sec_header, &app_data, true);
         let token = testbench.add_tc(&tc);
         let (_active_req, req) = testbench
             .convert(token, &[], TEST_APID, TEST_UNIQUE_ID_0)
@@ -415,7 +393,7 @@ mod tests {
         );
         let mode_reply = ModeReply::ModeReply(ModeAndSubmode::new(5, 1));
         let unrequested_reply =
-            GenericMessage::new(MessageMetadata::new(10_u32, 15_u32), mode_reply);
+            GenericMessage::new(MessageMetadata::new(10_u32, 15_u64), mode_reply);
         // Right now this function does not do a lot. We simply check that it does not panic or do
         // weird stuff.
         let result = testbench.handle_unrequested_reply(&unrequested_reply);

satrs-example/src/pus/scheduler.rs

@@ -5,11 +5,11 @@ use crate::pus::create_verification_reporter;
 use crate::tmtc::sender::TmTcSender;
 use log::info;
 use satrs::pool::{PoolProvider, StaticMemoryPool};
-use satrs::pus::scheduler::{PusSchedulerAlloc, TcInfo};
+use satrs::pus::scheduler::{PusScheduler, TcInfo};
 use satrs::pus::scheduler_srv::PusSchedServiceHandler;
 use satrs::pus::verification::VerificationReporter;
 use satrs::pus::{
-    DirectPusPacketHandlerResult, EcssTcAndToken, EcssTcCacher, MpscTcReceiver,
+    DirectPusPacketHandlerResult, EcssTcAndToken, EcssTcInMemConverter, MpscTcReceiver,
     PartialPusHandlingError, PusServiceHelper,
 };
 use satrs::spacepackets::ecss::PusServiceId;
@@ -84,9 +84,9 @@ pub struct SchedulingServiceWrapper {
     pub pus_11_handler: PusSchedServiceHandler<
         MpscTcReceiver,
         TmTcSender,
-        EcssTcCacher,
+        EcssTcInMemConverter,
         VerificationReporter,
-        PusSchedulerAlloc,
+        PusScheduler,
     >,
     pub sched_tc_pool: StaticMemoryPool,
     pub releaser_buf: [u8; 4096],
@@ -174,12 +174,12 @@ impl SchedulingServiceWrapper {
 
 pub fn create_scheduler_service(
     tm_sender: TmTcSender,
-    tc_in_mem_converter: EcssTcCacher,
+    tc_in_mem_converter: EcssTcInMemConverter,
     tc_releaser: TcReleaser,
     pus_sched_rx: mpsc::Receiver<EcssTcAndToken>,
     sched_tc_pool: StaticMemoryPool,
 ) -> SchedulingServiceWrapper {
-    let scheduler = PusSchedulerAlloc::new_with_current_init_time(Duration::from_secs(5))
+    let scheduler = PusScheduler::new_with_current_init_time(Duration::from_secs(5))
         .expect("Creating PUS Scheduler failed");
     let pus_11_handler = PusSchedServiceHandler::new(
         PusServiceHelper::new(

satrs-example/src/pus/test.rs

@@ -1,13 +1,13 @@
 use crate::pus::create_verification_reporter;
 use crate::tmtc::sender::TmTcSender;
 use log::info;
-use satrs::event_man_legacy::{EventMessage, EventMessageU32};
+use satrs::event_man::{EventMessage, EventMessageU32};
 use satrs::pus::test::PusService17TestHandler;
 use satrs::pus::verification::{FailParams, VerificationReporter, VerificationReportingProvider};
 use satrs::pus::PartialPusHandlingError;
 use satrs::pus::{
-    CacheAndReadRawEcssTc, DirectPusPacketHandlerResult, EcssTcAndToken, EcssTcCacher,
-    MpscTcReceiver, PusServiceHelper,
+    DirectPusPacketHandlerResult, EcssTcAndToken, EcssTcInMemConversionProvider,
+    EcssTcInMemConverter, MpscTcReceiver, PusServiceHelper,
 };
 use satrs::spacepackets::ecss::tc::PusTcReader;
 use satrs::spacepackets::ecss::{PusPacket, PusServiceId};
@@ -19,7 +19,7 @@ use super::{DirectPusService, HandlingStatus};
 
 pub fn create_test_service(
     tm_sender: TmTcSender,
-    tc_in_mem_converter: EcssTcCacher,
+    tc_in_mem_converter: EcssTcInMemConverter,
     event_sender: mpsc::SyncSender<EventMessageU32>,
     pus_test_rx: mpsc::Receiver<EcssTcAndToken>,
 ) -> TestCustomServiceWrapper {
@@ -37,8 +37,12 @@ pub fn create_test_service(
 }
 
 pub struct TestCustomServiceWrapper {
-    pub handler:
-        PusService17TestHandler<MpscTcReceiver, TmTcSender, EcssTcCacher, VerificationReporter>,
+    pub handler: PusService17TestHandler<
+        MpscTcReceiver,
+        TmTcSender,
+        EcssTcInMemConverter,
+        VerificationReporter,
+    >,
     pub event_tx: mpsc::SyncSender<EventMessageU32>,
 }
 
@@ -122,7 +126,7 @@ impl DirectPusService for TestCustomServiceWrapper {
                         }
                     }
                 } else {
-                    let fail_data = [tc.message_subtype_id()];
+                    let fail_data = [tc.subservice()];
                     self.handler
                         .service_helper
                         .verif_reporter()

satrs-example/src/requests.rs

@@ -8,15 +8,15 @@ use satrs::mode::ModeRequest;
 use satrs::pus::verification::{
     FailParams, TcStateAccepted, VerificationReportingProvider, VerificationToken,
 };
-use satrs::pus::{ActiveRequest, EcssTmSender, GenericRoutingError, PusRequestRouter};
+use satrs::pus::{ActiveRequestProvider, EcssTmSender, GenericRoutingError, PusRequestRouter};
 use satrs::queue::GenericSendError;
 use satrs::request::{GenericMessage, MessageMetadata, UniqueApidTargetId};
 use satrs::spacepackets::ecss::tc::PusTcReader;
 use satrs::spacepackets::ecss::PusPacket;
 use satrs::ComponentId;
 use satrs_example::config::tmtc_err;
+use satrs_example::ids;
 
-/*
 #[derive(Clone, Debug)]
 #[non_exhaustive]
 pub enum CompositeRequest {
@@ -46,7 +46,7 @@ impl Default for GenericRequestRouter {
 impl GenericRequestRouter {
     pub(crate) fn handle_error_generic(
         &self,
-        active_request: &impl ActiveRequest,
+        active_request: &impl ActiveRequestProvider,
         tc: &PusTcReader,
         error: GenericRoutingError,
         tm_sender: &(impl EcssTmSender + ?Sized),
@@ -55,7 +55,7 @@ impl GenericRequestRouter {
     ) {
         warn!(
             "Routing request for service {} failed: {error:?}",
-            tc.service_type_id()
+            tc.service()
         );
         let accepted_token: VerificationToken<TcStateAccepted> = active_request
             .token()
@@ -66,8 +66,7 @@ impl GenericRequestRouter {
                 let apid_target_id = UniqueApidTargetId::from(id);
                 warn!("Target APID for request: {}", apid_target_id.apid);
                 warn!("Target Unique ID for request: {}", apid_target_id.unique_id);
-                let mut fail_data: [u8; core::mem::size_of::<ComponentId>()] =
-                    [0; core::mem::size_of::<ComponentId>()];
+                let mut fail_data: [u8; 8] = [0; 8];
                 fail_data.copy_from_slice(&id.to_be_bytes());
                 verif_reporter
                     .completion_failure(
@@ -153,4 +152,3 @@ impl PusRequestRouter<ModeRequest> for GenericRequestRouter {
         Err(GenericRoutingError::UnknownTargetId(target_id))
     }
 }
-*/

satrs-example/src/spi.rs

@@ -0,0 +1,6 @@
+use core::fmt::Debug;
+
+pub trait SpiInterface {
+    type Error: Debug;
+    fn transfer(&mut self, tx: &[u8], rx: &mut [u8]) -> Result<(), Self::Error>;
+}

satrs-example/src/tmtc/sender.rs

@@ -1,9 +1,11 @@
 use std::{cell::RefCell, collections::VecDeque, sync::mpsc};
 
 use satrs::{
-    ComponentId,
+    pus::EcssTmSender,
     queue::GenericSendError,
-    tmtc::{PacketAsVec, PacketHandler},
+    spacepackets::ecss::WritablePusPacket,
+    tmtc::{PacketAsVec, PacketSenderRaw, PacketSenderWithSharedPool, StoreAndSendError},
+    ComponentId,
 };
 
 #[derive(Default, Debug, Clone)]
@@ -12,7 +14,8 @@ pub struct MockSender(pub RefCell<VecDeque<PacketAsVec>>);
 #[allow(dead_code)]
 #[derive(Debug, Clone)]
 pub enum TmTcSender {
-    Normal(mpsc::SyncSender<PacketAsVec>),
+    Static(PacketSenderWithSharedPool),
+    Heap(mpsc::SyncSender<PacketAsVec>),
     Mock(MockSender),
 }
 
@@ -26,28 +29,45 @@ impl TmTcSender {
     }
 }
 
-impl PacketHandler for TmTcSender {
-    type Error = GenericSendError;
-
-    fn handle_packet(&self, sender_id: ComponentId, packet: &[u8]) -> Result<(), Self::Error> {
+impl EcssTmSender for TmTcSender {
+    fn send_tm(
+        &self,
+        sender_id: satrs::ComponentId,
+        tm: satrs::pus::PusTmVariant,
+    ) -> Result<(), satrs::pus::EcssTmtcError> {
         match self {
-            TmTcSender::Normal(sync_sender) => {
-                if let Err(e) = sync_sender.send(PacketAsVec::new(sender_id, packet.to_vec())) {
-                    log::error!("Error sending packet via Heap TM/TC sender: {:?}", e);
-                }
-            }
-            TmTcSender::Mock(sender) => {
-                sender.handle_packet(sender_id, packet).unwrap();
-            }
+            TmTcSender::Static(sync_sender) => sync_sender.send_tm(sender_id, tm),
+            TmTcSender::Heap(sync_sender) => match tm {
+                satrs::pus::PusTmVariant::InStore(_) => panic!("can not send TM in store"),
+                satrs::pus::PusTmVariant::Direct(pus_tm_creator) => sync_sender
+                    .send(PacketAsVec::new(sender_id, pus_tm_creator.to_vec()?))
+                    .map_err(|_| GenericSendError::RxDisconnected.into()),
+            },
+            TmTcSender::Mock(_) => Ok(()),
         }
-        Ok(())
     }
 }
 
-impl PacketHandler for MockSender {
-    type Error = GenericSendError;
+impl PacketSenderRaw for TmTcSender {
+    type Error = StoreAndSendError;
 
-    fn handle_packet(&self, sender_id: ComponentId, tc_raw: &[u8]) -> Result<(), Self::Error> {
+    fn send_packet(&self, sender_id: ComponentId, packet: &[u8]) -> Result<(), Self::Error> {
+        match self {
+            TmTcSender::Static(packet_sender_with_shared_pool) => {
+                packet_sender_with_shared_pool.send_packet(sender_id, packet)
+            }
+            TmTcSender::Heap(sync_sender) => sync_sender
+                .send_packet(sender_id, packet)
+                .map_err(StoreAndSendError::Send),
+            TmTcSender::Mock(sender) => sender.send_packet(sender_id, packet),
+        }
+    }
+}
+
+impl PacketSenderRaw for MockSender {
+    type Error = StoreAndSendError;
+
+    fn send_packet(&self, sender_id: ComponentId, tc_raw: &[u8]) -> Result<(), Self::Error> {
         let mut mut_queue = self.0.borrow_mut();
         mut_queue.push_back(PacketAsVec::new(sender_id, tc_raw.to_vec()));
         Ok(())

satrs-example/src/tmtc/tc_source.rs

@@ -1,88 +1,57 @@
-use models::{ComponentId, TcHeader, ccsds::CcsdsTcPacketOwned};
 use satrs::{
+    pool::PoolProvider,
     pus::HandlingStatus,
-    spacepackets::{CcsdsPacketReader, ChecksumType},
-    tmtc::PacketAsVec,
-};
-use std::{
-    collections::HashMap,
-    sync::mpsc::{self, TryRecvError},
+    tmtc::{PacketAsVec, PacketInPool, SharedPacketPool},
 };
+use std::sync::mpsc::{self, TryRecvError};
 
-pub type CcsdsDistributor = HashMap<ComponentId, std::sync::mpsc::SyncSender<CcsdsTcPacketOwned>>;
+use crate::pus::PusTcDistributor;
 
-// TC source components where the heap is the backing memory of the received telecommands.
-pub struct TcSourceTask {
-    pub tc_receiver: mpsc::Receiver<PacketAsVec>,
-    ccsds_distributor: CcsdsDistributor,
+// TC source components where static pools are the backing memory of the received telecommands.
+pub struct TcSourceTaskStatic {
+    shared_tc_pool: SharedPacketPool,
+    tc_receiver: mpsc::Receiver<PacketInPool>,
+    /// We allocate this buffer from the heap to avoid a clippy warning on large enum variant
+    /// differences.
+    tc_buf: Box<[u8; 4096]>,
+    pus_distributor: PusTcDistributor,
 }
 
-impl TcSourceTask {
+#[allow(dead_code)]
+impl TcSourceTaskStatic {
     pub fn new(
-        tc_receiver: mpsc::Receiver<PacketAsVec>,
-        ccsds_distributor: CcsdsDistributor,
+        shared_tc_pool: SharedPacketPool,
+        tc_receiver: mpsc::Receiver<PacketInPool>,
+        pus_receiver: PusTcDistributor,
     ) -> Self {
         Self {
+            shared_tc_pool,
             tc_receiver,
-            ccsds_distributor,
+            tc_buf: Box::new([0; 4096]),
+            pus_distributor: pus_receiver,
         }
     }
 
-    pub fn add_target(
-        &mut self,
-        target_id: ComponentId,
-        sender: mpsc::SyncSender<CcsdsTcPacketOwned>,
-    ) {
-        self.ccsds_distributor.insert(target_id, sender);
-    }
-
     pub fn periodic_operation(&mut self) {
-        loop {
-            if self.poll_tc() == HandlingStatus::Empty {
-                break;
-            }
-        }
+        self.poll_tc();
     }
 
     pub fn poll_tc(&mut self) -> HandlingStatus {
+        // Right now, we only expect ECSS PUS packets.
+        // If packets like CFDP are expected, we might have to check the APID first.
         match self.tc_receiver.try_recv() {
-            Ok(packet) => {
-                log::debug!("received raw packet: {:?}", packet);
-                let ccsds_tc_reader_result =
-                    CcsdsPacketReader::new(&packet.packet, Some(ChecksumType::WithCrc16));
-                if ccsds_tc_reader_result.is_err() {
-                    log::warn!(
-                        "received invalid CCSDS TC packet: {:?}",
-                        ccsds_tc_reader_result.err()
-                    );
-                    // TODO: Send a dedicated TM packet.
-                    return HandlingStatus::HandledOne;
-                }
-                let ccsds_tc_reader = ccsds_tc_reader_result.unwrap();
-                let tc_header_result =
-                    postcard::take_from_bytes::<TcHeader>(ccsds_tc_reader.user_data());
-                if tc_header_result.is_err() {
-                    log::warn!(
-                        "received CCSDS TC packet with invalid TC header: {:?}",
-                        tc_header_result.err()
-                    );
-                    // TODO: Send a dedicated TM packet.
-                    return HandlingStatus::HandledOne;
-                }
-                let (tc_header, payload) = tc_header_result.unwrap();
-                if let Some(sender) = self.ccsds_distributor.get(&tc_header.target_id) {
-                    log::debug!("sending TC packet to target ID: {:?}", tc_header.target_id);
-                    sender
-                        .send(CcsdsTcPacketOwned {
-                            sp_header: *ccsds_tc_reader.sp_header(),
-                            tc_header,
-                            payload: payload.to_vec(),
-                        })
-                        .ok();
-                } else {
-                    log::warn!("no TC handler for target ID {:?}", tc_header.target_id);
-                    // TODO: Send a dedicated TM packet.
-                }
+            Ok(packet_in_pool) => {
+                let pool = self
+                    .shared_tc_pool
+                    .0
+                    .read()
+                    .expect("locking tc pool failed");
+                pool.read(&packet_in_pool.store_addr, self.tc_buf.as_mut_slice())
+                    .expect("reading pool failed");
+                drop(pool);
+                self.pus_distributor
+                    .handle_tc_packet_in_store(packet_in_pool, self.tc_buf.as_slice())
+                    .ok();
                 HandlingStatus::HandledOne
             }
             Err(e) => match e {
@@ -95,3 +64,58 @@ impl TcSourceTask {
         }
     }
 }
+
+// TC source components where the heap is the backing memory of the received telecommands.
+pub struct TcSourceTaskDynamic {
+    pub tc_receiver: mpsc::Receiver<PacketAsVec>,
+    pus_distributor: PusTcDistributor,
+}
+
+#[allow(dead_code)]
+impl TcSourceTaskDynamic {
+    pub fn new(tc_receiver: mpsc::Receiver<PacketAsVec>, pus_receiver: PusTcDistributor) -> Self {
+        Self {
+            tc_receiver,
+            pus_distributor: pus_receiver,
+        }
+    }
+
+    pub fn periodic_operation(&mut self) {
+        self.poll_tc();
+    }
+
+    pub fn poll_tc(&mut self) -> HandlingStatus {
+        // Right now, we only expect ECSS PUS packets.
+        // If packets like CFDP are expected, we might have to check the APID first.
+        match self.tc_receiver.try_recv() {
+            Ok(packet_as_vec) => {
+                self.pus_distributor
+                    .handle_tc_packet_vec(packet_as_vec)
+                    .ok();
+                HandlingStatus::HandledOne
+            }
+            Err(e) => match e {
+                TryRecvError::Empty => HandlingStatus::Empty,
+                TryRecvError::Disconnected => {
+                    log::warn!("tmtc thread: sender disconnected");
+                    HandlingStatus::Empty
+                }
+            },
+        }
+    }
+}
+
+#[allow(dead_code)]
+pub enum TcSourceTask {
+    Static(TcSourceTaskStatic),
+    Heap(TcSourceTaskDynamic),
+}
+
+impl TcSourceTask {
+    pub fn periodic_operation(&mut self) {
+        match self {
+            TcSourceTask::Static(task) => task.periodic_operation(),
+            TcSourceTask::Heap(task) => task.periodic_operation(),
+        }
+    }
+}

satrs-example/src/tmtc/tm_sink.rs

@@ -3,56 +3,179 @@ use std::{
     sync::mpsc::{self},
 };
 
-use arbitrary_int::{u11, u14};
-use models::ccsds::CcsdsTmPacketOwned;
-use satrs::spacepackets::seq_count::{SequenceCounter, SequenceCounterCcsdsSimple};
+use log::info;
+use satrs::{
+    pool::PoolProvider,
+    spacepackets::{
+        ecss::{tm::PusTmZeroCopyWriter, PusPacket},
+        seq_count::CcsdsSimpleSeqCountProvider,
+        time::cds::MIN_CDS_FIELD_LEN,
+        CcsdsPacket,
+    },
+};
+use satrs::{
+    spacepackets::seq_count::SequenceCountProvider,
+    tmtc::{PacketAsVec, PacketInPool, SharedPacketPool},
+};
 
 use crate::interface::tcp::SyncTcpTmSource;
 
 #[derive(Default)]
 pub struct CcsdsSeqCounterMap {
-    apid_seq_counter_map: HashMap<u11, SequenceCounterCcsdsSimple>,
+    apid_seq_counter_map: HashMap<u16, CcsdsSimpleSeqCountProvider>,
 }
 impl CcsdsSeqCounterMap {
-    pub fn get_and_increment(&mut self, apid: u11) -> u14 {
-        u14::new(
-            self.apid_seq_counter_map
-                .entry(apid)
-                .or_default()
-                .get_and_increment(),
-        )
+    pub fn get_and_increment(&mut self, apid: u16) -> u16 {
+        self.apid_seq_counter_map
+            .entry(apid)
+            .or_default()
+            .get_and_increment()
     }
 }
 
-pub struct TmSink {
+pub struct TmFunnelCommon {
     seq_counter_map: CcsdsSeqCounterMap,
+    msg_counter_map: HashMap<u8, u16>,
     sync_tm_tcp_source: SyncTcpTmSource,
-    tm_funnel_rx: mpsc::Receiver<CcsdsTmPacketOwned>,
-    tm_server_tx: mpsc::SyncSender<CcsdsTmPacketOwned>,
 }
 
-impl TmSink {
-    pub fn new(
-        sync_tm_tcp_source: SyncTcpTmSource,
-        tm_funnel_rx: mpsc::Receiver<CcsdsTmPacketOwned>,
-        tm_server_tx: mpsc::SyncSender<CcsdsTmPacketOwned>,
-    ) -> Self {
+impl TmFunnelCommon {
+    pub fn new(sync_tm_tcp_source: SyncTcpTmSource) -> Self {
         Self {
             seq_counter_map: Default::default(),
+            msg_counter_map: Default::default(),
             sync_tm_tcp_source,
+        }
+    }
+
+    // Applies common packet processing operations for PUS TM packets. This includes setting
+    // a sequence counter
+    fn apply_packet_processing(&mut self, mut zero_copy_writer: PusTmZeroCopyWriter) {
+        // zero_copy_writer.set_apid(PUS_APID);
+        zero_copy_writer.set_seq_count(
+            self.seq_counter_map
+                .get_and_increment(zero_copy_writer.apid()),
+        );
+        let entry = self
+            .msg_counter_map
+            .entry(zero_copy_writer.service())
+            .or_insert(0);
+        zero_copy_writer.set_msg_count(*entry);
+        if *entry == u16::MAX {
+            *entry = 0;
+        } else {
+            *entry += 1;
+        }
+
+        Self::packet_printout(&zero_copy_writer);
+        // This operation has to come last!
+        zero_copy_writer.finish();
+    }
+
+    fn packet_printout(tm: &PusTmZeroCopyWriter) {
+        info!(
+            "Sending PUS TM[{},{}] with APID {}",
+            tm.service(),
+            tm.subservice(),
+            tm.apid()
+        );
+    }
+}
+
+pub struct TmSinkStatic {
+    common: TmFunnelCommon,
+    shared_tm_store: SharedPacketPool,
+    tm_funnel_rx: mpsc::Receiver<PacketInPool>,
+    tm_server_tx: mpsc::SyncSender<PacketInPool>,
+}
+
+#[allow(dead_code)]
+impl TmSinkStatic {
+    pub fn new(
+        shared_tm_store: SharedPacketPool,
+        sync_tm_tcp_source: SyncTcpTmSource,
+        tm_funnel_rx: mpsc::Receiver<PacketInPool>,
+        tm_server_tx: mpsc::SyncSender<PacketInPool>,
+    ) -> Self {
+        Self {
+            common: TmFunnelCommon::new(sync_tm_tcp_source),
+            shared_tm_store,
             tm_funnel_rx,
             tm_server_tx,
         }
     }
 
     pub fn operation(&mut self) {
-        if let Ok(mut tm) = self.tm_funnel_rx.try_recv() {
-            tm.sp_header
-                .set_seq_count(self.seq_counter_map.get_and_increment(tm.sp_header.apid()));
-            self.sync_tm_tcp_source.add_tm(&tm.to_vec());
+        if let Ok(pus_tm_in_pool) = self.tm_funnel_rx.recv() {
+            // Read the TM, set sequence counter and message counter, and finally update
+            // the CRC.
+            let shared_pool = self.shared_tm_store.0.clone();
+            let mut pool_guard = shared_pool.write().expect("Locking TM pool failed");
+            let mut tm_copy = Vec::new();
+            pool_guard
+                .modify(&pus_tm_in_pool.store_addr, |buf| {
+                    let zero_copy_writer = PusTmZeroCopyWriter::new(buf, MIN_CDS_FIELD_LEN)
+                        .expect("Creating TM zero copy writer failed");
+                    self.common.apply_packet_processing(zero_copy_writer);
+                    tm_copy = buf.to_vec()
+                })
+                .expect("Reading TM from pool failed");
+            self.tm_server_tx
+                .send(pus_tm_in_pool)
+                .expect("Sending TM to server failed");
+            // We could also do this step in the update closure, but I'd rather avoid this, could
+            // lead to nested locking.
+            self.common.sync_tm_tcp_source.add_tm(&tm_copy);
+        }
+    }
+}
+
+pub struct TmSinkDynamic {
+    common: TmFunnelCommon,
+    tm_funnel_rx: mpsc::Receiver<PacketAsVec>,
+    tm_server_tx: mpsc::SyncSender<PacketAsVec>,
+}
+
+#[allow(dead_code)]
+impl TmSinkDynamic {
+    pub fn new(
+        sync_tm_tcp_source: SyncTcpTmSource,
+        tm_funnel_rx: mpsc::Receiver<PacketAsVec>,
+        tm_server_tx: mpsc::SyncSender<PacketAsVec>,
+    ) -> Self {
+        Self {
+            common: TmFunnelCommon::new(sync_tm_tcp_source),
+            tm_funnel_rx,
+            tm_server_tx,
+        }
+    }
+
+    pub fn operation(&mut self) {
+        if let Ok(mut tm) = self.tm_funnel_rx.recv() {
+            // Read the TM, set sequence counter and message counter, and finally update
+            // the CRC.
+            let zero_copy_writer = PusTmZeroCopyWriter::new(&mut tm.packet, MIN_CDS_FIELD_LEN)
+                .expect("Creating TM zero copy writer failed");
+            self.common.apply_packet_processing(zero_copy_writer);
+            self.common.sync_tm_tcp_source.add_tm(&tm.packet);
             self.tm_server_tx
                 .send(tm)
                 .expect("Sending TM to server failed");
         }
     }
 }
+
+#[allow(dead_code)]
+pub enum TmSink {
+    Static(TmSinkStatic),
+    Heap(TmSinkDynamic),
+}
+
+impl TmSink {
+    pub fn operation(&mut self) {
+        match self {
+            TmSink::Static(static_sink) => static_sink.operation(),
+            TmSink::Heap(dynamic_sink) => dynamic_sink.operation(),
+        }
+    }
+}

satrs-mib/CHANGELOG.md

@@ -8,10 +8,6 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 
 # [unreleased]
 
-# [v0.1.3] 2024-08-26
-
-Bump `satrs-shared`.
-
 # [v0.1.2] 2024-04-17
 
 Allow `satrs-shared` from `v0.1.3` to `<v0.2`.
@@ -23,6 +19,3 @@ Allow `satrs-shared` from `v0.1.3` to `<v0.2`.
 # [v0.1.0] 2024-02-12
 
 Initial release containing the `resultcode` macro.
-
-[unreleased]: https://egit.irs.uni-stuttgart.de/rust/sat-rs/compare/satrs-mib-v0.1.3...HEAD
-[v0.1.3]: https://egit.irs.uni-stuttgart.de/rust/sat-rs/compare/satrs-mib-v0.1.2...satrs-mib-v0.1.3

satrs-mib/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "satrs-mib"
-version = "0.1.3"
+version = "0.1.2"
 edition = "2021"
 rust-version = "1.61"
 authors = ["Robin Mueller <muellerr@irs.uni-stuttgart.de>"]
@@ -23,7 +23,7 @@ version = "1"
 optional = true
 
 [dependencies.satrs-shared]
-version = "0.2"
+version = "0.2.2"
 path = "../satrs-shared"
 features = ["serde"]
 

satrs-mib/codegen/Cargo.toml

@@ -28,7 +28,7 @@ features = ["full"]
 trybuild = { version = "1", features = ["diff"] }
 
 [dev-dependencies.satrs-shared]
-version = "0.2"
+version = "0.2.2"
 path = "../../satrs-shared"
 
 [dev-dependencies.satrs-mib]

satrs-minisim/Cargo.toml

@@ -11,14 +11,16 @@ serde_json = "1"
 log = "0.4"
 thiserror = "2"
 fern = "0.7"
-strum = { version = "0.28", features = ["derive"] }
+strum = { version = "0.26", features = ["derive"] }
 num_enum = "0.7"
 humantime = "2"
 tai-time = { version = "0.3", features = ["serde"] }
-nexosim = { version = "0.3.1" }
 
-satrs = { path = "../../satrs" }
-models = { path = "../models" }
+[dependencies.nexosim]
+version = "0.3.1"
+
+[dependencies.satrs]
+path = "../satrs"
 
 [dev-dependencies]
 delegate = "0.13"

satrs-minisim/src/acs.rs

@@ -1,10 +1,10 @@
 use std::{f32::consts::PI, sync::mpsc, time::Duration};
 
-use models::pcdu::SwitchStateBinary;
 use nexosim::{
     model::{Context, Model},
     ports::Output,
 };
+use satrs::power::SwitchStateBinary;
 use satrs_minisim::{
     acs::{
         lis3mdl::MgmLis3MdlReply, MgmReplyCommon, MgmReplyProvider, MgmSensorValuesMicroTesla,
@@ -179,12 +179,13 @@ impl Model for MagnetorquerModel {}
 pub mod tests {
     use std::time::Duration;
 
-    use models::pcdu::{SwitchId, SwitchStateBinary};
+    use satrs::power::SwitchStateBinary;
     use satrs_minisim::{
         acs::{
             lis3mdl::{self, MgmLis3MdlReply},
             MgmRequestLis3Mdl, MgtDipole, MgtHkSet, MgtReply, MgtRequest,
         },
+        eps::PcduSwitch,
         SerializableSimMsgPayload, SimComponent, SimMessageProvider, SimRequest,
     };
 
@@ -214,7 +215,7 @@ pub mod tests {
     #[test]
     fn test_basic_mgm_request_switched_on() {
         let mut sim_testbench = SimTestbench::new();
-        switch_device_on(&mut sim_testbench, SwitchId::Mgm0);
+        switch_device_on(&mut sim_testbench, PcduSwitch::Mgm);
 
         let mut request = SimRequest::new_with_epoch_time(MgmRequestLis3Mdl::RequestSensorData);
         sim_testbench
@@ -278,7 +279,7 @@ pub mod tests {
     #[test]
     fn test_basic_mgt_request_is_on() {
         let mut sim_testbench = SimTestbench::new();
-        switch_device_on(&mut sim_testbench, SwitchId::Mgt);
+        switch_device_on(&mut sim_testbench, PcduSwitch::Mgt);
         let request = SimRequest::new_with_epoch_time(MgtRequest::RequestHk);
 
         sim_testbench
@@ -323,7 +324,7 @@ pub mod tests {
     #[test]
     fn test_basic_mgt_request_is_on_and_torquing() {
         let mut sim_testbench = SimTestbench::new();
-        switch_device_on(&mut sim_testbench, SwitchId::Mgt);
+        switch_device_on(&mut sim_testbench, PcduSwitch::Mgt);
         let commanded_dipole = MgtDipole {
             x: -200,
             y: 200,

satrs-minisim/src/controller.rs

@@ -120,7 +120,7 @@ impl SimController {
     fn handle_ctrl_request(&mut self, request: &SimRequest) -> Result<(), SimRequestError> {
         let sim_ctrl_request = SimCtrlRequest::from_sim_message(request)?;
         if SIM_CTRL_REQ_WIRETAPPING {
-            log::info!("received sim ctrl request: {sim_ctrl_request:?}");
+            log::info!("received sim ctrl request: {:?}", sim_ctrl_request);
         }
         match sim_ctrl_request {
             SimCtrlRequest::Ping => {
@@ -139,7 +139,7 @@ impl SimController {
     ) -> Result<(), SimRequestError> {
         let mgm_request = MgmRequestLis3Mdl::from_sim_message(request)?;
         if MGM_REQ_WIRETAPPING {
-            log::info!("received MGM request: {mgm_request:?}");
+            log::info!("received MGM request: {:?}", mgm_request);
         }
         match mgm_request {
             MgmRequestLis3Mdl::RequestSensorData => {
@@ -160,7 +160,7 @@ impl SimController {
     fn handle_pcdu_request(&mut self, request: &SimRequest) -> Result<(), SimRequestError> {
         let pcdu_request = PcduRequest::from_sim_message(request)?;
         if PCDU_REQ_WIRETAPPING {
-            log::info!("received PCDU request: {pcdu_request:?}");
+            log::info!("received PCDU request: {:?}", pcdu_request);
         }
         match pcdu_request {
             PcduRequest::RequestSwitchInfo => {
@@ -188,7 +188,7 @@ impl SimController {
     fn handle_mgt_request(&mut self, request: &SimRequest) -> Result<(), SimRequestError> {
         let mgt_request = MgtRequest::from_sim_message(request)?;
         if MGT_REQ_WIRETAPPING {
-            log::info!("received MGT request: {mgt_request:?}");
+            log::info!("received MGT request: {:?}", mgt_request);
         }
         match mgt_request {
             MgtRequest::ApplyTorque { duration, dipole } => self

satrs-minisim/src/eps.rs

@@ -1,11 +1,14 @@
 use std::{sync::mpsc, time::Duration};
 
-use models::pcdu::{SwitchId, SwitchMapBinaryWrapper, SwitchStateBinary};
 use nexosim::{
     model::{Context, Model},
     ports::Output,
 };
-use satrs_minisim::{eps::PcduReply, SimReply};
+use satrs::power::SwitchStateBinary;
+use satrs_minisim::{
+    eps::{PcduReply, PcduSwitch, SwitchMapBinaryWrapper},
+    SimReply,
+};
 
 pub const SWITCH_INFO_DELAY_MS: u64 = 10;
 
@@ -42,12 +45,10 @@ impl PcduModel {
         self.reply_sender.send(reply).unwrap();
     }
 
-    pub async fn switch_device(&mut self, switch_and_target_state: (SwitchId, SwitchStateBinary)) {
-        log::info!(
-            "switching {:?} to {:?}",
-            switch_and_target_state.0,
-            switch_and_target_state.1
-        );
+    pub async fn switch_device(
+        &mut self,
+        switch_and_target_state: (PcduSwitch, SwitchStateBinary),
+    ) {
         let val = self
             .switcher_map
             .0
@@ -55,13 +56,12 @@ impl PcduModel {
             .unwrap_or_else(|| panic!("switch {:?} not found", switch_and_target_state.0));
         *val = switch_and_target_state.1;
         match switch_and_target_state.0 {
-            SwitchId::Mgm0 => {
+            PcduSwitch::Mgm => {
                 self.mgm_0_switch.send(switch_and_target_state.1).await;
             }
-            SwitchId::Mgt => {
+            PcduSwitch::Mgt => {
                 self.mgt_switch.send(switch_and_target_state.1).await;
             }
-            SwitchId::Mgm1 => todo!(),
         }
     }
 }
@@ -73,16 +73,16 @@ pub(crate) mod tests {
     use super::*;
     use std::time::Duration;
 
-    use models::pcdu::SwitchMapBinary;
     use satrs_minisim::{
-        eps::PcduRequest, SerializableSimMsgPayload, SimComponent, SimMessageProvider, SimRequest,
+        eps::{PcduRequest, SwitchMapBinary},
+        SerializableSimMsgPayload, SimComponent, SimMessageProvider, SimRequest,
     };
 
     use crate::test_helpers::SimTestbench;
 
     fn switch_device(
         sim_testbench: &mut SimTestbench,
-        switch: SwitchId,
+        switch: PcduSwitch,
         target: SwitchStateBinary,
     ) {
         let request = SimRequest::new_with_epoch_time(PcduRequest::SwitchDevice {
@@ -97,10 +97,10 @@ pub(crate) mod tests {
     }
 
     #[allow(dead_code)]
-    pub(crate) fn switch_device_off(sim_testbench: &mut SimTestbench, switch: SwitchId) {
+    pub(crate) fn switch_device_off(sim_testbench: &mut SimTestbench, switch: PcduSwitch) {
         switch_device(sim_testbench, switch, SwitchStateBinary::Off);
     }
-    pub(crate) fn switch_device_on(sim_testbench: &mut SimTestbench, switch: SwitchId) {
+    pub(crate) fn switch_device_on(sim_testbench: &mut SimTestbench, switch: PcduSwitch) {
         switch_device(sim_testbench, switch, SwitchStateBinary::On);
     }
 
@@ -128,7 +128,7 @@ pub(crate) mod tests {
         }
     }
 
-    fn test_pcdu_switching_single_switch(switch: SwitchId, target: SwitchStateBinary) {
+    fn test_pcdu_switching_single_switch(switch: PcduSwitch, target: SwitchStateBinary) {
         let mut sim_testbench = SimTestbench::new();
         switch_device(&mut sim_testbench, switch, target);
         let mut switcher_map = get_all_off_switch_map();
@@ -165,17 +165,17 @@ pub(crate) mod tests {
 
     #[test]
     fn test_pcdu_switching_mgm_on() {
-        test_pcdu_switching_single_switch(SwitchId::Mgm0, SwitchStateBinary::On);
+        test_pcdu_switching_single_switch(PcduSwitch::Mgm, SwitchStateBinary::On);
     }
 
     #[test]
     fn test_pcdu_switching_mgt_on() {
-        test_pcdu_switching_single_switch(SwitchId::Mgt, SwitchStateBinary::On);
+        test_pcdu_switching_single_switch(PcduSwitch::Mgt, SwitchStateBinary::On);
     }
 
     #[test]
     fn test_pcdu_switching_mgt_off() {
-        test_pcdu_switching_single_switch(SwitchId::Mgt, SwitchStateBinary::On);
-        test_pcdu_switching_single_switch(SwitchId::Mgt, SwitchStateBinary::Off);
+        test_pcdu_switching_single_switch(PcduSwitch::Mgt, SwitchStateBinary::On);
+        test_pcdu_switching_single_switch(PcduSwitch::Mgt, SwitchStateBinary::Off);
     }
 }

satrs-minisim/src/lib.rs

@@ -1,4 +1,5 @@
 use nexosim::time::MonotonicTime;
+use num_enum::{IntoPrimitive, TryFromPrimitive};
 use serde::{de::DeserializeOwned, Deserialize, Serialize};
 
 #[derive(Debug, Copy, Clone, PartialEq, Eq, Serialize, Deserialize, Hash)]
@@ -161,7 +162,73 @@ impl From<SimRequestError> for SimCtrlReply {
 
 pub mod eps {
     use super::*;
-    use models::pcdu::{SwitchId, SwitchMapBinary, SwitchStateBinary};
+    use satrs::power::{SwitchState, SwitchStateBinary};
+    use std::collections::HashMap;
+    use strum::{EnumIter, IntoEnumIterator};
+
+    pub type SwitchMap = HashMap<PcduSwitch, SwitchState>;
+    pub type SwitchMapBinary = HashMap<PcduSwitch, SwitchStateBinary>;
+
+    pub struct SwitchMapWrapper(pub SwitchMap);
+    pub struct SwitchMapBinaryWrapper(pub SwitchMapBinary);
+
+    #[derive(
+        Debug,
+        Copy,
+        Clone,
+        PartialEq,
+        Eq,
+        Serialize,
+        Deserialize,
+        Hash,
+        EnumIter,
+        IntoPrimitive,
+        TryFromPrimitive,
+    )]
+    #[repr(u16)]
+    pub enum PcduSwitch {
+        Mgm = 0,
+        Mgt = 1,
+    }
+
+    impl Default for SwitchMapBinaryWrapper {
+        fn default() -> Self {
+            let mut switch_map = SwitchMapBinary::default();
+            for entry in PcduSwitch::iter() {
+                switch_map.insert(entry, SwitchStateBinary::Off);
+            }
+            Self(switch_map)
+        }
+    }
+
+    impl Default for SwitchMapWrapper {
+        fn default() -> Self {
+            let mut switch_map = SwitchMap::default();
+            for entry in PcduSwitch::iter() {
+                switch_map.insert(entry, SwitchState::Unknown);
+            }
+            Self(switch_map)
+        }
+    }
+
+    impl SwitchMapWrapper {
+        pub fn new_with_init_switches_off() -> Self {
+            let mut switch_map = SwitchMap::default();
+            for entry in PcduSwitch::iter() {
+                switch_map.insert(entry, SwitchState::Off);
+            }
+            Self(switch_map)
+        }
+
+        pub fn from_binary_switch_map_ref(switch_map: &SwitchMapBinary) -> Self {
+            Self(
+                switch_map
+                    .iter()
+                    .map(|(key, value)| (*key, SwitchState::from(*value)))
+                    .collect(),
+            )
+        }
+    }
 
     #[derive(Debug, Copy, Clone)]
     #[repr(u8)]
@@ -173,7 +240,7 @@ pub mod eps {
     #[derive(Debug, Copy, Clone, PartialEq, Eq, Serialize, Deserialize)]
     pub enum PcduRequest {
         SwitchDevice {
-            switch: SwitchId,
+            switch: PcduSwitch,
             state: SwitchStateBinary,
         },
         RequestSwitchInfo,
@@ -197,7 +264,7 @@ pub mod eps {
 pub mod acs {
     use std::time::Duration;
 
-    use models::pcdu::SwitchStateBinary;
+    use satrs::power::SwitchStateBinary;
 
     use super::*;
 

satrs-minisim/src/main.rs

@@ -130,7 +130,7 @@ fn main() {
     let mut udp_server =
         SimUdpServer::new(SIM_CTRL_PORT, request_sender, reply_receiver, 200, None)
             .expect("could not create UDP request server");
-    log::info!("starting UDP server on port {SIM_CTRL_PORT}");
+    log::info!("starting UDP server on port {}", SIM_CTRL_PORT);
     // This thread manages the simulator UDP server.
     let udp_tc_thread = thread::spawn(move || {
         udp_server.run();

satrs-minisim/src/udp.rs

@@ -91,8 +91,11 @@ impl SimUdpServer {
             self.sender_addr = Some(src);
 
             let sim_req = SimRequest::from_raw_data(&self.req_buf[..bytes_read]);
-            if let Err(e) = sim_req {
-                log::warn!("received UDP request with invalid format: {}", e);
+            if sim_req.is_err() {
+                log::warn!(
+                    "received UDP request with invalid format: {}",
+                    sim_req.unwrap_err()
+                );
                 return processed_requests;
             }
             self.request_sender.send(sim_req.unwrap()).unwrap();

satrs-shared/CHANGELOG.md

@@ -8,14 +8,6 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 
 # [unreleased]
 
-# [v0.2.4] 2025-11-06
-
-`spacepackets` v0.17.0
-
-# [v0.2.3] 2025-07-22
-
-`spacepackets` range v0.14 to v0.15
-
 # [v0.2.2] 2025-05-10
 
 - Bump to `spacepackests` v0.14
@@ -54,7 +46,5 @@ Allow `spacepackets` range starting with v0.10 and v0.11.
 
 Initial release.
 
-[unreleased]: https://egit.irs.uni-stuttgart.de/rust/sat-rs/compare/satrs-shared-v0.2.4...HEAD
-[v0.2.3]: https://egit.irs.uni-stuttgart.de/rust/sat-rs/compare/satrs-shared-v0.2.3...satrs-shared-v0.2.4
-[v0.2.3]: https://egit.irs.uni-stuttgart.de/rust/sat-rs/compare/satrs-shared-v0.2.1...satrs-shared-v0.2.3
+[unreleased]: https://egit.irs.uni-stuttgart.de/rust/sat-rs/compare/satrs-shared-v0.2.2...HEAD
 [v0.2.2]: https://egit.irs.uni-stuttgart.de/rust/sat-rs/compare/satrs-shared-v0.2.1...satrs-shared-v0.2.2

satrs-shared/Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "satrs-shared"
 description = "Components shared by multiple sat-rs crates"
-version = "0.2.4"
+version = "0.2.2"
 edition = "2021"
 authors = ["Robin Mueller <muellerr@irs.uni-stuttgart.de>"]
 homepage = "https://absatsw.irs.uni-stuttgart.de/projects/sat-rs/"
@@ -11,10 +11,17 @@ license = "Apache-2.0"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-# spacepackets = { version = "0.17", default-features = false }
-spacepackets = { version = "0.17", git = "https://egit.irs.uni-stuttgart.de/rust/spacepackets.git", default-features = false }
-serde = { version = "1", default-features = false, optional = true }
-defmt = {version = "1", optional = true }
+spacepackets = { version = ">=0.14, <=0.15", git = "https://egit.irs.uni-stuttgart.de/rust/spacepackets.git", default-features = false }
+
+[dependencies.serde]
+version = "1"
+default-features = false
+optional = true
+
+[dependencies.defmt]
+version = "1"
+optional = true
+
 
 [features]
 serde = ["dep:serde", "spacepackets/serde"]

satrs-shared/src/lib.rs

@@ -1,4 +1,4 @@
 //! This crates contains modules shared among other sat-rs framework crates.
 #![no_std]
-#![cfg_attr(docsrs, feature(doc_cfg))]
+#![cfg_attr(docsrs, feature(doc_auto_cfg))]
 pub mod res_code;

satrs-shared/src/res_code.rs

@@ -14,7 +14,6 @@ pub struct ResultU16 {
 }
 
 impl ResultU16 {
-    #[inline]
     pub const fn new(group_id: u8, unique_id: u8) -> Self {
         Self {
             group_id,
@@ -22,22 +21,18 @@ impl ResultU16 {
         }
     }
 
-    #[inline]
-    pub const fn raw(&self) -> u16 {
+    pub fn raw(&self) -> u16 {
         ((self.group_id as u16) << 8) | self.unique_id as u16
     }
 
-    #[inline]
-    pub const fn group_id(&self) -> u8 {
+    pub fn group_id(&self) -> u8 {
         self.group_id
     }
 
-    #[inline]
-    pub const fn unique_id(&self) -> u8 {
+    pub fn unique_id(&self) -> u8 {
         self.unique_id
     }
 
-    #[inline]
     pub fn from_be_bytes(bytes: [u8; 2]) -> Self {
         Self::from(u16::from_be_bytes(bytes))
     }
@@ -56,7 +51,6 @@ impl From<ResultU16> for EcssEnumU16 {
 }
 
 impl UnsignedEnum for ResultU16 {
-    #[inline]
     fn size(&self) -> usize {
         core::mem::size_of::<u16>()
     }
@@ -73,14 +67,12 @@ impl UnsignedEnum for ResultU16 {
         Ok(self.size())
     }
 
-    #[inline]
-    fn value_raw(&self) -> u64 {
+    fn value(&self) -> u64 {
         self.raw() as u64
     }
 }
 
 impl EcssEnumeration for ResultU16 {
-    #[inline]
     fn pfc(&self) -> u8 {
         16
     }

satrs/CHANGELOG.md

@@ -8,31 +8,6 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 
 # [unreleased]
 
-# [v0.3.0-alpha.3] 2025-11-06
-
-- Bump `sat-rs` edition to 2024.
-- Bumped `spacepackets` to v0.17
-- `ComponentId` is u32 now
-- Simplified TCP servers
-
-## Changed
-
-Some trait renaming to be more in-line with Rust naming conventions.
-
-- `EventTmHookProvider` -> `EventTmHook`
-- `ActiveRequestProvider` -> `ActiveRequest`
-- `EcssTcInMemConversionProvider` -> `CacheAndReadRawEcssTc`
-- `ActiveRequestMapProvider` -> `ActiveRequestStore`
-- `CountdownProvider` -> `Countdown`
-
-# [v0.3.0-alpha.2] 2025-07-22
-
-`satrs-shared` update
-
-# [v0.3.0-alpha.1] 2025-07-22
-
-`spacepackets` range v0.14 to v0.15
-
 # [v0.3.0-alpha.0] 2025-02-18
 
 `spacepackets` v0.13
@@ -223,9 +198,3 @@ docs-rs hotfix
 # [v0.1.0] 2024-02-12
 
 Initial release.
-
-[unreleased]: https://egit.irs.uni-stuttgart.de/rust/sat-rs/compare/satrs-v0.3.0-alpha.3...HEAD
-[v0.3.0-alpha.3]: https://egit.irs.uni-stuttgart.de/rust/sat-rs/compare/satrs-v0.3.0-alpha.2...satrs-v0.3.0-alpha.3
-[v0.3.0-alpha.2]: https://egit.irs.uni-stuttgart.de/rust/sat-rs/compare/satrs-v0.3.0-alpha.1...satrs-v0.3.0-alpha.2
-[v0.3.0-alpha.1]: https://egit.irs.uni-stuttgart.de/rust/sat-rs/compare/satrs-v0.3.0-alpha.0...satrs-v0.3.0-alpha.1
-[v0.3.0-alpha.0]: https://egit.irs.uni-stuttgart.de/rust/sat-rs/compare/satrs-v0.2.1...satrs-v0.3.0-alpha.0

satrs/Cargo.toml

@@ -1,8 +1,8 @@
 [package]
 name = "satrs"
-version = "0.3.0-alpha.3"
-edition = "2024"
-rust-version = "1.85.0"
+version = "0.3.0-alpha.0"
+edition = "2021"
+rust-version = "1.82.0"
 authors = ["Robin Mueller <muellerr@irs.uni-stuttgart.de>"]
 description = "A library collection to build software for remote systems"
 homepage = "https://github.com/us-irs/sat-rs"
@@ -13,29 +13,27 @@ keywords = ["no-std", "space", "aerospace"]
 categories = ["aerospace", "aerospace::space-protocols", "no-std", "hardware-support", "embedded"]
 
 [dependencies]
-satrs-shared = { version = "0.2", path = "../satrs-shared" }
-spacepackets = { version = "0.17", git = "https://egit.irs.uni-stuttgart.de/rust/spacepackets.git", default-features = false }
+satrs-shared = { version = "0.2.2", path = "../satrs-shared" }
+spacepackets = { version = ">=0.14, <=0.15", git = "https://egit.irs.uni-stuttgart.de/rust/spacepackets.git", default-features = false }
 
-delegate = "0.13"
+delegate = ">0.7, <=0.13"
 paste = "1"
-derive-new = "0.7"
-num_enum = { version = "0.7", default-features = false }
-cobs = { version = "0.5", default-features = false }
+derive-new = ">=0.6, <=0.7"
+num_enum = { version = ">0.5, <=0.7", default-features = false }
+cobs = { version = "0.4", default-features = false, git = "https://github.com/jamesmunns/cobs.rs.git", branch = "main" }
 thiserror = { version = "2", default-features = false }
 
-hashbrown = { version = "0.16", optional = true }
-static_cell = { version = "2" }
-heapless = { version = "0.9", optional = true }
+hashbrown = { version = ">=0.14, <=0.15", optional = true }
+static_cell = { version = "2", optional = true }
 dyn-clone = { version = "1", optional = true }
+heapless = { version = "0.8", optional = true }
 downcast-rs = { version = "2", default-features = false, optional = true }
 bus = { version = "2.2", optional = true }
 crossbeam-channel = { version = "0.5", default-features = false, optional = true }
-postcard = { version = "1", features = ["alloc"] }
 serde = { version = "1", default-features = false, optional = true }
-socket2 = { version = "0.6", features = ["all"], optional = true }
-arbitrary-int = "2"
+socket2 = { version = "0.5", features = ["all"], optional = true }
 mio = { version = "1", features = ["os-poll", "net"], optional = true }
-defmt = { version = "1", optional = true }
+defmt = { version = "0.3", optional = true }
 
 [dev-dependencies]
 serde = "1"
@@ -49,7 +47,7 @@ tempfile = "3"
 version = "1"
 
 [features]
-default = ["std", "heapless"]
+default = ["std"]
 std = [
     "downcast-rs/std",
     "alloc",
@@ -64,7 +62,6 @@ std = [
 ]
 alloc = [
     "serde/alloc",
-    "cobs/alloc",
     "spacepackets/alloc",
     "hashbrown",
     "dyn-clone",
@@ -72,9 +69,15 @@ alloc = [
 ]
 serde = ["dep:serde", "spacepackets/serde", "satrs-shared/serde"]
 crossbeam = ["crossbeam-channel"]
+heapless = ["dep:heapless", "static_cell"]
 defmt = ["dep:defmt", "spacepackets/defmt"]
 test_util = []
 
 [package.metadata.docs.rs]
 all-features = true
 rustdoc-args = ["--generate-link-to-definition"]
+
+[[test]]
+name = "event_test"
+path = "tests/pus_events.rs"
+required-features = ["test_util"]

satrs/src/ccsds/mod.rs

@@ -1 +0,0 @@
-pub mod scheduler;

satrs/src/ccsds/scheduler.rs

@@ -1,926 +0,0 @@
-//! # CCSDS Telecommand Scheduler.
-#![deny(missing_docs)]
-use core::{hash::Hash, time::Duration};
-
-#[cfg(feature = "alloc")]
-pub use alloc_mod::*;
-use spacepackets::{
-    CcsdsPacketIdAndPsc,
-    time::{TimestampError, UnixTime},
-};
-
-/// Generic CCSDS scheduling errors.
-#[derive(Debug, Clone, PartialEq, Eq, thiserror::Error)]
-#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
-#[cfg_attr(feature = "defmt", derive(defmt::Format))]
-pub enum ScheduleError {
-    /// The release time is within the time-margin added on top of the current time.
-    /// The first parameter is the current time, the second one the time margin, and the third one
-    /// the release time.
-    #[error("release time in margin")]
-    ReleaseTimeInTimeMargin {
-        /// Current time.
-        current_time: UnixTime,
-        /// Configured time margin.
-        time_margin: Duration,
-        /// Release time.
-        release_time: UnixTime,
-    },
-    /// Nested time-tagged commands are not allowed.
-    #[error("nested scheduled tc")]
-    NestedScheduledTc,
-    /// TC data is empty.
-    #[error("tc data empty")]
-    TcDataEmpty,
-    /// Scheduler is full, packet number limit reached.
-    #[error("scheduler is full, packet number limit reached")]
-    PacketLimitReached,
-    /// Scheduler is full, numver of bytes limit reached.
-    #[error("scheduler is full, number of bytes limit reached")]
-    ByteLimitReached,
-    /// Timestamp error.
-    #[error("timestamp error: {0}")]
-    TimestampError(#[from] TimestampError),
-}
-
-/// Packet ID used for identifying scheduled packets.
-///
-/// Right now, this ID can be determined from the packet without requiring external input
-/// or custom data fields in the CCSDS space pacekt.
-#[derive(Debug, PartialEq, Eq, Clone)]
-#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
-pub struct CcsdsSchedulePacketId {
-    /// Base ID.
-    pub base: CcsdsPacketIdAndPsc,
-    /// Optional checksum of the packet.
-    pub crc16: Option<u16>,
-}
-
-impl CcsdsSchedulePacketId {
-    /// Create a new CCSDS scheduling packet ID.
-    pub const fn new(base: CcsdsPacketIdAndPsc, checksum: Option<u16>) -> Self {
-        Self {
-            base,
-            crc16: checksum,
-        }
-    }
-}
-
-impl Hash for CcsdsSchedulePacketId {
-    fn hash<H: core::hash::Hasher>(&self, state: &mut H) {
-        self.base.hash(state);
-        self.crc16.hash(state);
-    }
-}
-
-/// Modules requiring [alloc] support.
-#[cfg(feature = "alloc")]
-pub mod alloc_mod {
-    use core::time::Duration;
-    #[cfg(feature = "std")]
-    use std::time::SystemTimeError;
-
-    use alloc::collections::btree_map;
-    use spacepackets::{CcsdsPacketIdAndPsc, CcsdsPacketReader, time::UnixTime};
-
-    use crate::ccsds::scheduler::CcsdsSchedulePacketId;
-
-    /// The scheduler can be configured to have bounds for both the number of packets
-    /// and the total number of bytes used by scheduled packets.
-    ///
-    /// This can be used to avoid memory exhaustion in systems with limited resources or under
-    /// heavy workloads.
-    #[derive(Default, Debug)]
-    #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
-    #[cfg_attr(feature = "defmt", derive(defmt::Format))]
-    pub struct Limits {
-        /// Maximum number of scheduled packets.
-        pub packets: Option<usize>,
-        /// Maximum total number of bytes used by scheduled packets.
-        pub bytes: Option<usize>,
-    }
-
-    impl Limits {
-        /// Create new limits for the CCSDS scheduler.
-        pub const fn new(packets: Option<usize>, bytes: Option<usize>) -> Self {
-            Self { packets, bytes }
-        }
-
-        /// Check if no limits are set.
-        pub fn has_no_limits(&self) -> bool {
-            self.packets.is_none() && self.bytes.is_none()
-        }
-    }
-
-    /// Fill count of the scheduler.
-    #[derive(Default, Debug)]
-    #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
-    #[cfg_attr(feature = "defmt", derive(defmt::Format))]
-    pub struct FillCount {
-        /// Number of scheduled packets.
-        pub packets: usize,
-        /// Total number of bytes used by scheduled packets.
-        pub bytes: usize,
-    }
-
-    /// Simple CCSDS scheduler implementation.
-    ///
-    /// Relies of [alloc] support but limits the number of scheduled packets.
-    #[derive(Debug)]
-    pub struct CcsdsScheduler {
-        tc_map: alloc::collections::BTreeMap<
-            UnixTime,
-            alloc::vec::Vec<(CcsdsSchedulePacketId, alloc::vec::Vec<u8>)>,
-        >,
-        limits: Limits,
-        pub(crate) current_time: UnixTime,
-        time_margin: Duration,
-    }
-
-    impl CcsdsScheduler {
-        /// Create a new CCSDS scheduler.
-        pub fn new(current_time: UnixTime, limits: Limits, time_margin: Duration) -> Self {
-            Self {
-                tc_map: alloc::collections::BTreeMap::new(),
-                limits,
-                current_time,
-                time_margin,
-            }
-        }
-
-        /// Like [Self::new], but sets the `init_current_time` parameter to the current system time.
-        #[cfg(feature = "std")]
-        pub fn new_with_current_init_time(
-            limits: Limits,
-            time_margin: Duration,
-        ) -> Result<Self, SystemTimeError> {
-            Ok(Self::new(UnixTime::now()?, limits, time_margin))
-        }
-
-        /// Current fill count: number of scheduled packets and total number of bytes.
-        ///
-        /// The first returned value is the number of scheduled packets, the second one is the
-        /// byte count.
-        pub fn current_fill_count(&self) -> FillCount {
-            let mut fill_count = FillCount::default();
-            for value in self.tc_map.values() {
-                for (_, raw_scheduled_tc) in value {
-                    fill_count.packets += 1;
-                    fill_count.bytes += raw_scheduled_tc.len();
-                }
-            }
-            fill_count
-        }
-
-        /// Current number of scheduled entries.
-        pub fn num_of_entries(&self) -> usize {
-            self.current_fill_count().packets
-        }
-
-        /// Update the current time.
-        #[inline]
-        pub fn update_time(&mut self, current_time: UnixTime) {
-            self.current_time = current_time;
-        }
-
-        /// Current time.
-        #[inline]
-        pub fn current_time(&self) -> &UnixTime {
-            &self.current_time
-        }
-
-        fn common_check(
-            &mut self,
-            release_time: UnixTime,
-            packet_size: usize,
-        ) -> Result<(), super::ScheduleError> {
-            if !self.limits.has_no_limits() {
-                let fill_count = self.current_fill_count();
-                if let Some(max_bytes) = self.limits.bytes {
-                    if fill_count.bytes + packet_size > max_bytes {
-                        return Err(super::ScheduleError::ByteLimitReached);
-                    }
-                }
-                if let Some(max_packets) = self.limits.packets {
-                    if fill_count.packets + 1 > max_packets {
-                        return Err(super::ScheduleError::PacketLimitReached);
-                    }
-                }
-            }
-            if release_time < self.current_time + self.time_margin {
-                return Err(super::ScheduleError::ReleaseTimeInTimeMargin {
-                    current_time: self.current_time,
-                    time_margin: self.time_margin,
-                    release_time,
-                });
-            }
-            Ok(())
-        }
-
-        /// Insert a telecommand using an existing [CcsdsPacketReader].
-        pub fn insert_telecommand_with_reader(
-            &mut self,
-            reader: &CcsdsPacketReader,
-            release_time: UnixTime,
-        ) -> Result<(), super::ScheduleError> {
-            self.common_check(release_time, reader.packet_len())?;
-            let base_id = CcsdsPacketIdAndPsc::new_from_ccsds_packet(reader);
-            let checksum = reader.checksum();
-            let packet_id_scheduling = CcsdsSchedulePacketId {
-                base: base_id,
-                crc16: checksum,
-            };
-            self.insert_telecommand(packet_id_scheduling, reader.raw_data(), release_time)?;
-
-            Ok(())
-        }
-
-        /// Insert a raw telecommand, assuming the user has already extracted the
-        /// [CcsdsSchedulePacketId]
-        pub fn insert_telecommand(
-            &mut self,
-            packet_id_scheduling: CcsdsSchedulePacketId,
-            raw_packet: &[u8],
-            release_time: UnixTime,
-        ) -> Result<(), super::ScheduleError> {
-            self.common_check(release_time, raw_packet.len())?;
-            match self.tc_map.entry(release_time) {
-                btree_map::Entry::Vacant(e) => {
-                    e.insert(alloc::vec![(packet_id_scheduling, raw_packet.to_vec())]);
-                }
-                btree_map::Entry::Occupied(mut v) => {
-                    v.get_mut()
-                        .push((packet_id_scheduling, raw_packet.to_vec()));
-                }
-            }
-            Ok(())
-        }
-
-        /// Release all telecommands which should be released based on the current time.
-        pub fn release_telecommands<R: FnMut(&CcsdsSchedulePacketId, &[u8])>(
-            &mut self,
-            mut releaser: R,
-        ) {
-            let tcs_to_release = self.telecommands_to_release();
-            for tc_group in tcs_to_release {
-                for (packet_id, raw_tc) in tc_group.1 {
-                    releaser(packet_id, raw_tc);
-                }
-            }
-            self.tc_map.retain(|k, _| k > &self.current_time);
-        }
-
-        /// Retrieve all telecommands which should be released based on the current time.
-        pub fn telecommands_to_release(
-            &self,
-        ) -> btree_map::Range<
-            '_,
-            UnixTime,
-            alloc::vec::Vec<(CcsdsSchedulePacketId, alloc::vec::Vec<u8>)>,
-        > {
-            self.tc_map.range(..=self.current_time)
-        }
-
-        /// Delete scheduled telecommand by their packet ID.
-        ///
-        /// Returns whether any telecommand was deleted. This function might have to be called
-        /// multiple times if multiple identical CCSDS packet IDs are possible.
-        pub fn delete_by_id(&mut self, packet_id: &CcsdsSchedulePacketId) -> bool {
-            let mut was_removed = false;
-            self.tc_map.retain(|_, v| {
-                let len_before = v.len();
-                v.retain(|(stored_id, _)| stored_id != packet_id);
-                let has_remaining = !v.is_empty();
-                if v.len() < len_before {
-                    was_removed = true;
-                }
-                has_remaining
-            });
-            was_removed
-        }
-
-        /// Delete all telecommands scheduled in a time window.
-        ///
-        /// The range includes the start time but excludes the end time. Returns whether any
-        /// telecommands were deleted.
-        pub fn delete_time_window(&mut self, start_time: UnixTime, end_time: UnixTime) -> bool {
-            let len_before = self.tc_map.len();
-            self.tc_map.retain(|k, _| k < &start_time || k >= &end_time);
-            self.tc_map.len() < len_before
-        }
-
-        /// Delete all scheduled telecommands scheduled after or at a given time.
-        ///
-        /// Returns whether any telecommands were deleted.
-        pub fn delete_starting_at(&mut self, start_time: UnixTime) -> bool {
-            let len_before = self.tc_map.len();
-            self.tc_map.retain(|k, _| k < &start_time);
-            self.tc_map.len() < len_before
-        }
-
-        /// Delete all scheduled telecommands scheduled before but not equal to a given time.
-        ///
-        /// Returns whether any telecommands were deleted.
-        pub fn delete_before(&mut self, end_time: UnixTime) -> bool {
-            let len_before = self.tc_map.len();
-            self.tc_map.retain(|k, _| k >= &end_time);
-            self.tc_map.len() < len_before
-        }
-
-        /// Completely clear the scheduler.
-        pub fn clear(&mut self) {
-            self.tc_map.clear();
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use arbitrary_int::{traits::Integer, u11, u14};
-    use spacepackets::{
-        CcsdsPacketCreatorOwned, CcsdsPacketReader, ChecksumType, SpacePacketHeader,
-    };
-
-    use super::*;
-
-    fn test_tc(app_data: &[u8], seq_count: u14) -> CcsdsPacketCreatorOwned {
-        CcsdsPacketCreatorOwned::new(
-            SpacePacketHeader::new_for_tc(
-                u11::new(0x1),
-                spacepackets::SequenceFlags::Unsegmented,
-                seq_count,
-                0,
-            ),
-            spacepackets::PacketType::Tc,
-            app_data,
-            Some(ChecksumType::WithCrc16),
-        )
-        .unwrap()
-    }
-
-    #[test]
-    fn test_basic() {
-        let unix_time = UnixTime::new(0, 0);
-        let mut scheduler = CcsdsScheduler::new(
-            unix_time,
-            Limits::new(Some(100), Some(1024)),
-            Duration::from_millis(5000),
-        );
-        assert_eq!(scheduler.current_fill_count().packets, 0);
-        assert_eq!(scheduler.current_fill_count().bytes, 0);
-        assert_eq!(scheduler.num_of_entries(), 0);
-        assert_eq!(
-            scheduler
-                .telecommands_to_release()
-                .collect::<alloc::vec::Vec<_>>()
-                .len(),
-            0
-        );
-        assert_eq!(scheduler.current_time(), &unix_time);
-        scheduler.release_telecommands(|_, _| {
-            panic!("should not be called");
-        });
-    }
-
-    #[test]
-    fn test_mutable_closure() {
-        let unix_time = UnixTime::new(0, 0);
-        let mut scheduler = CcsdsScheduler::new(
-            unix_time,
-            Limits::new(Some(100), Some(1024)),
-            Duration::from_millis(5000),
-        );
-        let mut some_flag = false;
-        // We should be able to manipulate the boolean inside the closure.
-        scheduler.release_telecommands(|_, _| {
-            some_flag = true;
-        });
-    }
-
-    #[test]
-    fn test_clear() {
-        let unix_time = UnixTime::new(0, 0);
-        let mut scheduler = CcsdsScheduler::new(
-            unix_time,
-            Limits::new(Some(100), Some(1024)),
-            Duration::from_millis(1000),
-        );
-        let test_tc = test_tc(&[1, 2, 3], u14::ZERO);
-        let test_tc_raw = test_tc.to_vec();
-        let reader = CcsdsPacketReader::new(&test_tc_raw, Some(ChecksumType::WithCrc16)).unwrap();
-        scheduler
-            .insert_telecommand_with_reader(&reader, UnixTime::new(2, 0))
-            .unwrap();
-        assert_eq!(scheduler.current_fill_count().packets, 1);
-        assert_eq!(scheduler.current_fill_count().bytes, test_tc_raw.len());
-        assert_eq!(scheduler.num_of_entries(), 1);
-        assert_eq!(
-            scheduler
-                .telecommands_to_release()
-                .collect::<alloc::vec::Vec<_>>()
-                .len(),
-            0
-        );
-        scheduler.clear();
-        assert_eq!(scheduler.current_fill_count().packets, 0);
-        assert_eq!(scheduler.current_fill_count().bytes, 0);
-        assert_eq!(scheduler.num_of_entries(), 0);
-        assert_eq!(
-            scheduler
-                .telecommands_to_release()
-                .collect::<alloc::vec::Vec<_>>()
-                .len(),
-            0
-        );
-    }
-
-    #[test]
-    fn insert_and_release_one() {
-        let unix_time = UnixTime::new(0, 0);
-        let mut scheduler = CcsdsScheduler::new(
-            unix_time,
-            Limits::new(Some(100), Some(1024)),
-            Duration::from_millis(1000),
-        );
-        let test_tc_0 = test_tc(&[1, 2, 3], u14::ZERO);
-        let tc_id = CcsdsPacketIdAndPsc::new_from_ccsds_packet(&test_tc_0);
-        let test_tc_raw = test_tc_0.to_vec();
-        let reader = CcsdsPacketReader::new(&test_tc_raw, Some(ChecksumType::WithCrc16)).unwrap();
-        let checksum = reader.checksum();
-        scheduler
-            .insert_telecommand_with_reader(&reader, UnixTime::new(2, 0))
-            .unwrap();
-        assert_eq!(scheduler.current_fill_count().packets, 1);
-        assert_eq!(scheduler.current_fill_count().bytes, test_tc_raw.len());
-        assert_eq!(scheduler.num_of_entries(), 1);
-        assert_eq!(
-            scheduler
-                .telecommands_to_release()
-                .collect::<alloc::vec::Vec<_>>()
-                .len(),
-            0
-        );
-        scheduler.release_telecommands(|_, _| {
-            panic!("should not be called");
-        });
-        scheduler.update_time(UnixTime::new(3, 0));
-        assert_eq!(
-            scheduler
-                .telecommands_to_release()
-                .collect::<alloc::vec::Vec<_>>()
-                .len(),
-            1
-        );
-        scheduler.release_telecommands(|tc_id_scheduled, tc_raw| {
-            assert_eq!(tc_id, tc_id_scheduled.base);
-            assert_eq!(checksum, tc_id_scheduled.crc16);
-            assert_eq!(tc_raw, test_tc_raw);
-        });
-        assert_eq!(
-            scheduler
-                .telecommands_to_release()
-                .collect::<alloc::vec::Vec<_>>()
-                .len(),
-            0
-        );
-    }
-
-    #[test]
-    fn insert_and_release_multi_0() {
-        let unix_time = UnixTime::new(0, 0);
-        let mut scheduler = CcsdsScheduler::new(
-            unix_time,
-            Limits::new(Some(100), Some(1024)),
-            Duration::from_millis(1000),
-        );
-        let test_tc_0 = test_tc(&[42], u14::ZERO);
-        let test_tc_1 = test_tc(&[1, 2, 3], u14::new(1));
-        let tc_id_0 = CcsdsPacketIdAndPsc::new_from_ccsds_packet(&test_tc_0);
-        let tc_id_1 = CcsdsPacketIdAndPsc::new_from_ccsds_packet(&test_tc_1);
-        let test_tc_0_raw = test_tc_0.to_vec();
-        let test_tc_1_raw = test_tc_1.to_vec();
-        let reader_0 =
-            CcsdsPacketReader::new(&test_tc_0_raw, Some(ChecksumType::WithCrc16)).unwrap();
-        let reader_1 =
-            CcsdsPacketReader::new(&test_tc_1_raw, Some(ChecksumType::WithCrc16)).unwrap();
-        scheduler
-            .insert_telecommand_with_reader(&reader_0, UnixTime::new(2, 0))
-            .unwrap();
-        scheduler
-            .insert_telecommand(
-                CcsdsSchedulePacketId::new(tc_id_1, reader_1.checksum()),
-                &test_tc_1_raw,
-                UnixTime::new(5, 0),
-            )
-            .unwrap();
-        assert_eq!(scheduler.current_fill_count().packets, 2);
-        assert_eq!(
-            scheduler.current_fill_count().bytes,
-            test_tc_0_raw.len() + test_tc_1_raw.len()
-        );
-        assert_eq!(scheduler.num_of_entries(), 2);
-        assert_eq!(
-            scheduler
-                .telecommands_to_release()
-                .collect::<alloc::vec::Vec<_>>()
-                .len(),
-            0
-        );
-        scheduler.release_telecommands(|_, _| {
-            panic!("should not be called");
-        });
-
-        // Release first TC.
-        scheduler.update_time(UnixTime::new(3, 0));
-        assert_eq!(
-            scheduler
-                .telecommands_to_release()
-                .collect::<alloc::vec::Vec<_>>()
-                .len(),
-            1
-        );
-        scheduler.release_telecommands(|tc_id_scheduled, tc_raw| {
-            assert_eq!(tc_id_0, tc_id_scheduled.base);
-            assert_eq!(reader_0.checksum(), tc_id_scheduled.crc16);
-            assert_eq!(tc_raw, test_tc_0_raw);
-        });
-        assert_eq!(
-            scheduler
-                .telecommands_to_release()
-                .collect::<alloc::vec::Vec<_>>()
-                .len(),
-            0
-        );
-        assert_eq!(scheduler.current_fill_count().packets, 1);
-        assert_eq!(scheduler.current_fill_count().bytes, test_tc_1_raw.len());
-        assert_eq!(scheduler.num_of_entries(), 1);
-
-        // Release second TC.
-        scheduler.update_time(UnixTime::new(6, 0));
-        assert_eq!(
-            scheduler
-                .telecommands_to_release()
-                .collect::<alloc::vec::Vec<_>>()
-                .len(),
-            1
-        );
-        scheduler.release_telecommands(|tc_id_scheduled, tc_raw| {
-            assert_eq!(tc_id_1, tc_id_scheduled.base);
-            assert_eq!(reader_1.checksum(), tc_id_scheduled.crc16);
-            assert_eq!(tc_raw, test_tc_1_raw);
-        });
-        assert_eq!(
-            scheduler
-                .telecommands_to_release()
-                .collect::<alloc::vec::Vec<_>>()
-                .len(),
-            0
-        );
-        assert_eq!(scheduler.current_fill_count().packets, 0);
-        assert_eq!(scheduler.current_fill_count().bytes, 0);
-        assert_eq!(scheduler.num_of_entries(), 0);
-    }
-
-    #[test]
-    fn insert_and_release_multi_1() {
-        let unix_time = UnixTime::new(0, 0);
-        let mut scheduler = CcsdsScheduler::new(
-            unix_time,
-            Limits::new(Some(100), Some(1024)),
-            Duration::from_millis(1000),
-        );
-        let test_tc_0 = test_tc(&[42], u14::ZERO);
-        let test_tc_1 = test_tc(&[1, 2, 3], u14::new(1));
-        let tc_id_0 = CcsdsPacketIdAndPsc::new_from_ccsds_packet(&test_tc_0);
-        let tc_id_1 = CcsdsPacketIdAndPsc::new_from_ccsds_packet(&test_tc_1);
-        let test_tc_0_raw = test_tc_0.to_vec();
-        let test_tc_1_raw = test_tc_1.to_vec();
-        let reader_0 =
-            CcsdsPacketReader::new(&test_tc_0_raw, Some(ChecksumType::WithCrc16)).unwrap();
-        let reader_1 =
-            CcsdsPacketReader::new(&test_tc_1_raw, Some(ChecksumType::WithCrc16)).unwrap();
-        scheduler
-            .insert_telecommand_with_reader(&reader_0, UnixTime::new(2, 0))
-            .unwrap();
-        scheduler
-            .insert_telecommand(
-                CcsdsSchedulePacketId::new(tc_id_1, reader_1.checksum()),
-                &test_tc_1_raw,
-                UnixTime::new(5, 0),
-            )
-            .unwrap();
-        assert_eq!(scheduler.current_fill_count().packets, 2);
-        assert_eq!(
-            scheduler.current_fill_count().bytes,
-            test_tc_0_raw.len() + test_tc_1_raw.len()
-        );
-        assert_eq!(scheduler.num_of_entries(), 2);
-        assert_eq!(
-            scheduler
-                .telecommands_to_release()
-                .collect::<alloc::vec::Vec<_>>()
-                .len(),
-            0
-        );
-        scheduler.release_telecommands(|_, _| {
-            panic!("should not be called");
-        });
-
-        // Release first TC.
-        scheduler.update_time(UnixTime::new(6, 0));
-        assert_eq!(
-            scheduler
-                .telecommands_to_release()
-                .collect::<alloc::vec::Vec<_>>()
-                .len(),
-            2
-        );
-        let mut index = 0;
-        scheduler.release_telecommands(|tc_id_scheduled, tc_raw| {
-            if index == 0 {
-                assert_eq!(tc_id_0, tc_id_scheduled.base);
-                assert_eq!(reader_0.checksum(), tc_id_scheduled.crc16);
-                assert_eq!(tc_raw, test_tc_0_raw);
-            } else {
-                assert_eq!(tc_id_1, tc_id_scheduled.base);
-                assert_eq!(reader_1.checksum(), tc_id_scheduled.crc16);
-                assert_eq!(tc_raw, test_tc_1_raw);
-            }
-            index += 1;
-        });
-        assert_eq!(
-            scheduler
-                .telecommands_to_release()
-                .collect::<alloc::vec::Vec<_>>()
-                .len(),
-            0
-        );
-        assert_eq!(scheduler.current_fill_count().packets, 0);
-        assert_eq!(scheduler.current_fill_count().bytes, 0);
-        assert_eq!(scheduler.num_of_entries(), 0);
-    }
-
-    #[test]
-    fn test_packet_limit_reached() {
-        let unix_time = UnixTime::new(0, 0);
-        let mut scheduler = CcsdsScheduler::new(
-            unix_time,
-            Limits::new(Some(3), None),
-            Duration::from_millis(1000),
-        );
-        let test_tc_0 = test_tc(&[42], u14::ZERO);
-        let test_tc_0_raw = test_tc_0.to_vec();
-        let reader = CcsdsPacketReader::new(&test_tc_0_raw, Some(ChecksumType::WithCrc16)).unwrap();
-        let tc_id = CcsdsPacketIdAndPsc::new_from_ccsds_packet(&test_tc_0);
-        scheduler
-            .insert_telecommand_with_reader(&reader, UnixTime::new(2, 0))
-            .unwrap();
-        scheduler
-            .insert_telecommand_with_reader(&reader, UnixTime::new(2, 0))
-            .unwrap();
-        scheduler
-            .insert_telecommand_with_reader(&reader, UnixTime::new(2, 0))
-            .unwrap();
-        assert_eq!(scheduler.current_fill_count().packets, 3);
-        assert_eq!(
-            scheduler.insert_telecommand_with_reader(&reader, UnixTime::new(2, 0)),
-            Err(ScheduleError::PacketLimitReached)
-        );
-        assert_eq!(
-            scheduler.insert_telecommand(
-                CcsdsSchedulePacketId::new(tc_id, reader.checksum()),
-                &test_tc_0_raw,
-                UnixTime::new(2, 0)
-            ),
-            Err(ScheduleError::PacketLimitReached)
-        );
-    }
-
-    #[test]
-    fn test_byte_limit_reached() {
-        let unix_time = UnixTime::new(0, 0);
-        let test_tc_0 = test_tc(&[42], u14::ZERO);
-        let mut scheduler = CcsdsScheduler::new(
-            unix_time,
-            Limits::new(None, Some(test_tc_0.len_written() * 3)),
-            Duration::from_millis(1000),
-        );
-        let test_tc_0_raw = test_tc_0.to_vec();
-        let reader = CcsdsPacketReader::new(&test_tc_0_raw, Some(ChecksumType::WithCrc16)).unwrap();
-        let tc_id = CcsdsPacketIdAndPsc::new_from_ccsds_packet(&test_tc_0);
-        scheduler
-            .insert_telecommand_with_reader(&reader, UnixTime::new(2, 0))
-            .unwrap();
-        scheduler
-            .insert_telecommand_with_reader(&reader, UnixTime::new(2, 0))
-            .unwrap();
-        scheduler
-            .insert_telecommand_with_reader(&reader, UnixTime::new(2, 0))
-            .unwrap();
-        assert_eq!(scheduler.current_fill_count().packets, 3);
-        assert_eq!(
-            scheduler.insert_telecommand_with_reader(&reader, UnixTime::new(2, 0)),
-            Err(ScheduleError::ByteLimitReached)
-        );
-        assert_eq!(
-            scheduler.insert_telecommand(
-                CcsdsSchedulePacketId::new(tc_id, reader.checksum()),
-                &test_tc_0_raw,
-                UnixTime::new(2, 0)
-            ),
-            Err(ScheduleError::ByteLimitReached)
-        );
-    }
-
-    #[test]
-    fn test_deletion_by_id() {
-        let unix_time = UnixTime::new(0, 0);
-        let mut scheduler = CcsdsScheduler::new(
-            unix_time,
-            Limits::new(Some(100), Some(1024)),
-            Duration::from_millis(1000),
-        );
-        let test_tc = test_tc(&[1, 2, 3], u14::ZERO);
-        let tc_id = CcsdsPacketIdAndPsc::new_from_ccsds_packet(&test_tc);
-        let test_tc_raw = test_tc.to_vec();
-        let reader = CcsdsPacketReader::new(&test_tc_raw, Some(ChecksumType::WithCrc16)).unwrap();
-        let checksum = reader.checksum();
-        let id = CcsdsSchedulePacketId::new(tc_id, checksum);
-        scheduler
-            .insert_telecommand_with_reader(&reader, UnixTime::new(2, 0))
-            .unwrap();
-        scheduler.delete_by_id(&id);
-        assert_eq!(scheduler.current_fill_count().packets, 0);
-        assert_eq!(scheduler.current_fill_count().bytes, 0);
-    }
-
-    #[test]
-    fn test_deletion_by_window_0() {
-        let unix_time = UnixTime::new(0, 0);
-        let mut scheduler = CcsdsScheduler::new(
-            unix_time,
-            Limits::new(Some(100), Some(1024)),
-            Duration::from_millis(1000),
-        );
-        let test_tc_0 = test_tc(&[42], u14::ZERO);
-        let test_tc_1 = test_tc(&[1, 2, 3], u14::new(1));
-        let test_tc_2 = test_tc(&[1, 2, 3], u14::new(2));
-        let test_tc_0_raw = test_tc_0.to_vec();
-        let test_tc_1_raw = test_tc_1.to_vec();
-        let test_tc_2_raw = test_tc_2.to_vec();
-        let reader_0 =
-            CcsdsPacketReader::new(&test_tc_0_raw, Some(ChecksumType::WithCrc16)).unwrap();
-        let reader_1 =
-            CcsdsPacketReader::new(&test_tc_1_raw, Some(ChecksumType::WithCrc16)).unwrap();
-        let reader_2 =
-            CcsdsPacketReader::new(&test_tc_2_raw, Some(ChecksumType::WithCrc16)).unwrap();
-        scheduler
-            .insert_telecommand_with_reader(&reader_0, UnixTime::new(2, 0))
-            .unwrap();
-        scheduler
-            .insert_telecommand_with_reader(&reader_1, UnixTime::new(5, 0))
-            .unwrap();
-        scheduler
-            .insert_telecommand_with_reader(&reader_2, UnixTime::new(7, 0))
-            .unwrap();
-        let deleted = scheduler.delete_time_window(UnixTime::new(3, 0), UnixTime::new(6, 0));
-        assert!(deleted);
-        assert_eq!(scheduler.current_fill_count().packets, 2);
-        assert_eq!(
-            scheduler.current_fill_count().bytes,
-            test_tc_0_raw.len() + test_tc_2_raw.len()
-        );
-        scheduler.update_time(UnixTime::new(10, 0));
-        let mut index = 0;
-        scheduler.release_telecommands(|_id, packet| {
-            if index == 0 {
-                assert_eq!(packet, test_tc_0_raw);
-            } else {
-                assert_eq!(packet, test_tc_2_raw);
-            }
-            index += 1;
-        });
-        assert_eq!(scheduler.current_fill_count().packets, 0);
-        assert_eq!(scheduler.current_fill_count().bytes, 0);
-    }
-
-    #[test]
-    fn test_deletion_by_window_1() {
-        let unix_time = UnixTime::new(0, 0);
-        let mut scheduler = CcsdsScheduler::new(
-            unix_time,
-            Limits::new(Some(100), Some(1024)),
-            Duration::from_millis(1000),
-        );
-        let test_tc_0 = test_tc(&[42], u14::ZERO);
-        let test_tc_1 = test_tc(&[1, 2, 3], u14::new(1));
-        let test_tc_2 = test_tc(&[1, 2, 3], u14::new(2));
-        let test_tc_0_raw = test_tc_0.to_vec();
-        let test_tc_1_raw = test_tc_1.to_vec();
-        let test_tc_2_raw = test_tc_2.to_vec();
-        let reader_0 =
-            CcsdsPacketReader::new(&test_tc_0_raw, Some(ChecksumType::WithCrc16)).unwrap();
-        let reader_1 =
-            CcsdsPacketReader::new(&test_tc_1_raw, Some(ChecksumType::WithCrc16)).unwrap();
-        let reader_2 =
-            CcsdsPacketReader::new(&test_tc_2_raw, Some(ChecksumType::WithCrc16)).unwrap();
-        scheduler
-            .insert_telecommand_with_reader(&reader_0, UnixTime::new(2, 0))
-            .unwrap();
-        scheduler
-            .insert_telecommand_with_reader(&reader_1, UnixTime::new(5, 0))
-            .unwrap();
-        scheduler
-            .insert_telecommand_with_reader(&reader_2, UnixTime::new(7, 0))
-            .unwrap();
-        // This only deletes the first 2 TCs.
-        let deleted = scheduler.delete_time_window(UnixTime::new(2, 0), UnixTime::new(7, 0));
-        assert!(deleted);
-        assert_eq!(scheduler.current_fill_count().packets, 1);
-        assert_eq!(scheduler.current_fill_count().bytes, test_tc_2_raw.len());
-        scheduler.update_time(UnixTime::new(10, 0));
-        scheduler.release_telecommands(|_id, packet| {
-            assert_eq!(packet, test_tc_2_raw);
-        });
-    }
-
-    #[test]
-    fn test_deletion_from_start() {
-        let unix_time = UnixTime::new(0, 0);
-        let mut scheduler = CcsdsScheduler::new(
-            unix_time,
-            Limits::new(Some(100), Some(1024)),
-            Duration::from_millis(1000),
-        );
-        let test_tc_0 = test_tc(&[42], u14::ZERO);
-        let test_tc_1 = test_tc(&[1, 2, 3], u14::new(1));
-        let test_tc_2 = test_tc(&[1, 2, 3], u14::new(2));
-        let test_tc_0_raw = test_tc_0.to_vec();
-        let test_tc_1_raw = test_tc_1.to_vec();
-        let test_tc_2_raw = test_tc_2.to_vec();
-        let reader_0 =
-            CcsdsPacketReader::new(&test_tc_0_raw, Some(ChecksumType::WithCrc16)).unwrap();
-        let reader_1 =
-            CcsdsPacketReader::new(&test_tc_1_raw, Some(ChecksumType::WithCrc16)).unwrap();
-        let reader_2 =
-            CcsdsPacketReader::new(&test_tc_2_raw, Some(ChecksumType::WithCrc16)).unwrap();
-        scheduler
-            .insert_telecommand_with_reader(&reader_0, UnixTime::new(2, 0))
-            .unwrap();
-        scheduler
-            .insert_telecommand_with_reader(&reader_1, UnixTime::new(5, 0))
-            .unwrap();
-        scheduler
-            .insert_telecommand_with_reader(&reader_2, UnixTime::new(7, 0))
-            .unwrap();
-        // This only deletes the first 2 TCs.
-        let deleted = scheduler.delete_starting_at(UnixTime::new(5, 0));
-        assert!(deleted);
-        assert_eq!(scheduler.current_fill_count().packets, 1);
-        assert_eq!(scheduler.current_fill_count().bytes, test_tc_0_raw.len());
-        scheduler.update_time(UnixTime::new(10, 0));
-        scheduler.release_telecommands(|_id, packet| {
-            assert_eq!(packet, test_tc_0_raw);
-        });
-    }
-
-    #[test]
-    fn test_deletion_until_end() {
-        let unix_time = UnixTime::new(0, 0);
-        let mut scheduler = CcsdsScheduler::new(
-            unix_time,
-            Limits::new(Some(100), Some(1024)),
-            Duration::from_millis(1000),
-        );
-        let test_tc_0 = test_tc(&[42], u14::ZERO);
-        let test_tc_1 = test_tc(&[1, 2, 3], u14::new(1));
-        let test_tc_2 = test_tc(&[1, 2, 3], u14::new(2));
-        let test_tc_0_raw = test_tc_0.to_vec();
-        let test_tc_1_raw = test_tc_1.to_vec();
-        let test_tc_2_raw = test_tc_2.to_vec();
-        let reader_0 =
-            CcsdsPacketReader::new(&test_tc_0_raw, Some(ChecksumType::WithCrc16)).unwrap();
-        let reader_1 =
-            CcsdsPacketReader::new(&test_tc_1_raw, Some(ChecksumType::WithCrc16)).unwrap();
-        let reader_2 =
-            CcsdsPacketReader::new(&test_tc_2_raw, Some(ChecksumType::WithCrc16)).unwrap();
-        scheduler
-            .insert_telecommand_with_reader(&reader_0, UnixTime::new(2, 0))
-            .unwrap();
-        scheduler
-            .insert_telecommand_with_reader(&reader_1, UnixTime::new(5, 0))
-            .unwrap();
-        scheduler
-            .insert_telecommand_with_reader(&reader_2, UnixTime::new(7, 0))
-            .unwrap();
-        // This only deletes the first 2 TCs.
-        let deleted = scheduler.delete_before(UnixTime::new(7, 0));
-        assert!(deleted);
-        assert_eq!(scheduler.current_fill_count().packets, 1);
-        assert_eq!(scheduler.current_fill_count().bytes, test_tc_2_raw.len());
-        scheduler.update_time(UnixTime::new(10, 0));
-        scheduler.release_telecommands(|_id, packet| {
-            assert_eq!(packet, test_tc_2_raw);
-        });
-    }
-}

satrs/src/dev_mgmt.rs

@@ -0,0 +1,448 @@
+use crate::{
+    mode::{ModeAndSubmode, ModeReply, ModeRequest, ModeRequestSender},
+    mode_tree::{ModeStoreProvider, ModeStoreVec},
+    queue::{GenericSendError, GenericTargetedMessagingError},
+    request::{GenericMessage, RequestId},
+    ComponentId,
+};
+use core::fmt::Debug;
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct ActiveModeCommandContext {
+    pub target_mode: ModeAndSubmode,
+    pub active_request_id: RequestId,
+}
+
+#[derive(Debug, Default, PartialEq, Eq)]
+pub enum DevManagerHelperResult {
+    #[default]
+    Idle,
+    Busy,
+    ModeCommandingDone(ActiveModeCommandContext),
+}
+
+#[derive(Debug)]
+pub enum DevManagerHelperError {
+    ChildNotInStore,
+}
+
+pub trait DevManagerUserHook: Debug {
+    fn send_mode_cmd_to_child(
+        &self,
+        request_id: RequestId,
+        target_id: ComponentId,
+        mode: ModeAndSubmode,
+        forced: bool,
+        children_mode_store: &mut ModeStoreVec,
+        mode_req_sender: &impl ModeRequestSender,
+    ) -> Result<(), GenericSendError>;
+
+    fn send_mode_cmds_to_children(
+        &self,
+        request_id: RequestId,
+        commanded_parent_mode: ModeAndSubmode,
+        forced: bool,
+        children_mode_store: &mut ModeStoreVec,
+        mode_req_sender: &impl ModeRequestSender,
+    ) -> Result<(), GenericSendError>;
+}
+
+#[derive(Debug, Default)]
+pub struct TransparentDevManagerHook {}
+
+impl DevManagerUserHook for TransparentDevManagerHook {
+    fn send_mode_cmds_to_children(
+        &self,
+        request_id: RequestId,
+        commanded_parent_mode: ModeAndSubmode,
+        forced: bool,
+        children_mode_store: &mut ModeStoreVec,
+        mode_req_sender: &impl ModeRequestSender,
+    ) -> Result<(), GenericSendError> {
+        for child in children_mode_store {
+            mode_req_sender.send_mode_request(
+                request_id,
+                child.id(),
+                ModeRequest::SetMode {
+                    mode_and_submode: commanded_parent_mode,
+                    forced,
+                },
+            )?;
+            child.awaiting_reply = true;
+        }
+        Ok(())
+    }
+
+    fn send_mode_cmd_to_child(
+        &self,
+        request_id: RequestId,
+        target_id: ComponentId,
+        mode: ModeAndSubmode,
+        forced: bool,
+        children_mode_store: &mut ModeStoreVec,
+        mode_req_sender: &impl ModeRequestSender,
+    ) -> Result<(), GenericSendError> {
+        let mut_val = children_mode_store
+            .get_mut(target_id)
+            .ok_or(GenericSendError::TargetDoesNotExist(target_id))?;
+        mut_val.awaiting_reply = true;
+        mode_req_sender.send_mode_request(
+            request_id,
+            target_id,
+            ModeRequest::SetMode {
+                mode_and_submode: mode,
+                forced,
+            },
+        )?;
+        Ok(())
+    }
+}
+
+#[derive(Debug, Default, Clone, Copy, PartialEq, Eq)]
+pub enum DevManagerCommandingState {
+    #[default]
+    Idle,
+    AwaitingReplies(ActiveModeCommandContext),
+}
+
+impl DevManagerCommandingState {
+    fn new_active_cmd(mode_and_submode: ModeAndSubmode, active_request_id: RequestId) -> Self {
+        DevManagerCommandingState::AwaitingReplies(ActiveModeCommandContext {
+            target_mode: mode_and_submode,
+            active_request_id,
+        })
+    }
+}
+
+/// A generic helper for manager components which manage child components in a mode tree.
+///
+/// Mode commands are usually forwarded to all children components transparently.
+/// For example, this could be used in an Assembly component which manages multiple redundant
+/// child components. It can also be used inside a manager component which only manages one device.
+#[derive(Debug, Default)]
+pub struct DevManagerCommandingHelper<UserHook: DevManagerUserHook> {
+    /// The IDs, modes and reply awaition status of all children are tracked in this data
+    /// structure.
+    pub children_mode_store: ModeStoreVec,
+    pub user_hook: UserHook,
+    pub state: DevManagerCommandingState,
+}
+
+impl<UserHook: DevManagerUserHook> DevManagerCommandingHelper<UserHook> {
+    pub fn new(user_hook: UserHook) -> Self {
+        Self {
+            children_mode_store: Default::default(),
+            user_hook,
+            state: Default::default(),
+        }
+    }
+
+    pub fn send_mode_cmd_to_one_child(
+        &mut self,
+        request_id: RequestId,
+        target_id: ComponentId,
+        mode_and_submode: ModeAndSubmode,
+        forced: bool,
+        mode_req_sender: &impl ModeRequestSender,
+    ) -> Result<(), GenericSendError> {
+        self.state = DevManagerCommandingState::new_active_cmd(mode_and_submode, request_id);
+        self.user_hook.send_mode_cmd_to_child(
+            request_id,
+            target_id,
+            mode_and_submode,
+            forced,
+            &mut self.children_mode_store,
+            mode_req_sender,
+        )?;
+        Ok(())
+    }
+
+    pub fn send_mode_cmd_to_all_children(
+        &mut self,
+        request_id: RequestId,
+        mode_and_submode: ModeAndSubmode,
+        forced: bool,
+        mode_req_sender: &impl ModeRequestSender,
+    ) -> Result<(), GenericSendError> {
+        self.state = DevManagerCommandingState::new_active_cmd(mode_and_submode, request_id);
+        self.user_hook.send_mode_cmds_to_children(
+            request_id,
+            mode_and_submode,
+            forced,
+            &mut self.children_mode_store,
+            mode_req_sender,
+        )?;
+        Ok(())
+    }
+
+    pub fn target_mode(&self) -> Option<ModeAndSubmode> {
+        match self.state {
+            DevManagerCommandingState::Idle => None,
+            DevManagerCommandingState::AwaitingReplies(context) => Some(context.target_mode),
+        }
+    }
+
+    pub fn state(&self) -> DevManagerCommandingState {
+        self.state
+    }
+
+    pub fn send_announce_mode_cmd_to_children(
+        &self,
+        request_id: RequestId,
+        mode_req_sender: &impl ModeRequestSender,
+        recursive: bool,
+    ) -> Result<(), GenericTargetedMessagingError> {
+        let mut request = ModeRequest::AnnounceMode;
+        if recursive {
+            request = ModeRequest::AnnounceModeRecursive;
+        }
+        for child in self.children_mode_store.0.iter() {
+            mode_req_sender.send_mode_request(request_id, child.id(), request)?;
+        }
+        Ok(())
+    }
+
+    pub fn add_mode_child(&mut self, target_id: ComponentId, mode: ModeAndSubmode) {
+        self.children_mode_store.add_component(target_id, mode);
+    }
+
+    /// Helper method which counts the number of children which have a certain mode.
+    pub fn count_number_of_children_with_mode(&self, mode_and_submode: ModeAndSubmode) -> usize {
+        let mut children_in_target_mode = 0;
+        for child in &self.children_mode_store {
+            if child.mode_and_submode() == mode_and_submode {
+                children_in_target_mode += 1;
+            }
+        }
+        children_in_target_mode
+    }
+
+    pub fn handle_mode_reply(
+        &mut self,
+        mode_reply: &GenericMessage<ModeReply>,
+    ) -> Result<DevManagerHelperResult, DevManagerHelperError> {
+        let context = match self.state {
+            DevManagerCommandingState::Idle => return Ok(DevManagerHelperResult::Idle),
+            DevManagerCommandingState::AwaitingReplies(active_mode_command_context) => {
+                Some(active_mode_command_context)
+            }
+        };
+        if !self
+            .children_mode_store
+            .has_component(mode_reply.sender_id())
+        {
+            return Err(DevManagerHelperError::ChildNotInStore);
+        }
+        let mut generic_mode_reply_handler = |mode_and_submode: Option<ModeAndSubmode>| {
+            // Tying the reply awaition to the request ID ensures that something like replies
+            // belonging to older requests do not interfere with the completion handling of
+            // the mode commanding. This is important for forced mode commands.
+            let mut handle_awaition = false;
+            if let DevManagerCommandingState::AwaitingReplies { .. } = self.state {
+                handle_awaition = true;
+            }
+            let still_awating_replies = self.children_mode_store.mode_reply_handler(
+                mode_reply.sender_id(),
+                mode_and_submode,
+                handle_awaition,
+            );
+            // It is okay to unwrap: If awaition should be handled, the returned value should
+            // always be some valid value.
+            if handle_awaition && !still_awating_replies.unwrap() {
+                self.state = DevManagerCommandingState::Idle;
+                return Ok(DevManagerHelperResult::ModeCommandingDone(context.unwrap()));
+            }
+            Ok(DevManagerHelperResult::Busy)
+        };
+        match mode_reply.message {
+            ModeReply::ModeInfo(mode_and_submode) | ModeReply::ModeReply(mode_and_submode) => {
+                generic_mode_reply_handler(Some(mode_and_submode))
+            }
+            ModeReply::CantReachMode(_result_u16) => generic_mode_reply_handler(None),
+            ModeReply::WrongMode {
+                expected: _,
+                reached,
+            } => generic_mode_reply_handler(Some(reached)),
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::{
+        mode::{tests::ModeReqSenderMock, UNKNOWN_MODE},
+        request::MessageMetadata,
+    };
+
+    use super::*;
+
+    pub enum ExampleId {
+        Id1 = 1,
+        Id2 = 2,
+    }
+
+    pub enum ExampleMode {
+        Mode1 = 1,
+        Mode2 = 2,
+    }
+
+    #[test]
+    fn test_basic() {
+        let assy_helper = DevManagerCommandingHelper::new(TransparentDevManagerHook::default());
+        assert_eq!(assy_helper.state(), DevManagerCommandingState::Idle);
+    }
+
+    #[test]
+    fn test_mode_announce() {
+        let mut assy_helper = DevManagerCommandingHelper::new(TransparentDevManagerHook::default());
+        let mode_req_sender = ModeReqSenderMock::default();
+        assy_helper.add_mode_child(ExampleId::Id1 as u64, UNKNOWN_MODE);
+        assy_helper.add_mode_child(ExampleId::Id2 as u64, UNKNOWN_MODE);
+        assy_helper
+            .send_announce_mode_cmd_to_children(1, &mode_req_sender, false)
+            .unwrap();
+        assert_eq!(mode_req_sender.requests.borrow().len(), 2);
+        let mut req = mode_req_sender.requests.borrow_mut().pop_front().unwrap();
+        assert_eq!(req.target_id, ExampleId::Id1 as u64);
+        assert_eq!(req.request_id, 1);
+        assert_eq!(req.request, ModeRequest::AnnounceMode);
+        req = mode_req_sender.requests.borrow_mut().pop_front().unwrap();
+        assert_eq!(req.target_id, ExampleId::Id2 as u64);
+        assert_eq!(req.request_id, 1);
+        assert_eq!(req.request, ModeRequest::AnnounceMode);
+    }
+
+    #[test]
+    fn test_mode_announce_recursive() {
+        let mut assy_helper = DevManagerCommandingHelper::new(TransparentDevManagerHook::default());
+        let mode_req_sender = ModeReqSenderMock::default();
+        assy_helper.add_mode_child(ExampleId::Id1 as u64, UNKNOWN_MODE);
+        assy_helper.add_mode_child(ExampleId::Id2 as u64, UNKNOWN_MODE);
+        assy_helper
+            .send_announce_mode_cmd_to_children(1, &mode_req_sender, true)
+            .unwrap();
+        assert_eq!(mode_req_sender.requests.borrow().len(), 2);
+        let mut req = mode_req_sender.requests.borrow_mut().pop_front().unwrap();
+        assert_eq!(req.target_id, ExampleId::Id1 as u64);
+        assert_eq!(req.request_id, 1);
+        assert_eq!(req.request, ModeRequest::AnnounceModeRecursive);
+        req = mode_req_sender.requests.borrow_mut().pop_front().unwrap();
+        assert_eq!(req.target_id, ExampleId::Id2 as u64);
+        assert_eq!(req.request_id, 1);
+        assert_eq!(req.request, ModeRequest::AnnounceModeRecursive);
+    }
+
+    #[test]
+    fn test_mode_commanding_one_child() {
+        let mut dev_mgmt_helper =
+            DevManagerCommandingHelper::new(TransparentDevManagerHook::default());
+        let mode_req_sender = ModeReqSenderMock::default();
+        dev_mgmt_helper.add_mode_child(ExampleId::Id1 as u64, UNKNOWN_MODE);
+        let expected_mode = ModeAndSubmode::new(ExampleMode::Mode1 as u32, 0);
+        dev_mgmt_helper
+            .send_mode_cmd_to_one_child(
+                1,
+                ExampleId::Id1 as u64,
+                expected_mode,
+                false,
+                &mode_req_sender,
+            )
+            .unwrap();
+        assert_eq!(mode_req_sender.requests.borrow().len(), 1);
+        let req = mode_req_sender.requests.borrow_mut().pop_front().unwrap();
+        assert_eq!(req.target_id, ExampleId::Id1 as u64);
+        assert_eq!(req.request_id, 1);
+        assert_eq!(
+            req.request,
+            ModeRequest::SetMode {
+                mode_and_submode: expected_mode,
+                forced: false
+            }
+        );
+        matches!(
+            dev_mgmt_helper.state(),
+            DevManagerCommandingState::AwaitingReplies { .. }
+        );
+        if let DevManagerCommandingState::AwaitingReplies(ctx) = dev_mgmt_helper.state() {
+            assert_eq!(ctx.target_mode, expected_mode);
+            assert_eq!(ctx.active_request_id, 1);
+        }
+        let reply = GenericMessage::new(
+            MessageMetadata::new(1, ExampleId::Id1 as u64),
+            ModeReply::ModeReply(expected_mode),
+        );
+        if let DevManagerHelperResult::ModeCommandingDone(ActiveModeCommandContext {
+            target_mode,
+            active_request_id,
+        }) = dev_mgmt_helper.handle_mode_reply(&reply).unwrap()
+        {
+            assert_eq!(target_mode, expected_mode);
+            assert_eq!(active_request_id, 1);
+        }
+        matches!(dev_mgmt_helper.state(), DevManagerCommandingState::Idle);
+    }
+
+    #[test]
+    fn test_mode_commanding_multi_child() {
+        let mut dev_mgmt_helper =
+            DevManagerCommandingHelper::new(TransparentDevManagerHook::default());
+        let mode_req_sender = ModeReqSenderMock::default();
+        dev_mgmt_helper.add_mode_child(ExampleId::Id1 as u64, UNKNOWN_MODE);
+        dev_mgmt_helper.add_mode_child(ExampleId::Id2 as u64, UNKNOWN_MODE);
+        let expected_mode = ModeAndSubmode::new(ExampleMode::Mode2 as u32, 0);
+        dev_mgmt_helper
+            .send_mode_cmd_to_all_children(1, expected_mode, false, &mode_req_sender)
+            .unwrap();
+        assert_eq!(mode_req_sender.requests.borrow().len(), 2);
+        let req = mode_req_sender.requests.borrow_mut().pop_front().unwrap();
+        assert_eq!(req.target_id, ExampleId::Id1 as u64);
+        assert_eq!(req.request_id, 1);
+        assert_eq!(
+            req.request,
+            ModeRequest::SetMode {
+                mode_and_submode: expected_mode,
+                forced: false
+            }
+        );
+        let req = mode_req_sender.requests.borrow_mut().pop_front().unwrap();
+        assert_eq!(req.target_id, ExampleId::Id2 as u64);
+        assert_eq!(req.request_id, 1);
+        assert_eq!(
+            req.request,
+            ModeRequest::SetMode {
+                mode_and_submode: expected_mode,
+                forced: false
+            }
+        );
+        matches!(
+            dev_mgmt_helper.state(),
+            DevManagerCommandingState::AwaitingReplies { .. }
+        );
+        if let DevManagerCommandingState::AwaitingReplies(ctx) = dev_mgmt_helper.state() {
+            assert_eq!(ctx.target_mode, expected_mode);
+            assert_eq!(ctx.active_request_id, 1);
+        }
+
+        let reply = GenericMessage::new(
+            MessageMetadata::new(1, ExampleId::Id1 as u64),
+            ModeReply::ModeReply(expected_mode),
+        );
+        assert_eq!(
+            dev_mgmt_helper.handle_mode_reply(&reply).unwrap(),
+            DevManagerHelperResult::Busy
+        );
+        let reply = GenericMessage::new(
+            MessageMetadata::new(1, ExampleId::Id2 as u64),
+            ModeReply::ModeReply(expected_mode),
+        );
+        if let DevManagerHelperResult::ModeCommandingDone(ActiveModeCommandContext {
+            target_mode,
+            active_request_id,
+        }) = dev_mgmt_helper.handle_mode_reply(&reply).unwrap()
+        {
+            assert_eq!(target_mode, expected_mode);
+            assert_eq!(active_request_id, 1);
+        }
+        matches!(dev_mgmt_helper.state(), DevManagerCommandingState::Idle);
+    }
+}

satrs/src/encoding/ccsds.rs

@@ -1,6 +1,6 @@
-use spacepackets::SpHeader;
+use spacepackets::{CcsdsPacket, SpHeader};
 
-use crate::{ComponentId, tmtc::PacketHandler};
+use crate::{tmtc::PacketSenderRaw, ComponentId};
 
 #[derive(Debug, Copy, Clone, PartialEq, Eq)]
 pub enum SpValidity {
@@ -24,17 +24,13 @@ pub trait SpacePacketValidator {
 #[derive(Default, Debug, PartialEq, Eq)]
 pub struct ParseResult {
     pub packets_found: u32,
-    pub parsed_bytes: usize,
-    // If an incomplete space packet was found, its start index is indicated by this value.
-    //pub incomplete_packet_start: Option<usize>,
+    /// If an incomplete space packet was found, its start index is indicated by this value.
+    pub incomplete_tail_start: Option<usize>,
 }
 
-/// This function parses a given buffer for tightly packed CCSDS space packets.
-///
-/// Please note that it is recommended to use a proper data link layer instead to have proper
-/// packet framing and to allow more reliable recovery from packet loss.
-/// It uses the [spacepackets::SpHeader] of the CCSDS packets and a user provided
-/// [SpacePacketValidator] to check whether a received space packet is relevant for processing.
+/// This function parses a given buffer for tightly packed CCSDS space packets. It uses the
+/// [spacepackets::SpHeader] of the CCSDS packets and a user provided [SpacePacketValidator]
+/// to check whether a received space packet is relevant for processing.
 ///
 /// This function is also able to deal with broken tail packets at the end as long a the parser
 /// can read the full 7 bytes which constitue a space packet header plus one byte minimal size.
@@ -45,18 +41,17 @@ pub struct ParseResult {
 /// [SpacePacketValidator]:
 ///
 ///  1. [SpValidity::Valid]: The parser will forward all packets to the given `packet_sender` and
-///     return the number of packets found.If the [PacketHandler::handle_packet] calls fails, the
+///     return the number of packets found.If the [PacketSenderRaw::send_packet] calls fails, the
 ///     error will be returned.
 ///  2. [SpValidity::Invalid]: The parser assumes that the synchronization is lost and tries to
 ///     find the start of a new space packet header by scanning all the following bytes.
 ///  3. [SpValidity::Skip]: The parser skips the packet using the packet length determined from the
 ///     space packet header.
-///
 pub fn parse_buffer_for_ccsds_space_packets<SendError>(
     buf: &[u8],
     packet_validator: &(impl SpacePacketValidator + ?Sized),
     sender_id: ComponentId,
-    packet_sender: &(impl PacketHandler<Error = SendError> + ?Sized),
+    packet_sender: &(impl PacketSenderRaw<Error = SendError> + ?Sized),
 ) -> Result<ParseResult, SendError> {
     let mut parse_result = ParseResult::default();
     let mut current_idx = 0;
@@ -68,21 +63,20 @@ pub fn parse_buffer_for_ccsds_space_packets<SendError>(
         let sp_header = SpHeader::from_be_bytes(&buf[current_idx..]).unwrap().0;
         match packet_validator.validate(&sp_header, &buf[current_idx..]) {
             SpValidity::Valid => {
-                let packet_size = sp_header.packet_len();
+                let packet_size = sp_header.total_len();
                 if (current_idx + packet_size) <= buf_len {
                     packet_sender
-                        .handle_packet(sender_id, &buf[current_idx..current_idx + packet_size])?;
+                        .send_packet(sender_id, &buf[current_idx..current_idx + packet_size])?;
                     parse_result.packets_found += 1;
                 } else {
                     // Move packet to start of buffer if applicable.
-                    //parse_result.incomplete_packet_start = Some(current_idx);
-                    break;
+                    parse_result.incomplete_tail_start = Some(current_idx);
                 }
                 current_idx += packet_size;
                 continue;
             }
             SpValidity::Skip => {
-                current_idx += sp_header.packet_len();
+                current_idx += sp_header.total_len();
             }
             // We might have lost sync. Try to find the start of a new space packet header.
             SpValidity::Invalid => {
@@ -90,25 +84,23 @@ pub fn parse_buffer_for_ccsds_space_packets<SendError>(
             }
         }
     }
-    parse_result.parsed_bytes = current_idx;
     Ok(parse_result)
 }
 
 #[cfg(test)]
 mod tests {
-    use arbitrary_int::{u11, u14};
     use spacepackets::{
-        CcsdsPacket, PacketId, PacketSequenceControl, PacketType, SequenceFlags, SpHeader,
-        ecss::{CreatorConfig, MessageTypeId, tc::PusTcCreator},
+        ecss::{tc::PusTcCreator, WritablePusPacket},
+        CcsdsPacket, PacketId, PacketSequenceCtrl, PacketType, SequenceFlags, SpHeader,
     };
 
-    use crate::{ComponentId, encoding::tests::TcCacher};
+    use crate::{encoding::tests::TcCacher, ComponentId};
 
-    use super::{SpValidity, SpacePacketValidator, parse_buffer_for_ccsds_space_packets};
+    use super::{parse_buffer_for_ccsds_space_packets, SpValidity, SpacePacketValidator};
 
     const PARSER_ID: ComponentId = 0x05;
-    const TEST_APID_0: u11 = u11::new(0x02);
-    const TEST_APID_1: u11 = u11::new(0x10);
+    const TEST_APID_0: u16 = 0x02;
+    const TEST_APID_1: u16 = 0x10;
     const TEST_PACKET_ID_0: PacketId = PacketId::new_for_tc(true, TEST_APID_0);
     const TEST_PACKET_ID_1: PacketId = PacketId::new_for_tc(true, TEST_APID_1);
 
@@ -139,12 +131,7 @@ mod tests {
     #[test]
     fn test_basic() {
         let sph = SpHeader::new_from_apid(TEST_APID_0);
-        let ping_tc = PusTcCreator::new_simple(
-            sph,
-            MessageTypeId::new(17, 1),
-            &[],
-            CreatorConfig::default(),
-        );
+        let ping_tc = PusTcCreator::new_simple(sph, 17, 1, &[], true);
         let mut buffer: [u8; 32] = [0; 32];
         let packet_len = ping_tc
             .write_to_bytes(&mut buffer)
@@ -169,14 +156,8 @@ mod tests {
     #[test]
     fn test_multi_packet() {
         let sph = SpHeader::new_from_apid(TEST_APID_0);
-        let ping_tc = PusTcCreator::new_simple(
-            sph,
-            MessageTypeId::new(17, 1),
-            &[],
-            CreatorConfig::default(),
-        );
-        let action_tc =
-            PusTcCreator::new_simple(sph, MessageTypeId::new(8, 0), &[], CreatorConfig::default());
+        let ping_tc = PusTcCreator::new_simple(sph, 17, 1, &[], true);
+        let action_tc = PusTcCreator::new_simple(sph, 8, 0, &[], true);
         let mut buffer: [u8; 32] = [0; 32];
         let packet_len_ping = ping_tc
             .write_to_bytes(&mut buffer)
@@ -210,15 +191,9 @@ mod tests {
     #[test]
     fn test_multi_apid() {
         let sph = SpHeader::new_from_apid(TEST_APID_0);
-        let ping_tc = PusTcCreator::new_simple(
-            sph,
-            MessageTypeId::new(17, 1),
-            &[],
-            CreatorConfig::default(),
-        );
+        let ping_tc = PusTcCreator::new_simple(sph, 17, 1, &[], true);
         let sph = SpHeader::new_from_apid(TEST_APID_1);
-        let action_tc =
-            PusTcCreator::new_simple(sph, MessageTypeId::new(8, 0), &[], CreatorConfig::default());
+        let action_tc = PusTcCreator::new_simple(sph, 8, 0, &[], true);
         let mut buffer: [u8; 32] = [0; 32];
         let packet_len_ping = ping_tc
             .write_to_bytes(&mut buffer)
@@ -246,18 +221,10 @@ mod tests {
 
     #[test]
     fn test_split_packet_multi() {
-        let ping_tc = PusTcCreator::new_simple(
-            SpHeader::new_from_apid(TEST_APID_0),
-            MessageTypeId::new(17, 1),
-            &[],
-            CreatorConfig::default(),
-        );
-        let action_tc = PusTcCreator::new_simple(
-            SpHeader::new_from_apid(TEST_APID_1),
-            MessageTypeId::new(8, 0),
-            &[],
-            CreatorConfig::default(),
-        );
+        let ping_tc =
+            PusTcCreator::new_simple(SpHeader::new_from_apid(TEST_APID_0), 17, 1, &[], true);
+        let action_tc =
+            PusTcCreator::new_simple(SpHeader::new_from_apid(TEST_APID_1), 8, 0, &[], true);
         let mut buffer: [u8; 32] = [0; 32];
         let packet_len_ping = ping_tc
             .write_to_bytes(&mut buffer)
@@ -276,7 +243,8 @@ mod tests {
         assert!(parse_result.is_ok());
         let parse_result = parse_result.unwrap();
         assert_eq!(parse_result.packets_found, 1);
-        let incomplete_tail_idx = parse_result.parsed_bytes;
+        assert!(parse_result.incomplete_tail_start.is_some());
+        let incomplete_tail_idx = parse_result.incomplete_tail_start.unwrap();
         assert_eq!(incomplete_tail_idx, packet_len_ping);
 
         let queue = tc_cacher.tc_queue.borrow();
@@ -287,12 +255,8 @@ mod tests {
 
     #[test]
     fn test_one_split_packet() {
-        let ping_tc = PusTcCreator::new_simple(
-            SpHeader::new_from_apid(TEST_APID_0),
-            MessageTypeId::new(17, 1),
-            &[],
-            CreatorConfig::default(),
-        );
+        let ping_tc =
+            PusTcCreator::new_simple(SpHeader::new_from_apid(TEST_APID_0), 17, 1, &[], true);
         let mut buffer: [u8; 32] = [0; 32];
         let packet_len_ping = ping_tc
             .write_to_bytes(&mut buffer)
@@ -317,7 +281,7 @@ mod tests {
     fn test_smallest_packet() {
         let ccsds_header_only = SpHeader::new(
             PacketId::new(PacketType::Tc, true, TEST_APID_0),
-            PacketSequenceControl::new(SequenceFlags::Unsegmented, u14::new(0)),
+            PacketSequenceCtrl::new(SequenceFlags::Unsegmented, 0),
             0,
         );
         let mut buf: [u8; 7] = [0; 7];

satrs/src/encoding/cobs.rs

@@ -1,5 +1,5 @@
-use crate::{ComponentId, tmtc::PacketHandler};
-use cobs::{decode_in_place, encode_including_sentinels, max_encoding_length};
+use crate::{tmtc::PacketSenderRaw, ComponentId};
+use cobs::{decode_in_place, encode, max_encoding_length};
 
 /// This function encodes the given packet with COBS and also wraps the encoded packet with
 /// the sentinel value 0. It can be used repeatedly on the same encoded buffer by expecting
@@ -37,16 +37,15 @@ pub fn encode_packet_with_cobs(
     if *current_idx + max_encoding_len + 2 > encoded_buf.len() {
         return false;
     }
-    *current_idx += encode_including_sentinels(packet, &mut encoded_buf[*current_idx..]);
+    encoded_buf[*current_idx] = 0;
+    *current_idx += 1;
+    *current_idx += encode(packet, &mut encoded_buf[*current_idx..]);
+    encoded_buf[*current_idx] = 0;
+    *current_idx += 1;
     true
 }
 
-/// This function parses a given buffer for COBS encoded packets.
-///
-/// Please note that, it is recommended to use [cobs::CobsDecoderOwned] or [cobs::CobsDecoder]
-/// instead.
-///
-/// The packet structure is
+/// This function parses a given buffer for COBS encoded packets. The packet structure is
 /// expected to be like this, assuming a sentinel value of 0 as the packet delimiter:
 ///
 /// 0 | ... Encoded Packet Data ... | 0 | 0 | ... Encoded Packet Data ... | 0
@@ -59,7 +58,7 @@ pub fn encode_packet_with_cobs(
 pub fn parse_buffer_for_cobs_encoded_packets<SendError>(
     buf: &mut [u8],
     sender_id: ComponentId,
-    packet_sender: &(impl PacketHandler<Error = SendError> + ?Sized),
+    packet_sender: &(impl PacketSenderRaw<Error = SendError> + ?Sized),
     next_write_idx: &mut usize,
 ) -> Result<u32, SendError> {
     let mut start_index_packet = 0;
@@ -80,7 +79,7 @@ pub fn parse_buffer_for_cobs_encoded_packets<SendError>(
                 let decode_result = decode_in_place(&mut buf[start_index_packet..i]);
                 if let Ok(packet_len) = decode_result {
                     packets_found += 1;
-                    packet_sender.handle_packet(
+                    packet_sender.send_packet(
                         sender_id,
                         &buf[start_index_packet..start_index_packet + packet_len],
                     )?;
@@ -105,8 +104,8 @@ pub(crate) mod tests {
     use cobs::encode;
 
     use crate::{
+        encoding::tests::{encode_simple_packet, TcCacher, INVERTED_PACKET, SIMPLE_PACKET},
         ComponentId,
-        encoding::tests::{INVERTED_PACKET, SIMPLE_PACKET, TcCacher, encode_simple_packet},
     };
 
     use super::parse_buffer_for_cobs_encoded_packets;

satrs/src/encoding/mod.rs

@@ -11,8 +11,8 @@ pub(crate) mod tests {
     use alloc::collections::VecDeque;
 
     use crate::{
+        tmtc::{PacketAsVec, PacketSenderRaw},
         ComponentId,
-        tmtc::{PacketAsVec, PacketHandler},
     };
 
     use super::cobs::encode_packet_with_cobs;
@@ -25,10 +25,10 @@ pub(crate) mod tests {
         pub(crate) tc_queue: RefCell<VecDeque<PacketAsVec>>,
     }
 
-    impl PacketHandler for TcCacher {
+    impl PacketSenderRaw for TcCacher {
         type Error = ();
 
-        fn handle_packet(&self, sender_id: ComponentId, tc_raw: &[u8]) -> Result<(), Self::Error> {
+        fn send_packet(&self, sender_id: ComponentId, tc_raw: &[u8]) -> Result<(), Self::Error> {
             let mut mut_queue = self.tc_queue.borrow_mut();
             mut_queue.push_back(PacketAsVec::new(sender_id, tc_raw.to_vec()));
             Ok(())

satrs/src/event_man.rs

@@ -1,6 +1,4 @@
-//! # Event management and forwarding
-//!
-//! This is a legacy module. It is recommended to use [super::event_man] instead.
+//! Event management and forwarding
 //!
 //! It is recommended to read the
 //! [sat-rs book chapter](https://absatsw.irs.uni-stuttgart.de/projects/sat-rs/book/events.html)
@@ -50,7 +48,7 @@
 //! The [PUS event](https://egit.irs.uni-stuttgart.de/rust/sat-rs/src/branch/main/satrs-example/src/pus/event.rs)
 //! module and the generic [events module](https://egit.irs.uni-stuttgart.de/rust/sat-rs/src/branch/main/satrs-example/src/events.rs)
 //! show how the event management modules can be integrated into a more complex software.
-use crate::legacy::events_legacy::{EventU16, EventU32, GenericEvent, LargestEventRaw, LargestGroupIdRaw};
+use crate::events::{EventU16, EventU32, GenericEvent, LargestEventRaw, LargestGroupIdRaw};
 use crate::params::Params;
 use crate::queue::GenericSendError;
 use core::fmt::Debug;
@@ -73,14 +71,18 @@ pub enum ListenerKey {
 }
 
 #[derive(Debug)]
-pub struct EventMessage<Event: GenericEvent, Parameters: Debug = Params> {
+pub struct EventMessage<Event: GenericEvent, ParamProvider: Debug = Params> {
     sender_id: ComponentId,
     event: Event,
-    params: Option<Parameters>,
+    params: Option<ParamProvider>,
 }
 
-impl<Event: GenericEvent, Parameters: Debug + Clone> EventMessage<Event, Parameters> {
-    pub fn new_generic(sender_id: ComponentId, event: Event, params: Option<&Parameters>) -> Self {
+impl<Event: GenericEvent, ParamProvider: Debug + Clone> EventMessage<Event, ParamProvider> {
+    pub fn new_generic(
+        sender_id: ComponentId,
+        event: Event,
+        params: Option<&ParamProvider>,
+    ) -> Self {
         Self {
             sender_id,
             event,
@@ -96,7 +98,7 @@ impl<Event: GenericEvent, Parameters: Debug + Clone> EventMessage<Event, Paramet
         self.event
     }
 
-    pub fn params(&self) -> Option<&Parameters> {
+    pub fn params(&self) -> Option<&ParamProvider> {
         self.params.as_ref()
     }
 
@@ -104,7 +106,7 @@ impl<Event: GenericEvent, Parameters: Debug + Clone> EventMessage<Event, Paramet
         Self::new_generic(sender_id, event, None)
     }
 
-    pub fn new_with_params(sender_id: ComponentId, event: Event, params: &Parameters) -> Self {
+    pub fn new_with_params(sender_id: ComponentId, event: Event, params: &ParamProvider) -> Self {
         Self::new_generic(sender_id, event, Some(params))
     }
 }
@@ -134,7 +136,7 @@ pub trait ListenerMapProvider {
     #[cfg(feature = "alloc")]
     fn get_listeners(&self) -> alloc::vec::Vec<ListenerKey>;
     fn contains_listener(&self, key: &ListenerKey) -> bool;
-    fn get_listener_ids(&self, key: &ListenerKey) -> Option<Iter<'_, ComponentId>>;
+    fn get_listener_ids(&self, key: &ListenerKey) -> Option<Iter<ComponentId>>;
     fn add_listener(&mut self, key: ListenerKey, listener_id: ComponentId) -> bool;
     fn remove_duplicates(&mut self, key: &ListenerKey);
 }
@@ -196,13 +198,13 @@ pub enum EventRoutingError {
 }
 
 impl<
-    EventReceiver: EventReceiveProvider<Event, ParamProvider>,
-    SenderMap: SenderMapProvider<EventSender, Event, ParamProvider>,
-    ListenerMap: ListenerMapProvider,
-    EventSender: EventSendProvider<Event, ParamProvider>,
-    Event: GenericEvent + Copy,
-    ParamProvider: Debug,
-> EventManager<EventReceiver, SenderMap, ListenerMap, EventSender, Event, ParamProvider>
+        EventReceiver: EventReceiveProvider<Event, ParamProvider>,
+        SenderMap: SenderMapProvider<EventSender, Event, ParamProvider>,
+        ListenerMap: ListenerMapProvider,
+        EventSender: EventSendProvider<Event, ParamProvider>,
+        Event: GenericEvent + Copy,
+        ParamProvider: Debug,
+    > EventManager<EventReceiver, SenderMap, ListenerMap, EventSender, Event, ParamProvider>
 {
     pub fn remove_duplicates(&mut self, key: &ListenerKey) {
         self.listener_map.remove_duplicates(key)
@@ -227,13 +229,13 @@ impl<
     }
 }
 impl<
-    EventReceiver: EventReceiveProvider<Event, ParamProvider>,
-    SenderMap: SenderMapProvider<EventSenderMap, Event, ParamProvider>,
-    ListenerMap: ListenerMapProvider,
-    EventSenderMap: EventSendProvider<Event, ParamProvider>,
-    Event: GenericEvent + Copy,
-    ParamProvider: Debug,
-> EventManager<EventReceiver, SenderMap, ListenerMap, EventSenderMap, Event, ParamProvider>
+        EventReceiver: EventReceiveProvider<Event, ParamProvider>,
+        SenderMap: SenderMapProvider<EventSenderMap, Event, ParamProvider>,
+        ListenerMap: ListenerMapProvider,
+        EventSenderMap: EventSendProvider<Event, ParamProvider>,
+        Event: GenericEvent + Copy,
+        ParamProvider: Debug,
+    > EventManager<EventReceiver, SenderMap, ListenerMap, EventSenderMap, Event, ParamProvider>
 {
     pub fn new_with_custom_maps(
         event_receiver: EventReceiver,
@@ -265,13 +267,13 @@ impl<
 }
 
 impl<
-    EventReceiver: EventReceiveProvider<Event, ParamProvider>,
-    SenderMap: SenderMapProvider<EventSenderMap, Event, ParamProvider>,
-    ListenerMap: ListenerMapProvider,
-    EventSenderMap: EventSendProvider<Event, ParamProvider, Error = GenericSendError>,
-    Event: GenericEvent + Copy,
-    ParamProvider: Clone + Debug,
-> EventManager<EventReceiver, SenderMap, ListenerMap, EventSenderMap, Event, ParamProvider>
+        EventReceiver: EventReceiveProvider<Event, ParamProvider>,
+        SenderMap: SenderMapProvider<EventSenderMap, Event, ParamProvider>,
+        ListenerMap: ListenerMapProvider,
+        EventSenderMap: EventSendProvider<Event, ParamProvider, Error = GenericSendError>,
+        Event: GenericEvent + Copy,
+        ParamProvider: Clone + Debug,
+    > EventManager<EventReceiver, SenderMap, ListenerMap, EventSenderMap, Event, ParamProvider>
 {
     /// This function will use the cached event receiver and try to receive one event.
     /// If an event was received, it will try to route that event to all subscribed event listeners.
@@ -353,11 +355,11 @@ pub mod alloc_mod {
     >;
 
     impl<
-        EventReceiver: EventReceiveProvider<Event, ParamProvider>,
-        EventSender: EventSendProvider<Event, ParamProvider>,
-        Event: GenericEvent + Copy,
-        ParamProvider: 'static + Debug,
-    >
+            EventReceiver: EventReceiveProvider<Event, ParamProvider>,
+            EventSender: EventSendProvider<Event, ParamProvider>,
+            Event: GenericEvent + Copy,
+            ParamProvider: 'static + Debug,
+        >
         EventManager<
             EventReceiver,
             DefaultSenderMap<EventSender, Event, ParamProvider>,
@@ -400,7 +402,7 @@ pub mod alloc_mod {
             self.listeners.contains_key(key)
         }
 
-        fn get_listener_ids(&self, key: &ListenerKey) -> Option<Iter<'_, ComponentId>> {
+        fn get_listener_ids(&self, key: &ListenerKey) -> Option<Iter<ComponentId>> {
             self.listeners.get(key).map(|vec| vec.iter())
         }
 
@@ -435,10 +437,10 @@ pub mod alloc_mod {
     }
 
     impl<
-        EventSender: EventSendProvider<Event, ParamProvider>,
-        Event: GenericEvent,
-        ParamProvider: Debug,
-    > Default for DefaultSenderMap<EventSender, Event, ParamProvider>
+            EventSender: EventSendProvider<Event, ParamProvider>,
+            Event: GenericEvent,
+            ParamProvider: Debug,
+        > Default for DefaultSenderMap<EventSender, Event, ParamProvider>
     {
         fn default() -> Self {
             Self {
@@ -449,10 +451,10 @@ pub mod alloc_mod {
     }
 
     impl<
-        EventSender: EventSendProvider<Event, ParamProvider>,
-        Event: GenericEvent,
-        ParamProvider: Debug,
-    > SenderMapProvider<EventSender, Event, ParamProvider>
+            EventSender: EventSendProvider<Event, ParamProvider>,
+            Event: GenericEvent,
+            ParamProvider: Debug,
+        > SenderMapProvider<EventSender, Event, ParamProvider>
         for DefaultSenderMap<EventSender, Event, ParamProvider>
     {
         fn contains_send_event_provider(&self, id: &ComponentId) -> bool {
@@ -588,8 +590,8 @@ pub mod std_mod {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::legacy::event_man_legacy::EventManager;
-    use crate::legacy::events_legacy::{EventU32, GenericEvent, Severity};
+    use crate::event_man::EventManager;
+    use crate::events::{EventU32, GenericEvent, Severity};
     use crate::params::{ParamsHeapless, ParamsRaw};
     use crate::pus::test_util::{TEST_COMPONENT_ID_0, TEST_COMPONENT_ID_1};
     use std::format;

satrs/src/events.rs

@@ -1,6 +1,4 @@
-//! # Event support module
-//!
-//! This is a legacy module. It is recommended to use [super::events] instead.
+//! Event support module
 //!
 //! This module includes the basic event structs [EventU32] and [EventU16] and versions with the
 //! ECSS severity levels as a type parameter. These structs are simple abstractions on top of the
@@ -20,7 +18,7 @@
 //! # Examples
 //!
 //! ```
-//! use satrs::events_legacy::{EventU16, EventU32, EventU32TypedSev, Severity, SeverityHigh, SeverityInfo};
+//! use satrs::events::{EventU16, EventU32, EventU32TypedSev, Severity, SeverityHigh, SeverityInfo};
 //!
 //! const MSG_RECVD: EventU32TypedSev<SeverityInfo> = EventU32TypedSev::new(1, 0);
 //! const MSG_FAILED: EventU32 = EventU32::new(Severity::Low, 1, 1);
@@ -33,9 +31,9 @@ use core::fmt::Debug;
 use core::hash::Hash;
 use core::marker::PhantomData;
 use delegate::delegate;
-use spacepackets::ByteConversionError;
 use spacepackets::ecss::EcssEnumeration;
 use spacepackets::util::{ToBeBytes, UnsignedEnum};
+use spacepackets::ByteConversionError;
 
 /// Using a type definition allows to change this to u64 in the future more easily
 pub type LargestEventRaw = u32;
@@ -386,7 +384,7 @@ impl UnsignedEnum for EventU32 {
         self.base.write_to_bytes(self.raw(), buf, self.size())
     }
 
-    fn value_raw(&self) -> u64 {
+    fn value(&self) -> u64 {
         self.raw().into()
     }
 }
@@ -445,7 +443,7 @@ impl<SEVERITY: HasSeverity> UnsignedEnum for EventU32TypedSev<SEVERITY> {
     delegate!(to self.event {
         fn size(&self) -> usize;
         fn write_to_be_bytes(&self, buf: &mut [u8]) -> Result<usize, ByteConversionError>;
-        fn value_raw(&self) -> u64;
+        fn value(&self) -> u64;
     });
 }
 
@@ -558,7 +556,7 @@ impl UnsignedEnum for EventU16 {
         self.base.write_to_bytes(self.raw(), buf, self.size())
     }
 
-    fn value_raw(&self) -> u64 {
+    fn value(&self) -> u64 {
         self.raw().into()
     }
 }
@@ -611,7 +609,7 @@ impl<SEVERITY: HasSeverity> UnsignedEnum for EventU16TypedSev<SEVERITY> {
     delegate!(to self.event {
         fn size(&self) -> usize;
         fn write_to_be_bytes(&self, buf: &mut [u8]) -> Result<usize, ByteConversionError>;
-        fn value_raw(&self) -> u64;
+        fn value(&self) -> u64;
     });
 }
 

satrs/src/executable.rs

@@ -55,35 +55,33 @@ pub fn exec_sched_single<
     let mut cycle_count = 0;
     thread::Builder::new()
         .name(String::from(executable.task_name()))
-        .spawn(move || {
-            loop {
-                if let Some(ref mut terminator) = termination {
-                    match terminator.try_recv() {
-                        Ok(_) | Err(TryRecvError::Disconnected) => {
-                            return Ok(OpResult::Ok);
-                        }
-                        Err(TryRecvError::Empty) => (),
-                    }
-                }
-                match executable.exec_type() {
-                    ExecutionType::OneShot => {
-                        executable.periodic_op(op_code)?;
+        .spawn(move || loop {
+            if let Some(ref mut terminator) = termination {
+                match terminator.try_recv() {
+                    Ok(_) | Err(TryRecvError::Disconnected) => {
                         return Ok(OpResult::Ok);
                     }
-                    ExecutionType::Infinite => {
-                        executable.periodic_op(op_code)?;
-                    }
-                    ExecutionType::Cycles(cycles) => {
-                        executable.periodic_op(op_code)?;
-                        cycle_count += 1;
-                        if cycle_count == cycles {
-                            return Ok(OpResult::Ok);
-                        }
+                    Err(TryRecvError::Empty) => (),
+                }
+            }
+            match executable.exec_type() {
+                ExecutionType::OneShot => {
+                    executable.periodic_op(op_code)?;
+                    return Ok(OpResult::Ok);
+                }
+                ExecutionType::Infinite => {
+                    executable.periodic_op(op_code)?;
+                }
+                ExecutionType::Cycles(cycles) => {
+                    executable.periodic_op(op_code)?;
+                    cycle_count += 1;
+                    if cycle_count == cycles {
+                        return Ok(OpResult::Ok);
                     }
                 }
-                if let Some(freq) = task_freq {
-                    thread::sleep(freq);
-                }
+            }
+            if let Some(freq) = task_freq {
+                thread::sleep(freq);
             }
         })
 }
@@ -112,53 +110,51 @@ pub fn exec_sched_multi<
 
     thread::Builder::new()
         .name(String::from(task_name))
-        .spawn(move || {
-            loop {
-                if let Some(ref mut terminator) = termination {
-                    match terminator.try_recv() {
-                        Ok(_) | Err(TryRecvError::Disconnected) => {
-                            removal_flags.iter_mut().for_each(|x| *x = true);
-                        }
-                        Err(TryRecvError::Empty) => (),
+        .spawn(move || loop {
+            if let Some(ref mut terminator) = termination {
+                match terminator.try_recv() {
+                    Ok(_) | Err(TryRecvError::Disconnected) => {
+                        removal_flags.iter_mut().for_each(|x| *x = true);
                     }
+                    Err(TryRecvError::Empty) => (),
                 }
-                for (idx, executable) in executable_vec.iter_mut().enumerate() {
-                    match executable.exec_type() {
-                        ExecutionType::OneShot => {
-                            executable.periodic_op(op_code)?;
+            }
+            for (idx, executable) in executable_vec.iter_mut().enumerate() {
+                match executable.exec_type() {
+                    ExecutionType::OneShot => {
+                        executable.periodic_op(op_code)?;
+                        removal_flags[idx] = true;
+                    }
+                    ExecutionType::Infinite => {
+                        executable.periodic_op(op_code)?;
+                    }
+                    ExecutionType::Cycles(cycles) => {
+                        executable.periodic_op(op_code)?;
+                        cycle_counts[idx] += 1;
+                        if cycle_counts[idx] == cycles {
                             removal_flags[idx] = true;
                         }
-                        ExecutionType::Infinite => {
-                            executable.periodic_op(op_code)?;
-                        }
-                        ExecutionType::Cycles(cycles) => {
-                            executable.periodic_op(op_code)?;
-                            cycle_counts[idx] += 1;
-                            if cycle_counts[idx] == cycles {
-                                removal_flags[idx] = true;
-                            }
-                        }
                     }
                 }
-                let mut removal_iter = removal_flags.iter();
-                executable_vec.retain(|_| !*removal_iter.next().unwrap());
-                removal_iter = removal_flags.iter();
-                cycle_counts.retain(|_| !*removal_iter.next().unwrap());
-                removal_flags.retain(|&i| !i);
-                if executable_vec.is_empty() {
-                    return Ok(OpResult::Ok);
-                }
-                let freq = task_freq.unwrap_or_else(|| panic!("No task frequency specified"));
-                thread::sleep(freq);
             }
+            let mut removal_iter = removal_flags.iter();
+            executable_vec.retain(|_| !*removal_iter.next().unwrap());
+            removal_iter = removal_flags.iter();
+            cycle_counts.retain(|_| !*removal_iter.next().unwrap());
+            removal_flags.retain(|&i| !i);
+            if executable_vec.is_empty() {
+                return Ok(OpResult::Ok);
+            }
+            let freq = task_freq.unwrap_or_else(|| panic!("No task frequency specified"));
+            thread::sleep(freq);
         })
 }
 
 #[cfg(test)]
 mod tests {
     use super::{
-        Executable, ExecutableWithType, ExecutionType, OpResult, exec_sched_multi,
-        exec_sched_single,
+        exec_sched_multi, exec_sched_single, Executable, ExecutableWithType, ExecutionType,
+        OpResult,
     };
     use bus::Bus;
     use std::boxed::Box;

satrs/src/hal/std/mod.rs

@@ -2,5 +2,5 @@
 pub mod tcp_server;
 pub mod udp_server;
 
-pub mod tcp_cobs_server;
-pub mod tcp_spacepackets_server;
+mod tcp_cobs_server;
+mod tcp_spacepackets_server;

satrs/src/hal/std/tcp_cobs_server.rs

@@ -1,7 +1,5 @@
 use alloc::sync::Arc;
 use alloc::vec;
-use cobs::CobsDecoderOwned;
-use cobs::DecodeError;
 use cobs::encode;
 use core::sync::atomic::AtomicBool;
 use core::time::Duration;
@@ -11,58 +9,40 @@ use std::io::Write;
 use std::net::SocketAddr;
 use std::vec::Vec;
 
-use crate::queue::GenericSendError;
-use crate::tmtc::PacketHandler;
+use crate::encoding::parse_buffer_for_cobs_encoded_packets;
+use crate::tmtc::PacketSenderRaw;
 use crate::tmtc::PacketSource;
 
-use crate::ComponentId;
 use crate::hal::std::tcp_server::{
-    ConnectionResult, ServerConfig, TcpTcParser, TcpTmSender, TcpTmtcGenericServer,
+    ConnectionResult, ServerConfig, TcpTcParser, TcpTmSender, TcpTmtcError, TcpTmtcGenericServer,
 };
+use crate::ComponentId;
 
 use super::tcp_server::HandledConnectionHandler;
 use super::tcp_server::HandledConnectionInfo;
 
 /// Concrete [TcpTcParser] implementation for the [TcpTmtcInCobsServer].
-pub struct CobsTcParser<PacketHandlerInstance: PacketHandler> {
-    sender_id: ComponentId,
-    owned_decoder: CobsDecoderOwned,
-    packet_handler: PacketHandlerInstance,
-    last_decode_error: Option<DecodeError>,
-}
+#[derive(Default)]
+pub struct CobsTcParser {}
 
-impl<PacketHandlerInstance: PacketHandler> CobsTcParser<PacketHandlerInstance> {
-    pub fn new(
+impl<TmError, TcError: 'static> TcpTcParser<TmError, TcError> for CobsTcParser {
+    fn handle_tc_parsing(
+        &mut self,
+        tc_buffer: &mut [u8],
         sender_id: ComponentId,
-        decoder_buf_size: usize,
-        packet_handler: PacketHandlerInstance,
-    ) -> Self {
-        Self {
+        tc_sender: &(impl PacketSenderRaw<Error = TcError> + ?Sized),
+        conn_result: &mut HandledConnectionInfo,
+        current_write_idx: usize,
+        next_write_idx: &mut usize,
+    ) -> Result<(), TcpTmtcError<TmError, TcError>> {
+        conn_result.num_received_tcs += parse_buffer_for_cobs_encoded_packets(
+            &mut tc_buffer[..current_write_idx],
             sender_id,
-            owned_decoder: CobsDecoderOwned::new(decoder_buf_size),
-            packet_handler,
-            last_decode_error: None,
-        }
-    }
-}
-impl<PacketHandlerInstance: PacketHandler> TcpTcParser for CobsTcParser<PacketHandlerInstance> {
-    fn reset(&mut self) {
-        self.owned_decoder.reset();
-    }
-
-    fn push(&mut self, data: &[u8], conn_result: &mut HandledConnectionInfo) {
-        for byte in data {
-            match self.owned_decoder.feed(*byte) {
-                Ok(Some(packet_len)) => {
-                    self.packet_handler
-                        .handle_packet(self.sender_id, &self.owned_decoder.dest()[..packet_len])
-                        .ok();
-                    conn_result.num_received_tcs += 1;
-                }
-                Ok(None) => (),
-                Err(e) => self.last_decode_error = Some(e),
-            }
-        }
+            tc_sender,
+            next_write_idx,
+        )
+        .map_err(|e| TcpTmtcError::TcError(e))?;
+        Ok(())
     }
 }
 
@@ -81,18 +61,22 @@ impl CobsTmSender {
     }
 }
 
-impl TcpTmSender for CobsTmSender {
+impl<TmError, TcError> TcpTmSender<TmError, TcError> for CobsTmSender {
     fn handle_tm_sending(
         &mut self,
         tm_buffer: &mut [u8],
-        tm_source: &mut (impl PacketSource<Error = ()> + ?Sized),
+        tm_source: &mut (impl PacketSource<Error = TmError> + ?Sized),
         conn_result: &mut HandledConnectionInfo,
         stream: &mut TcpStream,
-    ) -> Result<bool, std::io::Error> {
+    ) -> Result<bool, TcpTmtcError<TmError, TcError>> {
         let mut tm_was_sent = false;
-        // Write TM until TM source is exhausted or there is an unexpected error. For now, there
-        // is no limit for the amount of TM written this way.
-        while let Ok(read_tm_len) = tm_source.retrieve_packet(tm_buffer) {
+        loop {
+            // Write TM until TM source is exhausted. For now, there is no limit for the amount
+            // of TM written this way.
+            let read_tm_len = tm_source
+                .retrieve_packet(tm_buffer)
+                .map_err(|e| TcpTmtcError::TmError(e))?;
+
             if read_tm_len == 0 {
                 return Ok(tm_was_sent);
             }
@@ -111,7 +95,6 @@ impl TcpTmSender for CobsTmSender {
             current_idx += 1;
             stream.write_all(&self.tm_encoding_buffer[..current_idx])?;
         }
-        Ok(tm_was_sent)
     }
 }
 
@@ -125,8 +108,8 @@ impl TcpTmSender for CobsTmSender {
 ///
 /// Using a framing protocol like COBS imposes minimal restrictions on the type of TMTC data
 /// exchanged while also allowing packets with flexible size and a reliable way to reconstruct full
-/// packets even from a data stream which is split up. The server wil use the streaming
-/// [CobsDecoderOwned] decoder to parse for packets and pass them to a
+/// packets even from a data stream which is split up. The server wil use the
+/// [parse_buffer_for_cobs_encoded_packets] function to parse for packets and pass them to a
 /// generic TC receiver. The user can use [crate::encoding::encode_packet_with_cobs] to encode
 /// telecommands sent to the server.
 ///
@@ -135,19 +118,30 @@ impl TcpTmSender for CobsTmSender {
 /// The [TCP integration tests](https://egit.irs.uni-stuttgart.de/rust/sat-rs/src/branch/main/satrs/tests/tcp_servers.rs)
 /// test also serves as the example application for this module.
 pub struct TcpTmtcInCobsServer<
-    TmSource: PacketSource<Error = ()>,
-    TcHandler: PacketHandler<Error = GenericSendError>,
+    TmSource: PacketSource<Error = TmError>,
+    TcSender: PacketSenderRaw<Error = SendError>,
     HandledConnection: HandledConnectionHandler,
+    TmError,
+    SendError: 'static,
 > {
-    pub generic_server:
-        TcpTmtcGenericServer<TmSource, CobsTmSender, CobsTcParser<TcHandler>, HandledConnection>,
+    pub generic_server: TcpTmtcGenericServer<
+        TmSource,
+        TcSender,
+        CobsTmSender,
+        CobsTcParser,
+        HandledConnection,
+        TmError,
+        SendError,
+    >,
 }
 
 impl<
-    TmSource: PacketSource<Error = ()>,
-    TcHandler: PacketHandler<Error = GenericSendError>,
-    HandledConnection: HandledConnectionHandler,
-> TcpTmtcInCobsServer<TmSource, TcHandler, HandledConnection>
+        TmSource: PacketSource<Error = TmError>,
+        TcReceiver: PacketSenderRaw<Error = TcError>,
+        HandledConnection: HandledConnectionHandler,
+        TmError: 'static,
+        TcError: 'static,
+    > TcpTmtcInCobsServer<TmSource, TcReceiver, HandledConnection, TmError, TcError>
 {
     /// Create a new TCP TMTC server which exchanges TMTC packets encoded with
     /// [COBS protocol](https://en.wikipedia.org/wiki/Consistent_Overhead_Byte_Stuffing).
@@ -162,16 +156,17 @@ impl<
     pub fn new(
         cfg: ServerConfig,
         tm_source: TmSource,
-        cobs_tc_parser: CobsTcParser<TcHandler>,
+        tc_receiver: TcReceiver,
         handled_connection: HandledConnection,
         stop_signal: Option<Arc<AtomicBool>>,
     ) -> Result<Self, std::io::Error> {
         Ok(Self {
             generic_server: TcpTmtcGenericServer::new(
                 cfg,
-                cobs_tc_parser,
+                CobsTcParser::default(),
                 CobsTmSender::new(cfg.tm_buffer_size),
                 tm_source,
+                tc_receiver,
                 handled_connection,
                 stop_signal,
             )?,
@@ -190,7 +185,7 @@ impl<
             pub fn handle_all_connections(
                 &mut self,
                 poll_duration: Option<Duration>,
-            ) -> Result<ConnectionResult, std::io::Error>;
+            ) -> Result<ConnectionResult, TcpTmtcError<TmError, TcError>>;
         }
     }
 }
@@ -211,13 +206,14 @@ mod tests {
     };
 
     use crate::{
-        ComponentId,
         encoding::tests::{INVERTED_PACKET, SIMPLE_PACKET},
         hal::std::tcp_server::{
-            ConnectionResult, ServerConfig,
             tests::{ConnectionFinishedHandler, SyncTmSource},
+            ConnectionResult, ServerConfig,
         },
+        queue::GenericSendError,
         tmtc::PacketAsVec,
+        ComponentId,
     };
     use alloc::sync::Arc;
     use cobs::encode;
@@ -247,12 +243,17 @@ mod tests {
         tc_sender: mpsc::Sender<PacketAsVec>,
         tm_source: SyncTmSource,
         stop_signal: Option<Arc<AtomicBool>>,
-    ) -> TcpTmtcInCobsServer<SyncTmSource, mpsc::Sender<PacketAsVec>, ConnectionFinishedHandler>
-    {
+    ) -> TcpTmtcInCobsServer<
+        SyncTmSource,
+        mpsc::Sender<PacketAsVec>,
+        ConnectionFinishedHandler,
+        (),
+        GenericSendError,
+    > {
         TcpTmtcInCobsServer::new(
             ServerConfig::new(TCP_SERVER_ID, *addr, Duration::from_millis(2), 1024, 1024),
             tm_source,
-            super::CobsTcParser::new(TCP_SERVER_ID, 1024, tc_sender),
+            tc_sender,
             ConnectionFinishedHandler::default(),
             stop_signal,
         )
@@ -434,19 +435,17 @@ mod tests {
             generic_tmtc_server(&auto_port_addr, tc_sender.clone(), tm_source, None);
         let start = Instant::now();
         // Call the connection handler in separate thread, does block.
-        let thread_jh = thread::spawn(move || {
-            loop {
-                let result = tcp_server.handle_all_connections(Some(Duration::from_millis(20)));
-                if result.is_err() {
-                    panic!("handling connection failed: {:?}", result.unwrap_err());
-                }
-                let result = result.unwrap();
-                if result == ConnectionResult::AcceptTimeout {
-                    break;
-                }
-                if Instant::now() - start > Duration::from_millis(100) {
-                    panic!("regular stop signal handling failed");
-                }
+        let thread_jh = thread::spawn(move || loop {
+            let result = tcp_server.handle_all_connections(Some(Duration::from_millis(20)));
+            if result.is_err() {
+                panic!("handling connection failed: {:?}", result.unwrap_err());
+            }
+            let result = result.unwrap();
+            if result == ConnectionResult::AcceptTimeout {
+                break;
+            }
+            if Instant::now() - start > Duration::from_millis(100) {
+                panic!("regular stop signal handling failed");
             }
         });
         thread_jh.join().expect("thread join failed");
@@ -470,22 +469,20 @@ mod tests {
         let stop_signal_copy = stop_signal.clone();
         let start = Instant::now();
         // Call the connection handler in separate thread, does block.
-        let thread_jh = thread::spawn(move || {
-            loop {
-                let result = tcp_server.handle_all_connections(Some(Duration::from_millis(20)));
-                if result.is_err() {
-                    panic!("handling connection failed: {:?}", result.unwrap_err());
-                }
-                let result = result.unwrap();
-                if result == ConnectionResult::AcceptTimeout {
-                    panic!("unexpected accept timeout");
-                }
-                if stop_signal_copy.load(Ordering::Relaxed) {
-                    break;
-                }
-                if Instant::now() - start > Duration::from_millis(100) {
-                    panic!("regular stop signal handling failed");
-                }
+        let thread_jh = thread::spawn(move || loop {
+            let result = tcp_server.handle_all_connections(Some(Duration::from_millis(20)));
+            if result.is_err() {
+                panic!("handling connection failed: {:?}", result.unwrap_err());
+            }
+            let result = result.unwrap();
+            if result == ConnectionResult::AcceptTimeout {
+                panic!("unexpected accept timeout");
+            }
+            if stop_signal_copy.load(Ordering::Relaxed) {
+                break;
+            }
+            if Instant::now() - start > Duration::from_millis(100) {
+                panic!("regular stop signal handling failed");
             }
         });
         // We connect but do not do anything.

satrs/src/hal/std/tcp_server.rs

@@ -11,8 +11,8 @@ use std::io::{self, Read};
 use std::net::SocketAddr;
 use std::thread;
 
+use crate::tmtc::{PacketSenderRaw, PacketSource};
 use crate::ComponentId;
-use crate::tmtc::PacketSource;
 use thiserror::Error;
 
 // Re-export the TMTC in COBS server.
@@ -73,9 +73,11 @@ impl ServerConfig {
 }
 
 #[derive(Error, Debug)]
-pub enum TcpTmError<TmError> {
+pub enum TcpTmtcError<TmError, TcError> {
     #[error("TM retrieval error: {0}")]
     TmError(TmError),
+    #[error("TC retrieval error: {0}")]
+    TcError(TcError),
     #[error("io error: {0}")]
     Io(#[from] std::io::Error),
 }
@@ -114,29 +116,32 @@ pub trait HandledConnectionHandler {
 }
 
 /// Generic parser abstraction for an object which can parse for telecommands given a raw
-/// bytestream received from a TCP socket and extract packets from them. This allows different
-/// encoding schemes for telecommands.
-pub trait TcpTcParser {
-    /// Reset the state of the parser.
-    fn reset(&mut self);
-
-    /// Pushes received data into the parser.
-    fn push(&mut self, tc_data: &[u8], conn_result: &mut HandledConnectionInfo);
+/// bytestream received from a TCP socket and send them using a generic [PacketSenderRaw]
+/// implementation. This allows different encoding schemes for telecommands.
+pub trait TcpTcParser<TmError, SendError> {
+    fn handle_tc_parsing(
+        &mut self,
+        tc_buffer: &mut [u8],
+        sender_id: ComponentId,
+        tc_sender: &(impl PacketSenderRaw<Error = SendError> + ?Sized),
+        conn_result: &mut HandledConnectionInfo,
+        current_write_idx: usize,
+        next_write_idx: &mut usize,
+    ) -> Result<(), TcpTmtcError<TmError, SendError>>;
 }
 
 /// Generic sender abstraction for an object which can pull telemetry from a given TM source
 /// using a [PacketSource] and then send them back to a client using a given [TcpStream].
 /// The concrete implementation can also perform any encoding steps which are necessary before
 /// sending back the data to a client.
-pub trait TcpTmSender {
-    /// Returns whether any packets were sent back to the client.
+pub trait TcpTmSender<TmError, TcError> {
     fn handle_tm_sending(
         &mut self,
         tm_buffer: &mut [u8],
-        tm_source: &mut (impl PacketSource<Error = ()> + ?Sized),
+        tm_source: &mut (impl PacketSource<Error = TmError> + ?Sized),
         conn_result: &mut HandledConnectionInfo,
         stream: &mut TcpStream,
-    ) -> Result<bool, std::io::Error>;
+    ) -> Result<bool, TcpTmtcError<TmError, TcError>>;
 }
 
 /// TCP TMTC server implementation for exchange of generic TMTC packets in a generic way which
@@ -146,8 +151,7 @@ pub trait TcpTmSender {
 /// through the following 4 core abstractions:
 ///
 /// 1. [TcpTcParser] to parse for telecommands from the raw bytestream received from a client.
-/// 2. Parsed telecommands will be handled by the [TcpTcParser] object as well. For example, this
-///    parser can contain a message queue handle to send the packets somewhere.
+/// 2. Parsed telecommands will be sent using the [PacketSenderRaw] object.
 /// 3. [TcpTmSender] to send telemetry pulled from a TM source back to the client.
 /// 4. [PacketSource] as a generic TM source used by the [TcpTmSender].
 ///
@@ -159,10 +163,13 @@ pub trait TcpTmSender {
 /// 1. [TcpTmtcInCobsServer] to exchange TMTC wrapped inside the COBS framing protocol.
 /// 2. [TcpSpacepacketsServer] to exchange space packets via TCP.
 pub struct TcpTmtcGenericServer<
-    TmSource: PacketSource<Error = ()>,
-    TmSender: TcpTmSender,
-    TcParser: TcpTcParser,
+    TmSource: PacketSource<Error = TmError>,
+    TcSender: PacketSenderRaw<Error = TcSendError>,
+    TmSender: TcpTmSender<TmError, TcSendError>,
+    TcParser: TcpTcParser<TmError, TcSendError>,
     HandledConnection: HandledConnectionHandler,
+    TmError,
+    TcSendError,
 > {
     pub id: ComponentId,
     pub finished_handler: HandledConnection,
@@ -170,6 +177,7 @@ pub struct TcpTmtcGenericServer<
     pub(crate) inner_loop_delay: Duration,
     pub(crate) tm_source: TmSource,
     pub(crate) tm_buffer: Vec<u8>,
+    pub(crate) tc_sender: TcSender,
     pub(crate) tc_buffer: Vec<u8>,
     poll: Poll,
     events: Events,
@@ -179,11 +187,23 @@ pub struct TcpTmtcGenericServer<
 }
 
 impl<
-    TmSource: PacketSource<Error = ()>,
-    TmSender: TcpTmSender,
-    TcParser: TcpTcParser,
-    HandledConnection: HandledConnectionHandler,
-> TcpTmtcGenericServer<TmSource, TmSender, TcParser, HandledConnection>
+        TmSource: PacketSource<Error = TmError>,
+        TcSender: PacketSenderRaw<Error = TcSendError>,
+        TmSender: TcpTmSender<TmError, TcSendError>,
+        TcParser: TcpTcParser<TmError, TcSendError>,
+        HandledConnection: HandledConnectionHandler,
+        TmError: 'static,
+        TcSendError: 'static,
+    >
+    TcpTmtcGenericServer<
+        TmSource,
+        TcSender,
+        TmSender,
+        TcParser,
+        HandledConnection,
+        TmError,
+        TcSendError,
+    >
 {
     /// Create a new generic TMTC server instance.
     ///
@@ -203,6 +223,7 @@ impl<
         tc_parser: TcParser,
         tm_sender: TmSender,
         tm_source: TmSource,
+        tc_receiver: TcSender,
         finished_handler: HandledConnection,
         stop_signal: Option<Arc<AtomicBool>>,
     ) -> Result<Self, std::io::Error> {
@@ -242,6 +263,7 @@ impl<
             inner_loop_delay: cfg.inner_loop_delay,
             tm_source,
             tm_buffer: vec![0; cfg.tm_buffer_size],
+            tc_sender: tc_receiver,
             tc_buffer: vec![0; cfg.tc_buffer_size],
             stop_signal,
             finished_handler,
@@ -275,7 +297,7 @@ impl<
     pub fn handle_all_connections(
         &mut self,
         poll_timeout: Option<Duration>,
-    ) -> Result<ConnectionResult, std::io::Error> {
+    ) -> Result<ConnectionResult, TcpTmtcError<TmError, TcSendError>> {
         let mut handled_connections = 0;
         // Poll Mio for events.
         self.poll.poll(&mut self.events, poll_timeout)?;
@@ -305,7 +327,7 @@ impl<
                     Err(ref err) if err.kind() == io::ErrorKind::WouldBlock => break,
                     Err(err) => {
                         self.reregister_poll_interest()?;
-                        return Err(err);
+                        return Err(TcpTmtcError::Io(err));
                     }
                 }
             }
@@ -328,24 +350,58 @@ impl<
         &mut self,
         mut stream: TcpStream,
         addr: SocketAddr,
-    ) -> Result<(), std::io::Error> {
-        self.tc_handler.reset();
+    ) -> Result<(), TcpTmtcError<TmError, TcSendError>> {
+        let mut current_write_idx;
+        let mut next_write_idx = 0;
         let mut connection_result = HandledConnectionInfo::new(addr);
+        current_write_idx = next_write_idx;
         loop {
-            let read_result = stream.read(&mut self.tc_buffer);
+            let read_result = stream.read(&mut self.tc_buffer[current_write_idx..]);
             match read_result {
                 Ok(0) => {
-                    // Connection closed by client.
+                    // Connection closed by client. If any TC was read, parse for complete packets.
+                    // After that, break the outer loop.
+                    if current_write_idx > 0 {
+                        self.tc_handler.handle_tc_parsing(
+                            &mut self.tc_buffer,
+                            self.id,
+                            &self.tc_sender,
+                            &mut connection_result,
+                            current_write_idx,
+                            &mut next_write_idx,
+                        )?;
+                    }
                     break;
                 }
                 Ok(read_len) => {
-                    self.tc_handler
-                        .push(&self.tc_buffer[0..read_len], &mut connection_result);
+                    current_write_idx += read_len;
+                    // TC buffer is full, we must parse for complete packets now.
+                    if current_write_idx == self.tc_buffer.capacity() {
+                        self.tc_handler.handle_tc_parsing(
+                            &mut self.tc_buffer,
+                            self.id,
+                            &self.tc_sender,
+                            &mut connection_result,
+                            current_write_idx,
+                            &mut next_write_idx,
+                        )?;
+                        current_write_idx = next_write_idx;
+                    }
                 }
                 Err(e) => match e.kind() {
                     // As per [TcpStream::set_read_timeout] documentation, this should work for
                     // both UNIX and Windows.
                     std::io::ErrorKind::WouldBlock | std::io::ErrorKind::TimedOut => {
+                        self.tc_handler.handle_tc_parsing(
+                            &mut self.tc_buffer,
+                            self.id,
+                            &self.tc_sender,
+                            &mut connection_result,
+                            current_write_idx,
+                            &mut next_write_idx,
+                        )?;
+                        current_write_idx = next_write_idx;
+
                         if !self.tm_handler.handle_tm_sending(
                             &mut self.tm_buffer,
                             &mut self.tm_source,
@@ -370,7 +426,7 @@ impl<
                         }
                     }
                     _ => {
-                        return Err(e);
+                        return Err(TcpTmtcError::Io(e));
                     }
                 },
             }
@@ -446,11 +502,8 @@ pub(crate) mod tests {
                 .connection_info
                 .pop_back()
                 .expect("no connection info available");
-            assert_eq!(
-                last_conn_result.num_received_tcs, num_tcs,
-                "received tcs mismatch"
-            );
-            assert_eq!(last_conn_result.num_sent_tms, num_tms, "sent tms missmatch");
+            assert_eq!(last_conn_result.num_received_tcs, num_tcs);
+            assert_eq!(last_conn_result.num_sent_tms, num_tms);
         }
 
         pub fn check_no_connections_left(&self) {